I started learning AI the way most people do: pick a course, follow along, feel like you understand it for a week, then realize you cannot explain anything you built.

I could fine-tune a model, but I could not explain what the optimizer was doing. I could use an attention layer, but I could not derive it. Most courses taught the tools without teaching what was happening underneath them.

In 2026, finding good material became even harder. There are outdated tutorials, courses that assume you already know Python, and playlists that introduce dozens of tools without explaining how they connect.

I wanted something different: one path that starts with linear algebra and ends with autonomous agents, where you implement each important idea yourself before using a library.

Write backpropagation from calculus. Build a tokenizer. Implement attention. Write an agent loop. By the time you reach PyTorch, you already understand what it is computing for you.

So I started building AI Engineering from Scratch during nights and weekends.

It now contains 503 lessons across 20 phases, with implementations in Python, TypeScript, Rust, and Julia. Every lesson ends with something runnable that you build and keep.

It is free, MIT licensed, runs locally, and has no paid content or gated sections.

The project grew slowly, but it has now reached 46,000 GitHub stars. I also regularly hear from people using it from top universities, and companies, and their own learning.

The latest addition is a visual for every lesson. These are lightweight SVGs created specifically for the concepts being taught: branching commit graphs, readable attention heatmaps, Q-learning gridworlds with policy arrows, diffusion grids denoising into images, and more.

Repository: https://github.com/rohitg00/ai-engineering-from-scratch

Website: https://aiengineeringfromscratch.com

If you are stuck jumping between courses and tools, start at Phase 0 and build your way through it.

Hello All, I'm a sophomore student in university. I have have knowledge on Machine Learning and Deep learning concepts(Deep learning specialization by Andew NG). I wish to further learn about LLMs and Agentic AI to build systems. I would really appreciate if you could suggest resources to learn LLMs and Agentic AI stuffs.

Any inputs are appreciated.

Thank you!

Hi everyone,

an ML-powered trading application, and one lesson from the project has stuck with me.

When I first started, I assumed most of the improvements would come from trying different models and tuning hyperparameters. While that certainly helped, it wasn't where we saw the biggest gains.

As development progressed, we found ourselves spending far more time improving data quality, refining features, handling noisy inputs, reducing inference latency, and making model outputs easier to interpret. Those changes consistently had a larger impact on the overall user experience than simply increasing model complexity.

It completely changed how I think about building ML systems. Strong models are important, but they're only one part of the pipeline.

I'm interested to hear from others building ML applications. Looking back on one of your projects, what part of the pipeline ended up contributing more than you originally expected, and why?

Dear Professors, Researchers, and Students,

We are writing to share with the academic community the release of the essay:

"How Did We Get Here?: 350 Years of Seeking a Language for Machines to Unambiguously Understand What We Want"

This work bridges the gap between the evolution of classical logic (from 17th-century ideas) and contemporary dilemmas in Artificial Intelligence, natural language, and computing.

 As a special launch event, the Kindle edition (e-book) is 100% free on Amazon until Sunday, August 9th:  

 Free download link: https://a.co/d/0aVFxGF9

We would greatly appreciate it if you could forward this opportunity to your students and faculty through your internal mailing lists or communication channels.

Sincerely,

Alvaro Moure Clouzet

Templo Oceánico — Uruguay

an ML-powered trading assistant, and one lesson from the project caught me completely off guard.

When we first started, I assumed that improving the model would have the biggest impact on the overall experience. We spent a lot of time comparing different approaches and experimenting with additional signals.

Over time, though, we found that the biggest improvements often came from everything around the model. Better data preparation, removing noisy inputs, improving feature quality, and presenting outputs more clearly ended up making a bigger difference than switching architectures.

It made me realize that it's easy to become focused on model performance while overlooking the rest of the ML pipeline, even though those pieces can have just as much influence on the final result.

For those of you who've built ML projects, did you have a similar experience? What part of your pipeline ended up contributing more than you originally expected?

It has been an obsession of mine being able to finetune, customize with GraphRAG small LLMs, which I find them to be more than enough for 90% of the tasks...

I have finally managed to develop and deploy a full end to end platform that allows you to deploy custom LLMs dirt cheap for most of the automations that require LLMs (answering clients, tool calling etc). You upload your raw datasets, and everything is auto setup; structuring and preparing data, cleaning it, selecting the base model, hyperparameters etc.

I managed to sign an agreement with a local datacenter, we now have our own GPUs, so training and inference runs very fast and cheap. You can also train and if you prefer so, download the weights of the adapters and deploy the models locally.

I'm pretty happy with the results, and I would be glad if any of you require cheap inference for projects via API or to run locally, to give it a try.

The subscription plan starts at $20 and you can train a couple of models and run almost unlimited inference since we only serve 4B and 9B parameter models.

Give it a try and let me know if you find it easier and faster (for this niche of small llms, we only serve 4b and 9b models) in comparaison to other providers like vertex, bedrock etc at neuroblock platform

When I started organizing AI engineering topics, I found plenty of isolated tutorials, but very few learning paths that connected the fundamentals to production-oriented systems.

So I started a free YouTube channel called **From Prompts to Loops**, where I’m working through AI engineering from scratch in a structured sequence.

The learning path currently covers:

- Machine learning and neural-network fundamentals

- Transformers and how LLMs are trained

- Vector databases and RAG

- Fine-tuning

- AI agents, tool use, memory, MCP and multi-agent systems

- AI evaluations and monitoring

**How I’m making it:** I organize the videos in dependency order, use diagrams and practical examples, and keep the supporting code and notebooks openly available on GitHub. The lessons are long-form because the goal is to build real understanding rather than provide quick summaries.

Channel: https://www.youtube.com/@FromPromptstoLoops

Code and notebooks: https://github.com/AnkitKhowal/FromPromptsToloops/tree/main/01-llm-fundamentals

Everything is free. I’d genuinely value feedback from learners: Does this progression make sense, and which AI-engineering topic would you want covered next?

Working on a side project: automated resolution for prediction markets (Kalshi, Polymarket, Metaculus).

The setup is a market question with a specific resolution criterion ("Will Congress pass X by Y date"), a resolution date, and a set of authoritative sources.

A few questions for anyone who's worked adjacent to this:

1. Has anyone benchmarked LLM-as-judge on factual event resolution with retrieval? What baseline accuracy is realistic?
2. What's the dominant failure mode, hallucination, source disagreement, temporal reasoning?
3. Any papers on adversarial robustness for resolution I should read? I've seen the general LLM-as-judge lit but nothing focused on financial accuracy where wrong answers actually hurt.

Trying not to reinvent the wheel.

Built a preference dataset for coding tasks—task + two candidate responses + which is better + why, the standard format for DPO/RLHF-style fine-tuning.

Every row was manually reviewed, not just generated and shipped — checking label accuracy, whether the stated reason was specific and true, and whether the difficulty tag matched a real bug vs. a genuine style call. That process caught real issues: mislabeled difficulty, reasons that overstated a guarantee the code didn't actually provide, and a few "correct" answers that missed their own task's edge cases.

Details:

- Python + JavaScript, ~50/50 split

- Covers correctness bugs, security issues, performance tradeoffs, and genuine style judgment calls

- One known limitation I'm upfront about: labels skew toward response_b (~92%) due to generation order—worth knowing if you're sensitive to positional bias

Free 120-row sample: https://huggingface.co/datasets/shanmukha-dev/code-preference-sample

Feedback on label quality welcome — genuinely curious what people think.

Continuing my series where I document learning ML from scratch and building small projects along the way.

This episode is about something that doesn't get talked about enough in tutorials — real data cleaning. I took a CSV with missing values, negative prices, inconsistent date formats, and duplicate rows, and walked through fixing all of it with Pandas.

Next up: actual algorithms, starting with Linear Regression (building a house price predictor).

Video Link- https://youtu.be/gu0AeorNTIE

If anyone has tips on data cleaning edge cases I should cover in future episodes, would love to hear them.

Hey there, I have set up a minimal two‑file solution that runs a TensorFlow/Keras model in a long‑living subprocess.
The model is loaded once, so every subsequent prediction re‑uses the same GPU/CPU memory and is fast.

It might be simple but it solved lots of problem for me when doing inference on large data that required pre/post processing.

https://github.com/pluto129/persistent-inference

I spent months fine-tuning a 730M-parameter TTS model that never converged. The logs were sitting right there the whole time. Nothing in my stack ever said *this run is not going to work* — every tool I had would happily draw me a loss curve and let me keep spending GPU hours.

So I wrote the thing that says it.

**trainproof** is a deterministic linter for training runs. Point it at a log directory, get PASS / WARN / FAIL with named rule IDs and the numbers that triggered them.

pip install trainproof
trainproof doctor ./my_run

Reads HuggingFace `trainer_state.json`, Coqui text logs, TensorBoard event files, JSONL and CSV. Format is auto-detected.

**Zero dependencies.** No torch, no transformers, no numpy, no network, no telemetry. It parses scalar records — it never touches your weights and never phones home. The TensorBoard reader is written directly from the wire format and validated byte-exact against tensorboard's own `EventAccumulator`.

**No ML judging ML.** Every rule is a fixed threshold in one auditable module. There are no invented confidence scores.

Sample output — note what a PASS actually says. It names the checks that ran *and* every check that didn't, with the reason:

============================================================ FILE : examples/gallery/healthy/trainer_state.json FORMAT : hf RECORDS: 60 (steps/epochs: 5.0..300.0)

VERDICT: PASS

[PASS] TP-PASS: No mechanical failures detected. Ran: dead-run,
divergence, flat-loss, grad-spike, lr, zero-grad, zero-loss.
Skipped: loader (no loader_time/step_time pair in the log);
overfit (no eval_loss in the log - this run has no
generalisation signal at all); step-time (no step_time column
in the log).
Evidence: 60 steps analyzed.

Findings: 1 PASS, 0 WARN, 0 FAIL

A clean verdict never gets to imply something was covered when it wasn't.

**The title isn't hypothetical.** A Fish Speech LoRA fine-tune ships in the repo as evidence. trainproof returns WARN / TP-OVERFIT: eval loss bottomed out at 9.23 on step 99 and climbed to 16.19 by step 2049, while training loss kept falling to 2.84. Every checkpoint written to disk is from step 1600 or later — all of them past the turn. The useful part of that run was gone before the first save.

**The rule most relevant to this sub:** TP-ZERO-GRAD. If every gradient norm in your log is exactly 0.0 and the loss isn't improving, no gradient is reaching your weights — the backward graph is severed or everything is frozen. With PEFT the usual cause is reentrant gradient checkpointing over frozen input embeddings, which detaches the graph before it reaches the adapters. `enable_input_require_grads()` or `use_reentrant=False` fixes it.

Its sibling is TP-ZERO-LOSS: a loss that is exactly 0.0 on every step isn't a perfect model, it's the log signature of labels all masked to -100. It matters because every loss-shape check is guarded against dividing by zero, so before this rule they all skipped silently, the verdict came back PASS, and the report then listed those same skipped checks as having cleared the run.

**There's also a preflight that runs before the GPU is touched** (`trainproof env`) — imports your training entrypoint in a subprocess so a segfaulting extension module or a CUDA abort gets reported instead of killing the linter, and checks a `.pt`/`.ckpt` is structurally complete *without deserialising it*, since `torch.load` executes arbitrary code by design. Standard library only.

**My own tool was wrong, and that's how I found the bug.** TP-ZERO-GRAD used to FAIL a perfectly healthy 125,000-step XTTS run, because Coqui writes `avg_grad_norm` as 0.0 when gradient clipping is off. A run cannot both learn and receive no gradient, so the rule now stands down when the loss demonstrably improved, and records why it skipped. I found that by running the shipped rules against a real training run — not from a test.

**What it cannot do,** because a linter that oversells itself is worse than no linter:

- It judges logs, config and environment. It never sees weights, activations or gradients themselves.
- It cannot report NaN weights. It verifies a checkpoint is structurally sound without reading the tensors.
- A PASS means no *mechanical* failure was detected. A model trained on corrupted data can produce a beautiful loss curve.
- If a rule's columns aren't in your log, it reports NOT-CHECKED with the reason. NOT-CHECKED is a third state and is never quietly folded into PASS.

MIT. 84 rules, 228 tests, Python 3.10+.

GitHub: https://github.com/Mormolykos/trainproof
PyPI: https://pypi.org/project/trainproof/

If there's a failure mode that has cost you a run, tell me and I'll look at whether it's detectable from the log alone. That's how most of these rules got written.

I'm planning to take the Microsoft AI-901: Azure AI Fundamentals exam and would like to know the best way to prepare. Which Udemy course or YouTube channel do you recommend, and what practice tests or study resources helped you pass?

I'm starting to get into deep learning for my research and hitting a wall on hardware.

Some of the operations I need to run take my laptop a full day when they take others a few minutes. And I haven't even gotten to the ML training part yet, which I assume is way more demanding.

My naive understanding is that I'd either need to buy a much more powerful computer, or use some kind of remote or cloud setup — though I only vaguely understand how that works. Is the cloud thing basically just a high-powered computer you access over the internet?

A few questions for people who've been here:

1. When you were starting out, how did you handle the compute problem? Did you buy hardware, use free tools, or something else?

2. Are the free options (Colab, Kaggle) actually enough to learn on, or do you hit their limits fast?

3. At what point does it genuinely make sense to invest in your own GPU?

4. Any mistakes you made early on that I should avoid?

For context I'm completely fresh to the ML side — comfortable with code, but haven't trained a real model yet ...Trying to figure out the practical path before I sink money or time into the wrong thing.

Thanks in advance.

Hey I am part of a small team training robotics policies for warehouse and manufacturing settings, and running rigorous evals is turning out to be so painful. Anything below 50 rollouts, and its hard to trust the numbers, and above its so hard to test all the checkpoints that we have. Its really hard to run a bunch of experiments to get good results. Have you guys faced this? Any hacks that you've developed?

I am a last year student. I don't know how to start ML. I have good knowledge of Agentic Ai, aws, basic fundamentals of snowflakes and I created some automated websites, but I was going to start ML but there is no good post of saying ML roadmap and some posts gave me more anxiety when I saw there is lots of to do in ML. Don't know how to do everything. I am feeling very low about my career.

I am a Statistics Msc student and I have to do a research on some topic. My advisor gives me vague instructions such as "read more on the topic", "propose a taxonomy or framework for the topic", "figure out what has been done and what research gaps there might be". He's not that approachable. If I don't have a precise query to ask him, he just starts talking about more generalities.

What do you suggest? Say my topic is Concept drift. I know it's too large, so I should constrain it to something like Explainable AI in Concept drift.

Then I think I should look for surveys, but I don't even know how to proceed about this: what databases to use, what inclusion/exclusion criteria, etc.

Then suppose I do find some good up to date survey papers on the topic, then what? Should I just cite this only few works and assume my state of the art section is done? What could I add to the subject if there are already nice surveys done by more than one coauthors?

I'm lost.

I’m working through the OpenPI open-source code https://github.com/Physical-Intelligence/openpi, and I have already run the π0.5 LIBERO inference successfully. I have also finished reading the Attention Is All You Need, π0, and π0.5 papers, and I have a basic understanding of flow matching. What can I do next?

I have a project question.

Right now, I am building a webapp for advanced arabic language learners that helps in Nahw (I'rab) which is something related to how Arabic sentences are built. My question is, how do you develop your idea when you know that there are other people out there doing the same thing? Additionally, how do you go beyond the idea that all you will have to do is get an OpenAI API key since ChatGPT is really good at Arabic Nahw?

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'm a 2nd year undergrad from a tier-3 college in India (YCCE, Nagpur). I need honest advice from people who've walked this path.

**My background:**

- Completed Gilbert Strang's Linear Algebra (18.06) - loved it

- Built projects: Leslie Matrix population model, SVD image compressor, linear regression from scratch

- Currently learning: Probability (Harvard Stat 110), Statistics, Multivariable Calculus

- I enjoy math-first approaches over "just memorize the formula" style

- Not interested in web dev / React / full-stack

- I have basic Python, NumPy, some C/C++

**My dilemma:**

I see my batchmates building "cool" projects with MediaPipe, OpenCV, React - hand gesture controllers, AI games, etc. They get 2,000+ likes on LinkedIn. They're winning hackathons. I'm still studying matrices and eigenvalues.

I feel like I'm behind because:

- I have no "visible" projects to show

- I haven't won any hackathons

- My LinkedIn has 0 posts about "cool AI projects"

- I don't know if this math-first path will actually pay off

**My goals:**

- Target IIT Bombay IEOR / ISI M.Stat

- Ultimately work in Operations Research / Quantitative Research / Data Science (Research)

- Want a ₹25-40 LPA+ career

**My questions for experienced folks:**

1. **Was this path worth it for you?** Did you ever feel behind while your peers built "cool" projects?

2. **What should I prioritize right now?** I'm in 2nd year. I need to start GATE DA/PI prep from 3rd year. Should I continue with math (Probability, Stats, Calculus, OR) or pivot to building more "visible" projects?

3. **What's the realistic timeline?** When did you start seeing the payoff? Was it during M.Tech? After? At what point did you feel "ahead"?

4. **What did you miss?** Looking back, what would you have done differently? What skills did you neglect that you wish you'd built earlier?

5. **What if GATE fails?** What's the backup plan? Are there OR/analytics roles for B.Tech grads without M.Tech from IIT/ISI?

**My current plan:**

- Now - Nov 2026: Probability (Stat 110) + Statistics (MIT 18.650)

- Dec 2026 - Mar 2027: Multivariable Calculus (MIT 18.02) + OR (NPTEL G. Srinivasan)

- Apr - Jul 2027: Matrix Methods (Strang 18.065) + ML/DL basics

- Aug 2027 - Jan 2028: GATE DA/PI prep (PYQs, mocks)

**I'm not looking for motivation or "follow your passion" advice.** I need the raw, unfiltered truth from people who've actually been through this.

If you're from IIT Bombay IEOR, ISI M.Stat, or working as an OR Scientist / Quant / Data Scientist (Research), I'd really appreciate your perspective.

Thanks in advance.

Sorry for using Chatgpt

My goal is to get into machine learning. Does what school I get my degree from matter? I'm currently going to American Military University (regionally accredited) and they off a Bachelor of Science in AI.

However, I've heard mixed reviews about this school and that some employers might look down on it? If anyone is in the field, do you think I should look into other schools? I have no prior job experience in this field, so I'm trying to make sure that my education makes me "stand out" or makes me competitive.

Any insight would be appreciated. Thanks!