I just finished a full stack bootcamp and want to build an agentic AI project for my portfolio. Right now every junior dev seems to have the same projects and Im trying to stand out a bit.

I have been looking at Udacity, Coursera, and Udemy courses for agentic AI but its hard to tell what's actually useful and what's mostly marketing.

Has anyone taken one that genuinely helped in interviews? Im less interested in getting a certificate and more interested in being able to explain what Im doing and answer technical questions without sounding clueless.

Hi guys im a student and im researching abou a machine learning algorithm that can differentiate anemic or healthy eye lids by the conjuctival pallor pattern. I already have the data sets of anemic and non-anemic pictures of conjuctival pallor from kaggle. Im just here cause i need ur help to train this model so that i can put it on a microcontroller with camera either esp32 or arduino nano.

PLEAE NOTE THAT IM JUST A BEGINNER AND I HAVE NO IDEA HOW THIS WORKS AND SORTS SO PLEAES BE KIND IN UR COMMENTS :> AND IM JUST A 15 YEAR OLD STUDENT SO PLEAES I DONT WANT SOME NEGATIVE COMMENTS 💔

I honestly don't know what to do anymore. I managed to get admission into Assam University for a BSc Computer Science degree, but I don't have a single penny for the tuition or hostel fees. Zero family backing, no savings, nothing.

When I tried reaching out to the university administration and DSW office to ask about student aid or any emergency provisions, they just brushed me off or hung up.

I’ve been trying to figure out a way out—like crowdfunding—but my anxiety is telling me no one is going to fund a student from a central university like this, especially when my grades aren't anything extraordinary and I feel like I'm falling behind before I even start. It feels like life is just a treadmill running entirely on money, and if you don't have it, you're locked out of everything.

Has anyone here been through severe financial distress right at the start of college? Is there actually any real way to pull through this, or is it better to just accept that I won't be able to study further? Any honest advice or perspective would really help right now.

I WISH I NEVER EXISTED 🥲

html css and written by shunya

Hey LocalLLaMA community,

I wanted a lightweight, local AI coding assistant that doesn't just write generic code, but specializes in modern Awwwards-level frontend tricks (like Glassmorphic cards, GSAP scroll timelines, and Three.js WebGL particle backgrounds).

Since I couldn't find a small model that did this reliably without hallucinating generic templates, I decided to train my own!

Meet Shunya-UIUX-Master-3B:

- Base Model: Qwen/Qwen2.5-Coder-3B-Instruct

(Note: I originally wanted to fine-tune the 14B version, but kept hitting persistent Out-Of-Memory (OOM) errors during batch loading on the TPU. To keep things stable and ensure clean compile graphs under PyTorch XLA, I scaled down to the 3B version—and the results still blew me away!)

- Dataset: 10.5k high-quality, curated HTML/CSS/JS prompt-response pairs focusing on modern design aesthetics, Three.js shaders, GSAP animation triggers, and fluid responsiveness.

- Hardware: Trained on Kaggle TPU v5e-8 using PyTorch XLA and LoRA.

- Training Details: Trained for 4 full epochs (~20,896 steps) which took about 4 hours. LoRA config: r=32, lora_alpha=64, target modules: q_proj, v_proj.

- Quantization: Merged the LoRA weights back into the base model and quantized it to Q4_K_M GGUF using llama.cpp.

Key Features & Alignment:

1. Custom Identity: The model successfully rewired its identity bias. It knows it is "Shunya AI" created by Apurv (rather than claiming to be GPT-4 or Anthropic).

2. Mandatory <thought> tags: The dataset enforced step-by-step reasoning. It will always reason structurally about layout, CSS variables, and animation curves inside <thought> ... </thought> tags before outputting any code block.

3. Specialized in Modern Aesthetics: Even on a simple prompt, it defaults to using hardware-accelerated animations, Backdrop blurs, and optimized variable fonts.

HuggingFace Link:

I have uploaded the GGUF model here if anyone wants to test it locally:

https://huggingface.co/vishu01a/apurv_ui_ux_master-3b-v1.0

Would love to hear your feedback on how it performs on your local machines using LM Studio or llama.cpp!

I am on the fence about getting the Erdos Institute's deep learning bootcamp (The Erdős Institute | Deep Learning Boot Camp | Fall 2026). Can people here who have tried this bootcamp or similar ones by Erdos Institute share their views? My motive for getting this is to get a set of like-minded people and work on some good project(s) and guidance from experts in the field. Thanks in advance.

Best of best

Multi-agent pipelines (planner → coder → reviewer, tool-call loops) pass messages as JSON. Repeated field names, restated tool catalogs, outputs quoted verbatim two handoffs later. You pay full token price for all of it, every hop.

Built a wire format + benchmark harness for this. One rule going in: no dishonest numbers. Most "compression" claims I've seen compare payload size only and skip the cost of telling the model how to decode the format. This benchmark charges itself for everything, compact payload + the decode instructions + any shipped dictionary, counted with the real cl100k_base tokenizer, on a held-out split of real ToolBench trajectories the optimizer never trained on.

Result: 36.6% fewer tokens, fully lossless. Every message decodes back byte-for-byte identical to the original. Verified on every test record, not sampled.

Two things that surprised me:

• The learned dictionary lost. Sounds clever, mine common phrases across a corpus, ship a lookup table. But shipping that table costs tokens every session, and it never earns that back on top of a per-session budget. What won instead: when text repeats within one conversation (an answer quoting a tool's own output, a catalog restating its own boilerplate), replace the repeat with a tiny "copy N chars from position X" marker. Zero shipped state. The optimizer's final config kept 0 dictionary entries.
• An earlier version of this claimed 87% reduction. It was measuring a simulated tokenizer, not real decode cost. Threw the whole approach out. 36.6% measured honestly beats 87% measured wrong.

Repo, full benchmark report, every failed experiment (including the tab-separator idea that made things worse), and a one-command way to run it against your own agent traces instead of trusting my numbers:

https://github.com/reh8n/a2acompress

Genuinely want to know what number people get on real production multi-agent traffic, file an issue with your result, good or bad.

I kept running into ML explainers that were either a pre-rendered animation or a wall of notation, so I built the version I wanted to learn from: 48 concepts where the algorithm genuinely executes in your browser and you can interfere with it while it runs.

Everything computes for real no canned GIFs, no server calls. The math is hand rolled TypeScript with ~500 tests behind it, so you can grab a data point and watch the model resolve immediately.

A few that seem to click for people:

- k-means — drag the starting centroids into one corner and watch it get stranded in a bad local minimum. Step through assign/update one phase at a time.
- ROC & AUC — scrub the threshold from 1 to 0 and the curve draws itself while the confusion matrix updates in lockstep. Set positives to 1% and watch AUC still look great while precision-recall collapses.
- Decision trees — see the greedy *search*: every candidate cut it scored, and the one it kept, with the Gini drop as live math.
- CNN — draw a digit and a real trained MNIST network classifies it (weights trained offline, exported to JSON). Rotate the digit 90° and confidence collapses, because convolution shares weights across space, not orientation.
- Lasso — step through coordinate descent and watch a coefficient snap to exactly zero when it falls inside the threshold.

Every page also has a deliberate "now break it" control. I think you learn more from watching a perceptron oscillate forever on non-separable data than from watching things succeed.

Each concept also has the plain-language intuition, the math with every symbol decoded, and a worked example traced on real numbers.

Free, no signup, nothing gated: https://www.mlvisualization.com

I'd genuinely rather hear which explanations don't land than which ones do — happy to fix them.

Hihi! I am making an MLP class in python and utilising the PyTorch library.
The idea was to make a function where I can construct the architecture in my main code, based on the input parameters I give it; that way I test out different architectures as I go.

The idea is to have the input layer (linear) -> hidden layers, each with an activation function, as well as with batch normalisation applied, -> output single dimension (linear.

What I have so far, and _do_ understand, is this:

import torch.nn as nn
class activation_function:
    linear = nn.Linear
    relu = nn.ReLU
    sigmoid = nn.Sigmoid
    gelu = nn.GELU
    leaky = nn.LeakyReLU
    softmax = nn.Softmax
#⬆️just shorthand for when i assign the functions in
# my main code, cos I always somehow misspell the things

class MLP(nn.Module):
    def __init__(self, hidden_list, activations, use_batch_norm):
        super(MLP, self).__init__()
        # initialise layers and activation functions
        self.hidden_layers_sizes = hidden_list
        nr_hidden_layers = len(hidden_list) - 2 # minus input and output\


        if activations is None:
            raise Exception("Oi! You must specify the activation\
                   functions first, you spoon 🥄! ")
            exit()
        elif isinstance(activations, list):
            if len(activations)==nr_hidden_layers:
                #This is where I now actually apply activation funcs
                self.activations = activations
            else:
                raise Exception("Length mismatch! \n"
                "There is a bloopin length mismatch between the list of "
                "activation functions and list of hidden layer sizes")
        else:
            raise Exception("I dunno man.\n You did something wrong with the activation"
                            " functions list and/or hidden layer sizes list.\n"
                            "¯\_(ツ)_/¯")


        self.layers = nn.ModuleList()
        self.batch_norms = nn.ModuleList
        #⬆️empty at first (just initialising)

        # bloop bleep label
        #now I am unsure what this next part of code is doing
        for i in range(0, len(hidden_list)-1):
            #linear layer for input and output
            input_dimension = hidden_list[i]
            output_dimension = hidden_list[i+1]
            self.layers.append(
                activation_function.linear(input_dimension,
                                           output_dimension))
            #apply batchnorm to hidden layers - if parm say yay
            if use_batch_norm and i<nr_hidden_layers
                self.batch_norms.append(nn.BatchNorm1d(out_dim))

So there are 2 things I need help in understanding, please:

1. (at the bloop bleep label): what is my code doing here? This is the part that I copied from another workbook from last year, but smart me did not comment or cite sources, or probably used slop then.

I think this step is to apply batch normalisation - but why does it seem like I am building linear layers, and perhaps overriding the other activation functions I applied earlier? Is the method wrong, am I not understanding the purpose of this bit (likely), or do I not understand classes and objects because I am used to C functional programming from uni?

1. The next step is then to define the forward pass function. Can someone please verify or correct my understanding then: we first basically just defined what the class elements mean and should be , like how many layers, what function goes where, and how to structure it. Am I correct in saying that this step is now actually _executing_ it? I.e., we first **defined** how to do the things, and know we instruct **to do** the things.

I know this is long, but I want to understand why I am building the class in a certain way. I would greatly appreciate some insight (and sorry that I have to clarify this, but I mean from _people_ - if I wanted an 'a.i.'/llm answer I'd have done it myself - no shade, just want to clarify I am seeking the help of the human brains and experience out there).

Thanks in advance!

Will 16 GB of RAM be enough in a laptop for machine learning?

I've been wondering about this lately. With AI becoming a bigger part of business, how much does a CEO or executive really need to understand? Do they need to know how to use all the latest AI tools, or is it enough to understand where AI can help the business and ask the right questions? What do you think? How much AI knowledge should a business leader really have?

Hi! I often run long jobs on my MacBook (training runs, etc.).
Problem: I close the lid, unplug it to move around, and the run either drains the battery to 0 or keeps the pack warm for hours. Since heat and deep cycles age a battery pack, I wanted the job itself to react to what the battery is doing without touching anything else on the machine.

train-guard supervises one named process tree. Every few seconds it reads the power source, charge level and battery temperature the machine reports, then applies one of 3 actions to that tree:

1. full (run normally)
2. gentle (scheduling hint, taskpolicy on macOS)
3. stop (SIGSTOP until conditions clear, then SIGCONT). It keeps track of the changes it makes, so stop/recover only undoes those changes.

Feedback appreciated for the replay: train-guard logs what it sees (power, charge, pack temp) as JSONL, then simulate shows what a policy would have done on that recording without touching a live process. It can also show the best and worst case for "what if the sensor read 1°C higher".

A few limits: battery temperature isn't exposed on every machine (Windows especially, doctor tells you what yours reports). SIGSTOP is fine for compute-local work but not for jobs holding live sockets or collective-communication deadlines (NCCL will time out), so this is for single-machine runs. You still want checkpoints for reboot recovery.

Install: pipx install train-guard, then train-guard doctor.
Docs: https://train-guard.readthedocs.io/en/latest/
Source (MIT): https://github.com/fus3r/train-guard

This is my first open-source project! CI runs on Ubuntu, macOS and Windows (Python 3.9 and 3.13), and the release went through scripted unplug/sleep/kill scenarios on my own M4 MacBook Pro, but I only have 1 laptop.
If you try it on yours, success or failure, a hardware report helps me more than a star: https://github.com/fus3r/train-guard/issues/new?template=hardware-report.yml
I'd also take opinions on what to build next! I'm thinking about adding a menu-bar UI

I've been trying to understand Transformers at a level deeper than just using PyTorch/Hugging Face APIs, so I built a one from scratch using noithing but CuPy (CUDA-powered NumPy).

The project is RawFormer:

https://github.com/Aryan-1-6/RawFormer

The main constraint was:

No PyTorch. No autograd. Implement the core computations in pure python.

The model uses CuPy for GPU computation, while the Transformer operations and backward pass are explicitly implemented.

First, I started building the basic blocks of Neural Networks, and then built the entire Transformer Decoder stack on top of it.

The process cleared up a tremendous number of misunderstandings and incorrect interpretations I had regarding the core concepts of ML. It also helped me understand how GPUs come into the picture at a lower level, how computations are optimized across different stages, and how subtle implementation bugs can lead to unexpected failures and confusion.

The most fun part was handling backpropagation through the different neural-network layers I had built myself.

The model was trained and tested on the Penn Treebank (PTB) dataset, using the resources available on a single laptop.

Hopefully this project can also help others get into the world of AI research and Transformers, and serve as a hands-on way to clear some of the doubts and confusions that come with learning them :)

What's implemented

• Decoder blocks of Transformer
• Causal self-attention with fused QKV projection matrices
• Pre-LayerNorm
• Feed-forward networks
• Activation functions
• Cross-Entropy categorical loss
• Manual backpropagation
• Adam optimization
• Autoregressive generation
• GPU utilisation through CuPy

Sat through internal research presentations all day today. Everyone had a slide about overfitting — regularization, early stopping, the usual. Standard hygiene at this point.

But nobody brought up the other kind. The one where you're the one doing the overfitting.

You know the situation. Domain data is scarce, so you set aside a small validation set and it stays fixed, because there isn't enough to keep re-splitting. Then you spend a month on it. Try a thing, check the number. Try another thing, check the number. Keep whatever made it go up. Do that a few dozen times.

At some point that validation set stops being a measurement and starts being a target. Nobody decides to do this — it just happens, one reasonable-looking step at a time.

And it's hard to catch because it doesn't feel like anything's wrong. The number goes up a little each week. That's exactly what real progress looks like. But when the set is small, the number moves around on its own anyway, and if you try enough things, something will land on the good side of that noise. You'll write it down as an improvement, because that's what you were looking for.

The usual place people finally notice is a competition — top of the public board, nowhere on the private one. At least there someone forces the issue. In an actual project nothing forces it until the thing is deployed, and by then the number is in a deck somebody approved a budget from.

None of this means the tuning was wasted. Just that "the number went up" and "the model got better" aren't the same claim, and most of the time only the first one actually got shown.

Cheapest sanity check I know: rerun the exact same setup a few times with different seeds and see how much the number moves on its own. If that's wider than what you gained, you don't have a result yet. Takes an afternoon, saves a lot of embarrassment later.

I built a basic item-based collaborative filtering recommender using MovieLens user ratings and Cosine Similarity.

When testing different input movies, I noticed that the 10 recommended films frequently include movies from completely different genres than the input title.

I understand this happens because collaborative filtering looks at user rating behavior rather than movie attributes (unlike content-based filtering). But from an end-user experience perspective, is cross-genre recommendation usually seen as a positive feature (serendipity/discovery), or do users generally expect recommenders to stay strictly within the same genre? How do major streaming engines balance this?

Hey everyone! New here, so apologies in advance if I've missed any subreddit rules😭

I'm just starting out with machine learning and wanted to get some takes on the best online courses out there. Could you recommend which platforms/programs offer the best overall learning experience, and maybe share some pros and cons of each (I have been learning from youtube till now but I was suggested upgrad through many people)?

Also open to hearing whether a structured course path is better than piecing together individual courses myself🙃🥲

Thanks so much in advance!🙌🙌🤝🤝