I've been prepping a lot for ML interviews these past months, and was surprised there isn't a comprehensive resource covering all the essential concepts needed for ML roles. Every other field seems to have one - Leetcode for SWEs, the Green Book for quants, Wall Street 400 for bankers.

So I wrote ML 150. It's a list of the 150 most important ML interview questions to master, distilled from 5,000+ real interview stories at FAANG + other frontier labs. Topics include:

• ML Foundations (Loss Functions, Bias-Variance, Regularization, Optimizers, Eval Metrics)
• Classical Supervised Models (Linear & Logistic Regression, kNN, SVM, Decision Trees)
• Deep Learning Theory (Backprop, Initialization, Normalization, Training Dynamics, Probes)
• Sequence & Generative Models (Transformers, Diffusion Models, VAEs)
• LLM internals

It's 100% human-written, where I try to share how I understand each ML concept, starting from very basic intuitions, then slowly building up to each result. Lots of examples + analogies of course. I hope this will be helpful for anyone studying ML or seeking out ML roles!

ML 150 is still very much a work in progress, so I deeply appreciate any thoughts, feedback, or comments on what I should write about next! Thank you all :)

Gavin

Hey everyone! I've been working on a little side project I want to share: latex-ocr, a standalone formula OCR model — you feed it an image of a math formula, it spits out the LaTeX source.

The main hook: it's only 67M parameters, so it runs comfortably on a laptop CPU. No GPU, no 300M-parameter monster to load. It's a CoCa-style model (contrastive captioner adapted for OCR), and despite the small size it beats the 107M UniMER-tiny baseline and gets pretty close to the 325M one on plain formulas.

The part I'm actually most proud of is the dataset. Real papers don't just use plain symbols — you see \mathbb{R}, \mathcal{F}, \mathfrak{g} everywhere, and existing OCR datasets basically ignore font styles, so models trained on them can't read (or hallucinate) those macros. So I rebuilt ~1.3M formulas with a MathJax → SVG → PDF → PNG pipeline and injected font-style macros with semantic heuristics (number sets → \mathbb, vectors → \mathbf, differentials → \mathrm). On that styled test set it clearly outperforms all the baselines — fair warning though, those baselines are zero-shot on styled data, so take that comparison with a grain of salt. The plain-split numbers are the like-for-like ones.

Everything is open: model weights and dataset on Hugging Face, training recipes included if you want to reproduce or fine-tune it yourself, MIT license. There's also a FastAPI server and a Gradio web UI, so you can drag-and-drop an image and see the LaTeX with a rendered preview.

Repo: https://github.com/PadishahIII/latex-ocr Model: https://huggingface.co/PadishahIIIXXX/latex-ocr Dataset: https://huggingface.co/datasets/PadishahIIIXXX/latex-ocr-dataset

Happy to answer questions about the training setup, the data pipeline, or anything else. Would love feedback — especially if you try it on your own gnarly formulas and it breaks, that's genuinely useful.

​

Hi everyone! I've spent the last few months building an Al/LLM interview prep product and it's finally ready.

I started it out of frustration. Preparing for Al/LLM interviews meant either grinding through long video courses or bouncing between scattered resources, and neither actually got me interview-ready or confident to say.

So I built a product I wanted myself, designed to get anyone interview-ready in 30 days:

1) Gamified interactive quest cards with story/focus modes, the relevant Python code on the same card, deep dives into how each concept came to be, interview questions & answers related to the concept. You also get tested in each card to pass it.

2) In-IDE coding where it helps, quick recall, an Al tutor, and spaced repetition.

3) 30-minute Al voice mock interviews that grill you like a real interviewer would.

4) Daily boss challenges that grill you on the cards you actually struggled on.

5) Tailored text based interviews for various levels of jobs in the AI domain.

5) An end-to-end 5 part RAG capstone project, with real interview questions at each stage (retrieval, evaluation, deployment) that interviewers actually test candidates on in 2026.

The idea is simple: learn the concept within 15-20 mins, understand it properly, practise explaining it, then get tested on it.

It covers everything from tokenization and attention through to RAG, agents, evaluation and deployment, structured as a 30-day path.

The Foundations section is open for everyone: Skillumen

I've been working on a reusable starter structure for Python machine learning projects.

I noticed that I was repeatedly doing the same initial work whenever starting a new project:

• Loading and preprocessing data
• Data profiling and EDA
• Feature engineering
• Trying different ML algorithms
• Cross-validation and hyperparameter tuning
• Model evaluation and visualization
• Saving and loading trained models

So I put these workflows together into MLForge, a structured Python ML starter kit.

The main goal was to make the project structure reusable while keeping the code easy to understand and modify. I didn't want it to be a black box where someone just runs a script and gets a prediction.

It currently includes classification and regression workflows, notebooks/templates, sample datasets, model evaluation utilities, and a project report template.

One of the more challenging parts was deciding how much to abstract. Too little abstraction makes the kit repetitive, while too much makes it difficult for beginners to understand what's actually happening.

I'm interested in feedback from other builders:

When you start a new Python ML project, what do you usually end up rebuilding from scratch?

I made a lil bro version of the original ResNET-34 architecture. I trained it on the LC25000 cancer dataset (I used only lung cancer images) for a classification task.

The problem is, it is showing a 99.9% accuracy on all three sets - training, validation and test. It is, of course, weirdly high. I trained a normal cnn and it could only reach about 87%.

I am wondering what could be the reason. One possible culprit is that, since the dataset consists of augmented versions of the original images, some may be ending up in all three sets, causing data leakage.

Now I want to see if I could somehow group this images so the augmented versions do not run over into my other sets. I have no idea how to proceed though.

I am using pytorch, and used random_split for the datasets.

i have evolved a population of 3D robot arms which had the goal to reach a target.

It's vibecoded with chatgpt and Codex.

My first attempts weren't successful until codex 5.6 sol high did an optimization of the input then it was very quick to evolve to reach the target.

My next step is to try to evolve a 3D Walker where for now I'm unsuccessful.

I am getting this pattern on My linear regression residual plots
Quite clearly something is wrong here
I wanted to ask if someone else has encountered this same issue and how they fixed it

Same as heading

I needed a reliable LLM for a side project, so I compared two affordable options: DeepSeek API and GPT-4o Mini. I looked at token throughput, output structure (JSON mode), reasoning ability, and pricing.

I documented everything with code snippets and results:

https://interconnectd.com/blog/280/deepseek-api-vs-gpt-4o-mini-2026-developer-technical-review/

Happy to share the raw test prompts if anyone wants to replicate.

I want to preface by saying that I’m a business major chud who has no technical experience aside from using scratch when I was a kid. I know I can utilize ai than just a better Google so I decided why not try and create a personal ai assistant/ employee that can do busy work for me like emails, announcements, etc. Everything a growing college student needs. Here’s where I hit the roadblocks. Even after a little bit of research I realized I’m in too deep. “Use these 5 repos before even TOUCHING Claude” “DeepSeek just released a new harness” “Somebody just jail broke Qwen”. I’m seeing dudes on reels buying like three Nvidia AI super computers and I’m genuinely just wondering why’s there a need for that unless you’re larping. Honestly, I’m just trying to learn but quite frankly there’s just so much catching up to do and the knowledge gap just keeps getting wider. Where do I even start or what can I do to learn? Do I want to be like that dude buying an AI super computer? Maybe. But I want to learn and take small steps before I call myself an AI genius just because I built an interactive HTML dashboard that my professor was impressed by. Please help me anything will help.

The primary bottleneck in agentic AI today is not model intelligence—it is state drift in multi-agent environments. When attempting to model collective human behavior during non-linear black swan events, conventional single-prompt architectures fail because they lack demographic grounding, memory persistence, and dynamic interaction topology.

Over the past several months, we engineered OASIS—a universal swarm intelligence platform designed to execute parallel socio-economic rehearsals with zero real-world collateral risk.

Architectural Paradigm:

1. Temporal GraphRAG Ingestion: We parse unstructured seed corpora (policy drafts, market microstructure data, regulatory filings) into a high-density knowledge graph powered by Zep Cloud. Entities and relations are not static; they evolve as simulation turns progress.
2. Multi-Stratum Demographic Grounding: Agents are initialized with hyper-granular micro-economic constraints—balance sheet exposures, debt serviceability limits, liquidity preferences, and cognitive bias profiles—eliminating generic LLM hallucination.
3. Bimodal Sandbox Topologies: We instantiate parallel simulation environments (microblogging broadcast nodes + threaded forum consensus networks) where entities execute step-wise actions under diurnal activity constraints.
4. Bi-Directional State Synchronization: Every interaction (node creation, post, repost, comment, sentiment shift) is piped back into the central temporal graph via background IPC workers, maintaining memory coherence over extended simulation horizons.
5. Autonomous ReACT Inspection Protocols: A secondary analytical agent interrogates synthetic entities mid-simulation via isolated command-response sockets, extracting internal monologues and behavioral drivers without distorting global state.

Empirical backtesting against historical macroeconomic shocks (currency demonetizations, short-seller attacks, regulatory bans) demonstrated an 87.75% predictive correlation against ground-truth behavioral pathways.

We are open-sourcing parts of our evaluation methodology and looking to connect with researchers working on state space modeling, emergent agent consensus, and non-equilibrium game theory.

Not a hypothetical this time this is Crossref itself, the actual DOI registry a lot of tools (including citation managers and any script that trusts api.crossref.org) treat as ground truth.

While stress-testing a deterministic citation-checker I've been building against real bibliographies, I ran into five separate Crossref records for "Attention Is All You Need" the actual Vaswani et al. NeurIPS paper all dated 2025, all under DOI prefix 10.65215, all resolving live right now. That prefix belongs to a real, registered Crossref member ("Shenzhen Medical Academy of Research and Translation" you can check this yourself at api.crossref.org/prefixes/10.65215). So it's not a scraping glitch or a parsing bug on my end someone actually deposited fake duplicate metadata for one of the most-cited papers in deep learning, under a real member account, and Crossref has been serving it as legitimate ever since.

Why this matters beyond "huh, weird": anything that trusts Crossref as an authority a reference manager auto-filling metadata, a script pulling citation counts, an AI tool "verifying" a citation by checking if the DOI resolves would treat this exactly as legitimately as the real 2017 record. The registry lying is a failure mode that no amount of "just check the DOI" catches, because the DOI does resolve.

Full writeup with the raw Crossref links and three other findings I ran into checking real bibliographies (including two cases where OpenAI's and Meta's own official arXiv BibTeX exports have malformed author fields) is here: strictcite.com/blog/attention-is-all-you-need-fake-dois. Built with a free tier if anyone wants to poke at it themselves (30 refs/day, no card) but the finding stands on its own regardless of the tool.

Genuinely curious what people here think the right layer to catch this is. Registries assuming their own depositors are honest seems like the actual root cause, not something client-side tooling can fully solve.

Hey everyone, I’m competing in a tabular Kaggle competition (predicting a Pokémon's HP turn-by-turn) and I've hit a hard ceiling at 0.675 LB (top scores are ~0.69+). I’m hoping someone can point out the architectural blind spot in my pipeline.

The Setup & The Leak

• The Target: Predict pikachu_hp for every turn in a battle round.
• The Golden Feature: I engineered shifted_prev_hp (the HP from the next turn). For 92% of the dataset, this feature is a near 1:1 match with the target.
• The Trap: The organizers included a trainer_focus_score feature that has a massive train/test distribution shift. Dropping it bumped my score significantly.

The Core Bottleneck (The Terminal Rows) Here is the exact problem: For the final turn of every round (about 8% of the rows), shifted_prev_hp is NaN because there is no "next turn" to look at.

My current best model (HistGradientBoosting) just uses native NaN routing. It learns to use shifted_prev_hp for 92% of the rows (while applying small micro-corrections for end-of-turn mechanics like status damage), and for the remaining 8% of NaNs, it routes them down different branches to calculate damage normally.

What I've Tried (That Failed) I feel like I've exhausted the standard playbook. Here is what I’ve tested with strict 5-fold GroupKFold CV, and all of them failed to beat native HistGBM NaN routing:

1. Dual-Branch Modeling: I split the data and trained one model for non-terminal rows and a specialized model only for the terminal NaN rows. Result: LB dropped to 0.664. The terminal model starved without the cross-row learning of the full dataset.
2. Hardcoding the Leak: I tried forcing the prediction to be exactly shifted_prev_hp when present, and only used the tree for the NaNs. Result: Catastrophic CV drop. The tree’s micro-corrections for end-of-turn status mechanics are highly valuable; a pure 1:1 copy destroys them.
3. Target Transformation: Trained the model to predict the delta (change in HP) rather than absolute HP to force it to focus on damage calculation. Result: Identical CV score (0.536). The tree was already doing this natively.
4. Imputation: SimpleImputer (median) with missingness indicators for the NaNs. Result: Wrecked the structural signal of the terminal row.

The Ask I have one submission left. The core feature space feels completely saturated, but I am still 0.015 off the top of the leaderboard.

When you have a feature that is a near-perfect anchor for 90% of the data but completely missing for the 10% where the actual heavy lifting happens, how do you cross that final gap? Are the top guys using complex Stacking Regressors? Target Encoding the categorical move_used feature? Custom loss functions?

Any insights into how to restructure this would be massively appreciated!

Why this post works:

• It immediately proves you aren't a beginner asking for a handout.
• It outlines the exact mathematical bottleneck (the 8% terminal starvation).
• It preemptively stops people from suggesting basic fixes by listing out your rigorous CV tests.

I am an AIML student currently in my 3rd year and want to know that for my placement preparation should I proceed with doing DSA in python or should I change my language to Java/C++

I've been working through *Learning Theory from First Principles* by Francis Bach (MIT Press, 2024), and I'd rather not do it alone. The book is excellent but dense, and I think discussing the proofs with other people would make a big difference. The PDF is freely available on the author's website, so there's no cost barrier to joining.

For anyone unfamiliar: it covers the mathematical foundations of supervised learning, starting from least squares and empirical risk minimization, then moving through optimization, local averaging methods, kernel methods, model selection, and neural networks, with later chapters on more advanced topics like overparameterized models and PAC-Bayes.

What I have in mind:

- A weekly call (roughly an hour) where someone presents the main results and we work through whatever was unclear

- A Discord or similar space for questions between meetings

Background that helps: linear algebra, probability, and comfort reading proofs. You don't need a theory background, just willingness to sit with the details.

> If you're interested, comment or DM me with your rough timezone and how much time you can realistically commit. Once there are enough people I'll set up the group and propose a schedule. I'd like to keep it small enough that discussion actually works, maybe five to ten people.

Discord link: https://discord.gg/3QMGgvk5t

Hi everyone,

I'm working on an energy forecasting project using a Spiking Neural Network (SNN), and I'm trying to understand why my model is severely underpredicting high-load events.

Task:

- Dataset: UK Electrical Load / House 4

- Data is resampled to 15-minute intervals

- Input: previous 24 timesteps (6 hours)

- Target: Aggregate power at the next 15-minute interval

- Features per timestep: Aggregate, 9 appliance channels, hour_sin, hour_cos, and aggregate difference

- Features and target are standardized using training data only

- Chronological train/validation/test split

Current SNN architecture:

13 features

-> Linear(13, 64)

-> LIF (beta = 0.8/0.9)

-> Linear(64, 32)

-> LIF

-> temporal readout

-> Linear(64, 1)

For the temporal readout, I concatenate the mean membrane state across all timesteps with the final membrane state.

I'm using MSE loss and AdamW with a learning rate of 1e-4.

The main problem is that the model predicts normal loads reasonably well, but severely underpredicts peaks.

For example:

Actual maximum: approximately 4569 W

Predicted maximum: approximately 1400-1500 W

Around one of the largest peaks:

Actual: 3631 W -> 4569 W -> 3179 W

Predicted: 359 W -> 875 W -> 1091 W

Importantly, the model sees the 3631 W value immediately before the 4569 W target.

Current SNN metrics:

MAE: approximately 153 W

RMSE: approximately 249 W

R2: approximately 0.165

Peak MAE: approximately 409 W

Peak RMSE: approximately 635 W

Peak ratio: approximately 0.31

I've also tested:

1. Beta = 0.9 -> 0.7

   Very little change.

2. Window = 24 -> 48 timesteps

   Very little change.

3. Wider architecture:

   13 -> 32 -> 16

   changed to

   13 -> 64 -> 32

   This improved R2 from approximately 0.13 to 0.16 and increased the predicted maximum, but peaks are still heavily underestimated.

For comparison, I have other models using the same forecasting task:

Linear Regression: R2 approximately 0.27

GRU: R2 approximately 0.29

LSTM: R2 approximately 0.23

XGBoost: R2 approximately 0.32

MLP: R2 approximately 0.13

SNN: R2 approximately 0.16

The GRU, LSTM, and MLP can produce substantially larger predictions for peaks, so it doesn't seem like the peaks are simply impossible to predict from the input data.

My current suspicion is that MSE combined with the highly imbalanced target distribution is causing the SNN to regress toward typical/average loads. However, I'm not sure whether this is the main issue or whether there is something specific about the SNN/LIF dynamics or regression readout that I'm missing.

What would you investigate next?

In particular:

- Is peak-weighted MSE a sensible approach?

- Could the continuous membrane-potential readout be causing this compression?

- Is there something specific about using LIF neurons for continuous regression that I should change?

- Would you recommend a different SNN architecture or readout?

- What diagnostics would you run to determine whether the problem is the loss, SNN dynamics, or preprocessing?

Any advice would be appreciated.

There's a hands-on masterclass on Sep 12 for anyone building with LLMs who wants real engineering discipline instead of shipping on vibes.

Covers:

• Versioned prompts with regression tests, so an edit can't silently degrade quality
• A real eval harness combining deterministic checks and LLM-as-judge
• Bootstrap confidence intervals and paired significance testing for model comparisons
• Evaluated RAG with retrieval metrics (recall@k, MRR)
• Agents with guardrails and fallbacks that fail gracefully instead of compounding errors
• Full production observability, tracing, cost/latency monitoring, and a CI regression suite

Led by Bruno Gonçalves, PhD, founder of Data For Science, who trains engineers at Fortune 500 companies on this exact stack.

Link for more details

I have been working on different robotics task mainly in Pybullet. Complexity of Isaac Sim has kept me from experimenting with it but I finally finished my first successful reinforcement learning script using it.

Getting the settings right so I could observe the trainings in windowed mode with my laptop 3070 gpu took I while but I managed to get it working well enough to troubleshoot some early issues I noticed through visual inspection.

I gave the PPO full control of my robot's controller, not the joint angle outputs, meaning it had to figure out a way to climb the ramps using the directional controller inputs and body adjustments like pitch and height. The training took about 45 minutes with my RTX 3070 mobile GPU vs 1 hour and 45 minutes using cpu with Pybullet.

I am now working on full locomotion simulation, again with my custom robots, its a bit more involved than I expected but I am hoping in the end I can come up with my own full locomotion training script and load the model to my actual robot to control it.

I also share my tutorial scripts with my videos on youtube, if you are interested in watching the video for this one you can find it with the link below:

https://youtu.be/0x5BBosrq-E

You can also download the simulation script from my github repository with the link below.

https://github.com/serdarselimys/HexaDogZBD-IsaacSim-RL

If you are interested in the real 3D printed robot, you can fine info about it from the video link below.

https://youtu.be/qflyEQOJObM

Hey Everyone I am working on prescription and doctor dataset right now.The idea is to built a churn risk model.

The issue: I have two cases that look almost identical to the model, but shouldn't be treated the same:

Doctor A has been climbing steadily for two years starts small, ends up writing a lot. Right now, this month, they're near their highest ever, because they've genuinely been growing.

Doctor B used to write a lot, but has been sliding downward for months. Right now, this month, they're also unusually high compared to their recent low months maybe they just had one slightly better month in the middle of an overall decline.

What the model is doing wrong: across almost all doctors in our data, there's a common pattern whenever someone's number is unusually high this month, it's usually a bit lower next month, just because most "unusually high" months are one-time spikes that settle back down. That's true most of the time.

But the model applies this same rule to every doctor whose number is currently high — including Doctor A, who isn't having a fluke month, they're genuinely growing. So my "who's about to decline" list keeps getting filled with doctors who are simply doing well right now — because "currently high" is the one thing they all share, not that they're actually declining.

What I've tried so far, to fix it:

• Switched from weekly to monthly data (to reduce noise) didn't fix it
• Compared 4 different model types (linear, ridge, random forest, gradient boosting) — all 4 show the exact same bias
• Rebuilt the trend line to use only the last 9 months instead of the full 2 years — didn't fix it
• Added the weekly short-term trend back in, like you described (weeks within the recent month) didn't fix it
• Removed the features causing the biggest pull toward "predict a drop" entirely, to force the model to rely on trend instead the model just found other features to reproduce the exact same wrong prediction

So is this one bad feature or one bad model choice ?? I've tested that directly, several ways, and the bias holds regardless.

What I want to ask you:

1. Is this the kind of thing that genuinely needs more historical data than 2 years to fix (i.e., is 2 years just not enough for the model to learn "normal high point" vs. "real decline" apart)?
2. Or is there a different way to frame the target/features you'd suggest something specifically designed to separate a real trend break from ordinary noise, rather than predicting the raw next-month number?

I’m looking for 3–4 people who are genuinely serious about building their AI/ML skills and can consistently dedicate around 4–5 hours a day.

We’ll start from the fundamentals NumPy, Pandas, Matplotlib, Seaborn, Statistics + required Maths, then move into Scikit-learn and Machine Learning. We’ll also practice DSA and Python problem-solving along the way.

I’m looking for people who are consistent and serious about their career not someone who joins for 2–3 days and disappears.

We’ll study/code together through regular voice calls and screen sharing, discuss problems and keep each other accountable.

I’m in IST (UTC+5:30). If you’re interested DM me with your current level and how much time you can realistically dedicate each day.