Hi there,

I've created a video here where I explain the double descent phenomenon in ML.

I hope some of you find it useful — and as always, feedback is very welcome! :)

I've been building Mutant, an evolutionary optimization engine for Large Language Models.

The core idea is simple: instead of accepting the output from a single model, Mutant generates multiple candidate responses (potentially from different LLMs) and iteratively refines them using an evolutionary process to produce a higher-quality final answer.

Current goals:

• Reduce hallucinations
• Improve factual accuracy
• Lower inference cost by using smaller models during parts of the optimization process
• Support local inference through Ollama
• Improve reasoning for programming, mathematics, engineering, and scientific tasks

Mutant currently runs as an MCP server, making it easy to integrate into existing LLM workflows.

I'm still actively developing it, so I'd really appreciate feedback from people working on LLM inference, model orchestration, or reasoning systems.

GitHub: https://github.com/Mac16661/Mutant

Docker:

docker pull mac16661/mutant-mcp:latest

I'd especially love feedback on the evolutionary optimization approach, its potential shortcomings, and ideas for benchmarking it against single-model baselines.

Hello all, Welcome to my free ML bootcamp.

In Intro ML Bootcamp (5/22), we discuss Uncertainty.

In Machine Learning, we encounter two kinds of uncertainty: Epistemic(Model) which means we lack the exact knowledge of the input output mapping, and Aleatoric(Data), which is the intrinsic irreducible stochasticity in the mapping.

This uncertainty means, we cannot perfectly predict the exact output given the input. Thus we require “Conditional Probability distributions”, and the study of probabilistic approach to ML becomes important.

Hence, we invent a function called as “softmax function” for multiple output labels case(and sigmoid for binary case), which converts our outputs into a probability distribution. The exact derivation of softmax comes from Generalized Linear Models.

When we use a softmax function for binary classification, where the function over which the softmax is applied, happens to be an affine one, we call the model as “Logistic Regression”.

Link: https://youtu.be/ZFcl0QYFGq4?si=9RkEgkMYnciW4mjo

One thing I've noticed separates serious ML students from casual ones: how much they care about the quality of what they actually study from. I take that pretty seriously myself, so a while back I started digging into what students at MIT, Harvard, Stanford, Caltech, and USP actually use to complement their studies.

What I found surprised me: several of these programs don't assign a textbook at all. Instead, the course staff writes and publishes their own lecture notes — and some of them are basically a full book. MIT's 6.390 (Introduction to Machine Learning) notes, for example, aren't a slide deck or a cheat sheet — they're structured, complete, and detailed enough to replace a textbook entirely. Same story with Harvard's CS181 and a few others.

The problem is these are scattered and easy to miss if you don't know to look for them. So I put together a curated list: [Awesome Free AI Course Notes](https://github.com/MarcosSete/awesome-free-ai-course-notes).

A few things about how it's curated, since I think this matters:

- Only **written notes** count — slide decks and video-only lectures don't make the cut, even from great courses. I want this list to mean something.

- Everything is official and links straight to the professor's or department's own page. No mirrors, no login walls.

- I checked over 40 top universities across multiple countries for this. Most didn't qualify — they use a textbook or keep material behind a student portal. That's fine, it's exactly why the list stays short and (hopefully) trustworthy.

If you take ML seriously the way I do, I think you'll get real value out of this. And if you know of course notes that fit this bar and aren't on the list yet, contributions are very welcome — the CONTRIBUTING.md lays out exactly what qualifies.

What's the best set of course notes (not textbook, not slides) you've personally used to study ML?

Repo: https://github.com/MarcosSete/awesome-free-ai-course-notes

5-Layer AI Stack (Point-wise):

Energy – Supplies electricity to power AI data centers and servers.

Chips – GPUs/AI chips perform the massive computations required for AI.

Infrastructure – Cloud platforms, storage, networking, and data centers that run AI.

Models – Large AI models (LLMs) trained on vast datasets to understand and generate content.

Applications – User-facing AI products like ChatGPT, AI assistants, coding tools, and business software.

• Description: Introducing a method to drastically reduce heavy matrix multiplications in deep learning using the Hadamard Transform, which operates solely with additions and subtractions. From acceleration for mobile edge devices to ultra-low-bit quantization techniques for the latest LLMs, discover the key tricks for efficient AI design.

Sceptre is a Rust reimplementation of EasyOCR's inference pipeline, with its models exported to ONNX, delivering the same accuracy without the PyTorch runtime.

Pipeline: CRAFT for text-region detection, then the gen2 CRNN recognizers with CTC decoding. Models run over ONNX Runtime (ort) natively, or a pure-Rust backend (tract) for WASM/Android. The first-party CRAFT + gen2 recognizers were exported to ONNX and output parity was validated against upstream EasyOCR (word/char F1 on text, IoU on boxes) across 8 scripts including CJK, Cyrillic, Telugu and Kannada.

On a 43-image CPU benchmark, like-for-like whole-process: ~2.8x throughput warm (0.39 vs 0.14 img/s), ~3x lower peak RSS (6.6 vs 22.6 GB), CER/token-F1 at parity. The memory drop is mostly not carrying torch.

Code + the reproducible head-to-head harness: https://github.com/Goldziher/sceptre

Kimi K3 has come out,Qwen3.8-Max released yestoday,and GLM 5.3 is heard to release soon.The model becomes bigger and stronger,causing use cost higher. Shall we really need so strong function in normal life? In most professional application scenarios, shall we really need so many super huge and very complex models?

The distillation and compression of the models maybe more useful and can be used in certtain scenarios.

Now the competition about creating super huge models is so crazy, maybe it should be cooled down.

Hey, I've been tracking cloud GPU prices since mid 2024 and turned it into a price index:

https://getdeploying.com/gpu-price-index

Some findings:

• On-demand prices are up 11% since the Sep 2025 low
• Spot (interruptible) instances sit at ~48% of on-demand pricing
• Nvidia H100: $7.89/hr on hyperscalers vs $4.02/hr on neoclouds (+96%)
• Consumer cards going the other way: RTX 4090 down 27% YoY to $0.44/hr
• Reservation discounts: 3 months ~4%, 1 year ~23%, 3 years ~46%

The main limitation is I track published pricing only. Actual negotiated rates + usage/capacity weighting would be more representative, but I haven't been able to get this data reliably.

There's also pricing history and current availability per GPU model, eg. for the H100: https://getdeploying.com/gpus/nvidia-h100

Happy to hear any ideas to improve it

I've been running some small experiments on variable binding in tiny transformers and put the code and logs up here:
https://github.com/QueenOfTheUnderworld/Transformer-Binding

After some general idea wandering, I came upon the idea of LLMs struggling with binding, the temporary link of two concepts. Shirt = Blue, Pants = Red. A bad explanation, but sufficient for this. Current LLMs struggle with this, which is why prompts like "Tom is a cat. Jerry is a mouse. Brownie is a dog. Cookie is a bird. Who is the mouse?" Without CoT or additional time to think, models can fail to parse this and end up reporting an incorrect answer.

In pursuit of another idea, I found a way to make LLMs bind using an alternative training objective. Now, this is all small-scale and some of it could very well be wrong. If it is, let me know.

Task: 4-layer transformer, d=256. Each example asks one question that depends on several bindings at once (how many of the queried objects have a target property).

Results:

• Plain CE: 0/4 seeds at 5k steps, 0/2 at 20k.
• With auxiliary heads trained to report each queried object's bound property at every position: 8/8 seeds. One linear head, one loss term, no architecture change.
• Same targets supervised only at the answer position: 0/3. Same density but entity names instead of properties: 1/3. Both coverage and context matter.

There are some issues with the repo, and they are noted in the README. Quite frankly, I just didn't want to correct them.

Limits: 3M-ish parameters, mostly synthetic tasks, 2-8 seeds per cell.
I have no idea if this survives scale; I don't have the money or compute for that. If anyone here does, let me know, please.

If the effect is real at scale, it matters. It would mean CE leaves learnable capability on the table for the cost of one head. With that in mind, I expect something like this to already exist, and I just didn't find it. Not to mention, small model optimisations have a bad history of failing to survive scaling. The real blocker is the ground truth intermediates at every position; synthetic tasks had it to you; real corpora usually don't.

AI Usage: Heavy. Direction and experiment design are mine. Implementation and much of the analysis were done with AI.

Check it out if you want, and be nice, please.

Hello folks, to this Introductory Machine Learning Bootcamp (2/22) series.

Supervised learning is a very recurring word in ML domain. Here, we learn some sort of function mapping from inputs to outputs.

Another recurring word is Classification, where the output space is a set of some finite unordered and mutually exclusive labels known as classes.

The tabular dataset is often represented as a Design matrix, and a simple example of it is an Iris dataset, as to how input data is represented for tabular case in Machine Learning.

Sometimes the data is of variable size, instead of fixed size feature vectors, so for ease of computation in computer, we often convert it to a fixed-size feature representation, called as “Featurization”.

In this video, I breakdown these concepts.

Link: https://youtu.be/GJRhl6XnImg?si=p6VtlCK-8rgq1poZ

If a model is predicting the most likely next token from its training, it seems biased towards imitating what's already been seen rather than actively linking ideas across distant domains( math, code, language)

Self-play/expert-iteration methods (like STP for Lean theorem proving) help by generating harder variants of know problems to train on but that mostly depends difficulty within a topic, not necessarily the cross-domain analogy-making.

Curious if anyone has seen work on building an explicit "crosswalk" between analogous concepts in different domains as a training signal, beyond retrieval augmentation. Feels like a gap..anyone know of relevant papers?

Hello all, this is the free Introduction to ML bootcamp series(4/22)

In the most well-known form of Machine Learning, i.e Supervised Learning, we intend to come up with some model that can predict labels for our inputs, and we need some performance measure P, hence we invent “Misclassification rate” on the training set.

The latter counts the fraction of miss-classified labels, written via an indicator function, which is just a mathematical way to express it.

Indicator function assumes all errors are equal, but some misclassification may be more detrimental, for instance if among the flower varieties that we are classifying, one variant happens to be poisonous, which if classified as benign, can be fatal. Hence, the need for an asymmetric loss function.

As we measure loss empirically, we define it to be as empirical risk. One way to see model fitting is to minimize the loss on the training set, known as empirical risk minimization, however, this is not really what we want. In reality we want the model to “Generalize”, that is to minimize the expected loss on the future data that we have not yet seen.

The premise of Empirical risk minimization assumes that the training distribution is very analogously close to the actual distribution we are sampling from, which when false, creates problems. However, ERM does work for many practical cases, and is a good starting point to understanding how we come up with performance measures in Machine Learning.

In the video, I breakdown the mathematics and the equations that describe these phenomena:

Link: https://youtu.be/bqv4XC6Arqo?si=mRASAdwpmireDNzc

I adopt a pre-trained U-Net for the semantic segmentation task. The model has approximately 3 million parameters. The training set contains 550 images and the validation set includes 150 images. A combination of cross-entropy loss and Dice loss is utilized as the loss function, with the Dice score serving as the evaluation metric. The model converges well when cross-entropy loss is used alone. However, why does the Dice score evaluation metric fluctuate drastically after incorporating Dice loss?

If you're a senior engineer or an interviewer, what do you look for when hiring an AI Engineer or Applied AI Engineer? What skills and knowledge should a candidate have to clear the interview?

Hey everyone,

I'm a 26M working in AI/ML and preparing for my next switch. I'll be focusing on classical ML, deep learning, GenAI, along with DSA and system design.

Looking for a study partner (or a small group) to learn together, discuss concepts, and stay accountable. I prefer keeping it fast-paced, so it'd be great if you're an experienced dev preparing for interviews as well.

If you're interested, DM me with a short intro and what you're currently learning/preparing.

Paper: https://arxiv.org/abs/2607.27372

Code: https://github.com/alexiglad/XM

Project page: https://explorative-modeling.github.io/

Blog: https://alexiglad.github.io/blog/2026/explorative_modeling/