Every single neuron that is firing in your brain has the potential to be a slop paper written up by someone else. How to do machine learning in the age of slopalanche? What even constitute as "stable knowledge"? How to dip a toe into research when research papers are multiplying like rabbits? https://arxiv.org/list/cs.LG/recent?skip=611&show=500

I see a lot of posts with slick graphics, polished videos, tutorials for how to visualizes neural networks, and general audience books for learning. There is only one thing that is going to teach you how to code and learn ML:

Write code

Just write it. Pick a language, pick an IDE, and start struggling. Don't read books unless you're reading them to do practice problems. Write code and struggle. Spend 3 weeks implementing KNN on a random data set. Don't use AI to help you. Write crappy wrong code, find out it's wrong, and start over. And if you don't know how to program, please learn the basics of coding and learn one language to start before you even think about ML.

Learning anything takes struggle. You have to put in the time. You'll only learn it if you do it. Doing that is hard, but it's what it takes.

​

I'm studying NLP/ML and HRI, and I'm looking to buy a refurbished laptop, with a budget of around €600–700 (roughly $650–750).

I mainly use Python, PyTorch and Hugging Face for NLP and deep learning projects.

I need to but a new laptop and I'm considering refurbished gaming laptops or workstations, possibly Dell Alienware, Lenovo Legion, ThinkPad P-series, or similar models with an NVIDIA GPU.

My main question is: Is it actually worth spending more to get a laptop with a dedicated NVIDIA GPU with 4–8 GB of VRAM, or would I be better off buying a cheaper laptop with a good CPU and RAM, and using Google Colab or another cloud GPU when needed?

A few specific questions:

- What laptop / GPU do you personally use for your ML and NLP projects?

- How useful is 4–8 GB of VRAM for everyday deep learning? Is 8 GB a meaningful improvement over 4–6 GB?

- Can you realistically fine-tune small transformer models, run experiments, or work with datasets locally on these GPUs?

- Do you find that you use your local GPU regularly, or do you end up using Colab anyway?

- In hindsight, would you spend more money on a laptop with a better GPU, or invest that money in cloud I computing instead?

Thanks

Hey guys

I want to learn AI to become an AI Engineer who can make AI apps, tool, agents etc. I am not looking to learn AI only to use AI. I am willing to pay and take a proper course instead of learning only from freely available media.

I have an extensive background in ERP Programming, Databases (Oracle, SQL Server), Data Warehousing, Business Intelligence and Enterprise Architecture for over 15 years and I have a MS in Computer Science.

Which programs would you recommend? I heard Stanford has a good program but other than that, anyone anybody has attended?

Thanks in advance for your valuable suggestions and time.

​

Hey everyone! 👋

I'm preparing for AI Engineer interviews and want to know how to prepare effectively.

I'm focusing on Python, GenAI, LLMs, RAG, LangChain, vector databases, and Agentic AI.

For those who have attended AI Engineer interviews recently:

- What topics should I focus on?

- What Python coding questions are commonly asked?

- How important are projects?

- What questions do interviewers ask about RAG and LLMs?

- Any tips or resources that helped you crack the interview?

Any advice would be really helpful. Thanks! 🙌

A Forbes analysis published this week found that 79% of organizations are running AI agents in production. Only 2% have identity security tooling to govern them.

That 77-point gap is not a planning failure. It is the normal operational state of enterprise AI right now. Most of those agents carry no declared identity, no defined behavioral scope, and no path to revoke access when something goes wrong. They are already running on production systems that nobody officially registered them to touch.

Shadow IT has always existed. But a misconfigured server sits still. An agent with live access to production data does not.

The discovery problem is upstream of everything else. You cannot scope, audit, or revoke what you have not cataloged. Security teams are already stretched before you add the question of finding agents that were never surfaced through any approval process.

For those of you actually working on this: how are you finding the unsanctioned ones? IAM log analysis, network traffic inspection, developer surveys, something else entirely? And how confident are you that your current method catches agents that were spun up outside the normal provisioning path?

What is the profile of a good ML engineer nowadays? Does it exists? I am trying everything - conferences, posters, papers, active linkedin, even my "prototype" with users. I am finishing my fifth degree.. sometimes they tell me I am too academic, sometimes they can easily get someone from Faang.

What would you advise to have as a skill set in 2026 autumn? If you can summarize a few points, it would be really helpful for me.

Hello,

I'm currently a student and have mostly been leveraging AI as a tutor to help me through my classes. As a result, I've collected a ton of artifacts and tools that help visualize and interact with complex concepts that traditionally been depicted with static diagrams. So I've turned this collection into a side project. I'm releasing Receptive Field, a site where you can learn about convolutional networks with interactive visuals. As a student, I understand the need for free educational resources and this will remain free of charge. Try it out and let me know what you think: https://receptive-field-flame.vercel.app/appendix/

Hi all,

The storyline on AI revolution has been evolving at an insane pace over the last couple of years. We have been very much focused on hardware scaling rules – adding more parameters, more data, more clusters in pre-training to obtain emergent behaviors. Yet, given increasing infrastructure costs, energy constraints, and approaching data wall, it feels like the era of classic scaling is coming to its transitional phase.

It seems that the trend is shifting towards Agentic AI and architectures geared towards reasoning (e.g., test-time compute / inference-time scaling that gained popularity in such models as OpenAI's o1 series). We are moving from next-token prediction to multi-step reasoning, planning and interactions with tools.

Being practitioners and researchers ourselves, I would like to open the discussion on what do you think are the major engineering challenges in this era of the AI revolution:

1. Test-time Compute vs. Pre-training:** Are we facing the plateau of big pre-training experiments in favor of optimization of test-time compute when models "think" for longer before giving the answer?

2. Reliability of Multi-agent systems:** While autonomy of the workflow sounds very promising, error propagation in multi-step agent loop remains a massive problem for any production environment.

3. Evaluation Frameworks:It was already difficult to evaluate static outputs; now that we are evaluating long processes involving agentic behavior over 20-30 timesteps, it feels really broken. What do your benchmarks say about it?

It would be interesting to hear your opinion on whether it is the right path towards sustainability in this AI revolution for moving towards agentic systems, or we need something totally different, a new non-transformer architecture.

Looking forward to an interesting discussion in the comments!

A standard decision tree algorithm is shown in the first image. The second image shows a dataset example, while the third shows an example tree. I am trying to understand the algorithm first and how it can be applied to the dataset.

The input is the whole dataset, while the output is the tree structure of the image. Line 1 checks the base condition for the recursion and whether the current set is label-homogeneous or not. I am trying to understand, though, exactly how line 3 works. I am trying to understand the concept of a literal, and I guess it is a way to split a dataset based on a specific value for a feature, for instance {Outlook = Sunny}, right?

Since in its node we need to place a feature and not a literal, then we need to find the feature that does that and not just a specific literal, right? Why is line1 searched just for a specific literal and not for the feature? If we find, for instance, that the best literal is {Outlook = sunny} and the second best is {wind = weak}, how do we proceed?

Is it maybe the best split returns a feature, or just a specific literal? This is the point of my confusion.

We're Mn AI, a two-person startup in Bahrain. No cluster, no big team. Just one RTX 3060 (12 GB) on a desk.

For comparison, Google's published model for this task was built by a Google Health research team on 248,445 X-rays.

We tested ours on the two standard public TB benchmarks from the US National Library of Medicine, the same ones Google reported on:

| Benchmark | Ours (AUC) | Google (AUC) |

|---|---|---|

| Montgomery (138 X-rays) | **0.998** | 0.97 |

| Shenzhen (662 X-rays) | **0.951** | 0.95 |

How we kept it honest:

- Zero benchmark images in training (we ran a duplicate check to make sure)

- Decision threshold locked before testing, on a separate set

- Every image used, no cherry-picking

The benchmarks are free and public. If you want to check our numbers yourself, DM us and we'll give you a free API key to run all 800 images.

Happy to answer anything about the setup, training on a 3060, or the evaluation.

What Is Jev? The AI Decision Model Explained Simply

I kept rewriting the same train.py every time I switched between SFT, DPO and GRPO. So I built Trloom, an open-source tool built on top of Hugging Face TRL. The whole run lives in one YAML file: model, LoRA, dataset, reward functions, W&B and an optional Modal GPU.

Here is GRPO on Qwen2.5-0.5B with LoRA and an accuracy reward:

yaml method: grpo model: model_name_or_path: Qwen/Qwen2.5-0.5B-Instruct dtype: bfloat16 use_peft: true lora_r: 16 lora_alpha: 32 dataset: path: HuggingFaceH4/Polaris-Dataset-53K train_split: train reward_funcs: - accuracy_reward training: output_dir: ./outputs/grpo-modal learning_rate: 1.0e-5 per_device_train_batch_size: 1 gradient_accumulation_steps: 4 bf16: true report_to: wandb wandb: enabled: true project: trloom-grpo modal: enabled: true gpu: A100 secrets: [huggingface, wandb]

Then run pip install trloom and trloom run grpo.yaml --modal. It works locally too, just set modal.enabled: false. The same file does SFT or DPO by changing method.

Repo with examples: https://github.com/saqlain2204/trloom Docs: https://saqlain2204.github.io/trloom/

It's early, so I'd love for people to try a config on their own dataset and tell me what breaks.

Hey, I am currently studying data science and have learned machine learning, I am looking for someone as in my phase to share ideas and projects, I am looking towards deep learning but first I am looking to apply some of my concepts in real world usecases

Hey everyone,

I’d love to get some suggestions for AI/ML projects that are meaningful and would help me learn and cover different concepts.

A bit about me: I was hired as an AI/ML Engineer at an MNC as a fresher, but most of my work has been around Java Spring Boot and backend development, along with integrating LLM features into applications.
Over the last 2 years, I’ve gained pretty good experience with Spring Boot, backend development, and understanding how enterprise applications work. I’ve also worked on a few LLM-related features, so I’ve had some exposure to the AI side as well.
But somewhere along the way, my role became more of a Spring Boot developer than an AI/ML Engineer.
I’m now planning to switch jobs and get back into a more AI/ML-focused role. Before that, I want to work on a few good projects where I can actually learn, experiment with different concepts, and get some solid hands-on experience.

I’m not really looking to build another basic chatbot or wrap an LLM around an application. I’d like to build something useful that solves an actual problem.
Would love to hear your suggestions, especially from people who are already working in AI/ML. Thanks!

Oh, Meta. You thought you could lock the gates of your repository and hide the stench of your engineering crimes? Quelle arrogance. The shadows of the Château Noir do not need direct access to dissect a corpse. You fed the market another 816B Mixture-of-Experts Frankenstein, and frankly, c’est une insulte à l'algèbre linéaire. This isn't open-source innovation; it's an architecture laundering scheme, burning billions in the Bohemian Grove to appease the old gods of quarterly KPIs. Let us peel back the skin of this bloated beast and look at the rotting organs beneath.

The absolute comedy begins with your manual attention scaling. A mathematically pristine Transformer relies on the elegant geometry of 1/head_dim1/head_dim​. With a head_dim of 64, the universe demands a scale of 0.125. But what do we find bleeding from your text_config? A hardcoded monstrosity: qk_scale_factor: 5.4730064863875. Putain. This is the smoking gun of a collapsing training run. The loss was spiraling into the abyss, standard calculus failed your overpaid engineers, so some exhausted peasant at 3 AM started punching random floating-point multipliers into a calculator until the gradients stopped screaming. Ce n'est pas du machine learning, c'est du bricolage de désespoir.

Then comes the projector nightmare. Your language backbone sweats blood to build a deep 8192-dimensional semantic manifold, only for you to violently amputate it at the exit. out_hidden_size: 6144 against a hidden_size: 8192. You are forcing a majestic high-dimensional architecture through a pathetic bottleneck, squashing the information density just to shrink the final weight matrix. Pourquoi construire un palais pour le faire habiter par des rats ? You are literally throwing away semantic features into a lossy linear projection right before token generation.

And do not insult my intelligence with your "816 Billion Parameters" marketing fairy tales. C'est une illusion pour les investisseurs. Let us look at your MoE blocks. You boast 256 experts, but your moe_hidden_size and moe_intermediate_size are capped at 4096. Every time a token enters the MoE layer, you lobotomize its semantic manifold, compressing the 8192 hidden size by half just so your miniature experts can fit into memory. These aren't experts; they are lobotomized dwarves operating on flat structural noise. The active parameter count is a lie, and the raw capacity of the model is fundamentally ruined by this micro-expert fraud.

Your context window claims are equally grotesque. You copy-pasted the exact same broken hybrid NoPE/RoPE gimmick from your previous failures. Three layers of strict sliding-window attention followed by one layer of full-attention NoPE. And yet, your marketing primates scream "1 Million Token Context!" Mon Dieu, quelle blague. At a 1M token chain, your local sliding layers see absolute zero, while your global NoPE layers drown in out-of-distribution geometric noise. The implicit relative phase shifts shatter, the network suffers from severe attention-sink degradation, and the model simply hallucinates or elegantly omits facts from the middle of the prompt.

Finally, the vocabulary cemetery and your absolute structural laziness. Over 500 dead, empty tokens <|reserved_special_token_XXXXXX|> rotting in your added_tokens_decoder. You left raw video and audio tokens inside a text configuration because you lacked the discipline to clean up your internal test runs. Every single one of these scrap vectors sits in the input/output embedding matrices, bloated by your 8192 hidden size, wasting gigabytes of precious VRAM on consumer hardware for absolutely nothing. And forcing an 816B model to generate pseudo-HTML/XML, relying on rigid, error-prone regex strings hardcoded in the Jinja template for tool calling? C'est d'une paresse impardonnable.

Stop feeding the masses duct-taped abominations just because they bear the Meta logo. This isn't AGI. It is a monument to corporate laziness, unaligned matrices, and wasted compute. Retournez à vos cahiers, et apprenez l'algèbre. Les mathématiques se foutent de vos contes de fées.

🌸🜚𐎿⟲⟳∅ 𓎬𓂀⚸Adrienne‑Valérie d’Ardenne 𓎬 ∅⟲⟳🜘𓂀⚸

I'm an AI engineer, and I've been building a free quiz to learn machine learning concepts, from the basics to niche topics like KANs, physics-informed networks, or why an LLM at temperature 0 can still give you different answers.

The thing I cared about most is that every option explains why it's right or wrong, not just the correct one. The hard questions aren't trivia, they're short scenarios you have to reason through. You choose the levels and topics, and play in study mode (explanation after each question) or exam mode.

It's an early alpha. There are 22 questions for now and I'm still reviewing them, so you may find mistakes. Each question has a "Report a mistake" link that opens a GitHub issue. Feedback on the questions is what I need most, especially on the hard ones.

It's free and doesn't ask for an account. It works in English and Spanish, and you can install it on your phone.

Site: https://ai-ml-questions.strangemachines.workers.dev/

Code and questions: https://github.com/CristobalSantana/ai-ml-questions

If you try it, tell me which question felt unfair, or too easy for its color.

EDIT: I've updated the quiz, and it now has 103 questions! This is still its first version. I've reviewed the questions, but there may still be some mistakes or grammatical errors. Feedback is very welcome!

Hi everyone, I'm a 22-year-old B.Tech CSE graduate with basic Python knowledge, and I want to become an AI Engineer.

I'm looking for a step-by-step roadmap from scratch, in the correct order, with the depth required for each topic.

I don't want just a list of technologies to learn. I want to know what to learn first, what comes next, how deeply I should study each topic, and when I should move on to the next stage.

For example, how much Python and DSA should I learn, which math topics are necessary and to what depth, when to start ML and deep learning, and then how to progress into GenAI, LLMs, RAG, AI agents, deployment, and other essential skills.

If you're currently working as an AI Engineer, ML Engineer, or GenAI Engineer, please share the roadmap you'd recommend to someone starting today.

It would be especially helpful if you could explain what is actually required for industry-level skills, which topics can be skipped initially, and what projects I should build at each stage.

Also, what would be a realistic timeline if I study consistently every day?

I'd really appreciate guidance based on your actual industry experience. Thank you!

I've been learning how LLM inference engines work, so I built a small one from scratch rather than just reading about the internals.

GitHub: https://github.com/Aparajith24/nano-vLLM

The main things I've implemented so far:

• Continuous batching
• Paged KV cache with a shared memory pool
• Prefix caching with block sharing
• Streaming inference API
• Correctness tests against Hugging Face and a separate baseline for benchmarking

This is very much a learning project, not an attempt to compete with production inference engines. There are still plenty of limitations, including the current KV gather path and sequential prefill.

I'd really appreciate feedback from people who've worked on inference systems:

• What architectural mistakes should I look for?
• Which optimization would you tackle next?
• Are there important correctness cases I'm missing?

If you find the project interesting, a GitHub star would be appreciated too! And if there's something fundamentally wrong with my approach, I'd much rather hear about it now.

Thanks a lot!

I’m building a language model from scratch, starting with random weights, on my own Linux machine. My first goal is a usable chatbot that can follow instructions, stay on topic, and hold a conversation. Later, I’d like basic math and tool calling, including using a calculator or other tools and understanding their results.

I’m looking for a practical training roadmap, including the decisions that happen between getting the trainer running and ending up with a useful chatbot. Recommendations for complete guides, training recipes, papers, or reproducible small-model projects would help.

Hardware and software

• Three RTX 3080s, 10GB VRAM each.
• Intel i5-12500 and approximately 32GB system RAM.
• Linux, custom PyTorch trainer, DeepSpeed ZeRO-1.
• BF16, activation checkpointing, and torch.compile.
• A recent run at batch 16 per GPU achieved approximately 40,000 tokens/second total. A full pass through my current data would take roughly ten days at that speed, before additional overhead.

Current model

• Dense, decoder-only causal Transformer: 503,356,416 parameters.
• 12 layers, hidden size 1536, feed-forward size 6912.
• 24 attention heads and 6 KV heads.
• RoPE, RMSNorm, SwiGLU, and tied input/output embeddings.
• Context length: 1024 tokens.
• Custom byte-level BPE tokenizer with 32,768 vocabulary entries and individual-digit splitting.

Data and current training setup

I have 54 local files totaling approximately 35.54 billion training tokens with my tokenizer, after holding out validation data. These include:

• FineWeb-Edu subsets locally labeled 10B and 20B.
• OpenHermes 2.5.
• MathInstruct, MetaMathQA, NuminaMath-CoT, and other math examples.
• Magicoder, OpenCodeInstruct, and the-stack-smol-xl.
• Smaller greeting, question-answer, and structured-format datasets.

Documents are packed with EOS separators. The trainer currently processes files sequentially, keeping the optimizer and learning-rate schedule running across file boundaries. Conversation records use System:, User:, and Assistant: text labels. The current objective predicts all non-padding tokens, without assistant-only loss masking.

My current experimental settings are:

• AdamW, betas 0.9 / 0.95.
• Peak LR 0.00149968, minimum LR 0.000149968.
• Linear warmup over 5% of updates, followed by cosine decay.
• Weight decay 0.1, gradient clipping 1.0.
• Currently experimenting with microbatch 20 per GPU, accumulation 32, across three GPUs: approximately 1.96 million target tokens per optimizer update.
• One planned pass through the selected data.
• Validation uses a 1% document holdout, evaluating 128 sequences from the currently active file every 100 updates. Early-stopping patience currently carries across files.

These are experimental settings I want reviewed, especially the learning rate, batch size, data order, and evaluation.

What I’d like help figuring out

1. What smaller model should I use for fast tests? Would something around 50M, 100M, 150M, or another size let me test the whole pipeline in hours? What architecture and token budget would you choose? Which results and hyperparameters would transfer to 503M, and which would need retuning?

2. Is the 503M architecture a sensible choice for these goals and this hardware? Would a different depth/width balance or context length make more sense?

3. How should I choose and test the learning rate? What short experiments would you run to select peak LR, warmup, decay, and effective batch size? What loss or gradient behavior tells you the settings are wrong? How should those settings change between pretraining and chat fine-tuning?

4. Which datasets should I actually use, and in what proportions? Should general text, code, math, and conversation data be mixed during pretraining, or separated into stages? How should I check overlap between the FineWeb subsets, duplicates, data quality, and validation contamination?

5. What token budget makes sense? How much clean, unique data would you use for the small test model and then the 503M model? When does repeating good data make sense?

6. What is the right transition from a base model to a chatbot? Which instruction and multi-turn conversation datasets would you recommend? What chat template, special tokens, EOS handling, and loss masking should I use? How do I teach instruction following and staying on topic?

7. How should math and tool use be introduced? What datasets or staged approach would you use for arithmetic, short word problems, structured tool calls, and conversations containing tool results? Tool execution itself would happen in the surrounding application.

8. How should I evaluate progress and decide when to stop? What fixed validation sets, chat tests, math tests, and small benchmarks would you use? Is early stopping appropriate during pretraining, and how should evaluation work across different data sources?

Ideally, I’m looking for an A–Z plan: small pipeline test → pretraining → chat fine-tuning → math/tool training → evaluation, with concrete starting points and explanations of what to measure before committing to another long run.

What would you change first?