Anel Music 🍉

After +9 years working in AI, here's my advice for aspiring ML engineers: If you're just starting out, let me ask you this: "𝐃𝐨 𝐲𝐨𝐮 𝐟𝐞𝐞𝐥 𝐥𝐨𝐬𝐭?" Chances are, you said yes. And I get it. You're drowning in noise: "Try this tool" "Check this framework" "Test this LLM" You keep grinding ... but at night, you wonder: "Did I actually learn anything today? ... Or did I just collect 𝐦𝐨𝐫𝐞 𝐛𝐮𝐳𝐳𝐰𝐨𝐫𝐝𝐬?" That anxious pit in your stomach? It's called 𝐅𝐎𝐌𝐎. And LinkedIn is a FOMO factory. I've been there, and trust me, it's brutal. Mentally, even physically. But here's the 𝐜𝐮𝐫𝐞 (and it's not more tools): 𝐒𝐡𝐮𝐭 𝐨𝐮𝐭 𝐭𝐡𝐞 𝐧𝐨𝐢𝐬𝐞. Pick one thing. Maybe two. Go deep. Learn the fundamentals. 𝐁𝐮𝐢𝐥𝐝 𝐬𝐨𝐦𝐞𝐭𝐡𝐢𝐧𝐠 𝐫𝐞𝐚𝐥. You don't need 40 frameworks ... you need focus. 𝐒𝐨 𝐡𝐞𝐫𝐞'𝐬 𝐦𝐲 𝐚𝐝𝐯𝐢𝐜𝐞: ✨ Come up with a project idea 📵 Close LinkedIn 💻 Start building It'll do more for your growth than any post, course, or thread. And the results will blow your mind. 🫶

235

45 Kommentare

PyTorch dataloader has 2 terrible default settings. Fixing it gave me ~5x speedup: In any standard PyTorch model training with GPU: - .to(device) transfers the data to the GPU. - Everything executes after this happens on the GPU. This means when the GPU is working, the CPU is idle, and when the CPU is working, the GPU is idle. Memory pinning can optimize this. Here's what it does: - When the model is trained on the 1st mini-batch, the CPU can transfer the 2nd mini-batch to the GPU. - This ensures that the GPU does not have to wait for the next mini-batch of data as soon as it completes processing an existing mini-batch. Enabling this is quite simple in PyTorch: - Set pin_memory=True in the DataLoader object. - During the data transfer step, do this: .to(device, non_blocking=True) Along with this, also specify num_workers in the Dataloader object. The speedup is evident from the image below. ____ Get a free visual guidebook to learn MCPs from scratch (with 11 projects): https://lnkd.in/g4ziu6va. ____ Find me → Avi Chawla Every day, I share tutorials and insights on DS, ML, LLMs, and RAGs.

335

8 Kommentare

𝗜𝘁 𝘁𝗼𝗼𝗸 𝗺𝗲 𝟯 𝘆𝗲𝗮𝗿𝘀 𝘁𝗼 𝘁𝗿𝘂𝗹𝘆 𝘂𝗻𝗱𝗲𝗿𝘀𝘁𝗮𝗻𝗱 𝗠𝗮𝗰𝗵𝗶𝗻𝗲 𝗟𝗲𝗮𝗿𝗻𝗶𝗻𝗴, (𝗯𝘂𝘁 𝗶𝗳 𝗜 𝗵𝗮𝗱 𝘁𝗼 𝗿𝗲-𝗹𝗲𝗮𝗿𝗻 𝗶𝘁 𝗶𝗻 𝟲 𝗺𝗼𝗻𝘁𝗵𝘀, 𝗵𝗲𝗿𝗲’𝘀 𝗵𝗼𝘄 𝗜’𝗹𝗹 𝗱𝗼 𝗶𝘁) As a Senior ML Scientist at Prezent, this is the perfect roadmap for working professionals: 𝗠𝗼𝗻𝘁𝗵 𝟭: 𝗣𝘆𝘁𝗵𝗼𝗻 + 𝗦𝗤𝗟 𝗯𝗮𝘀𝗶𝗰𝘀 Get comfortable with the syntax, data wrangling, and querying databases. Without these, nothing else moves. 𝗠𝗼𝗻𝘁𝗵 𝟮: 𝗦𝘁𝗮𝘁𝗶𝘀𝘁𝗶𝗰𝘀 & 𝗠𝗮𝘁𝗵 𝗳𝗼𝘂𝗻𝗱𝗮𝘁𝗶𝗼𝗻𝘀 Probability, linear algebra, calculus. Not the entire textbook - just the parts that directly power ML models. 𝗠𝗼𝗻𝘁𝗵 𝟯: 𝗖𝗼𝗿𝗲 𝗠𝗟 𝗔𝗹𝗴𝗼𝗿𝗶𝘁𝗵𝗺𝘀 Regression, classification, decision trees, ensemble methods. Code them from scratch once, then use libraries. 𝗠𝗼𝗻𝘁𝗵 𝟰: 𝗣𝗿𝗼𝗷𝗲𝗰𝘁𝘀 𝘁𝗵𝗮𝘁 𝗺𝗶𝗺𝗶𝗰 𝗿𝗲𝗮𝗹-𝘄𝗼𝗿𝗹𝗱 𝘂𝘀𝗲 𝗰𝗮𝘀𝗲𝘀 Build churn prediction, recommendation engines, sentiment analysis. Focus on clarity of problem-solving, not just code. 𝗠𝗼𝗻𝘁𝗵 𝟱: 𝗔𝗱𝘃𝗮𝗻𝗰𝗲𝗱 𝗠𝗟 + 𝗦𝗽𝗲𝗰𝗶𝗮𝗹𝗶𝘇𝗮𝘁𝗶𝗼𝗻 Start exploring neural networks, NLP, or computer vision - depending on the industry you want to target. 𝗠𝗼𝗻𝘁𝗵 𝟲: 𝗜𝗻𝘁𝗲𝗿𝘃𝗶𝗲𝘄 𝗣𝗿𝗲𝗽 + 𝗗𝗲𝗽𝗹𝗼𝘆𝗺𝗲𝗻𝘁 Mock interviews, Kaggle-style case studies, and practice explaining trade-offs. Also learn deployment basics because companies want models that run in production. And you need to act fast as you’ve already wasted so many months. 𝗦𝗼, 𝗶𝗳 𝘆𝗼𝘂 𝘄𝗮𝗻𝘁 𝘁𝗼 𝗽𝗿𝗲𝗽𝗮𝗿𝗲 𝘀𝗲𝗿𝗶𝗼𝘂𝘀𝗹𝘆, 𝘁𝗵𝗲𝗻 𝗷𝗼𝗶𝗻 𝗕𝗼𝘀𝘀𝗰𝗼𝗱𝗲𝗿 𝗔𝗰𝗮𝗱𝗲𝗺𝘆’𝘀 𝗗𝗮𝘁𝗮 𝗦𝗰𝗶𝗲𝗻𝗰𝗲 𝗮𝗻𝗱 𝗠𝗮𝗰𝗵𝗶𝗻𝗲 𝗟𝗲𝗮𝗿𝗻𝗶𝗻𝗴 𝗽𝗿𝗼𝗴𝗿𝗮𝗺 𝘁𝗼𝗱𝗮𝘆. Check it here - http://bit.ly/465EaCg 𝗧𝗵𝗲𝘆’𝘃𝗲 𝗮𝗹𝗿𝗲𝗮𝗱𝘆 𝗵𝗲𝗹𝗽𝗲𝗱 𝟮𝟮𝟬𝟬+ 𝗽𝗿𝗼𝗳𝗲𝘀𝘀𝗶𝗼𝗻𝗮𝗹𝘀 𝘁𝗿𝗮𝗻𝘀𝗶𝘁𝗶𝗼𝗻 𝘀𝘂𝗰𝗰𝗲𝘀𝘀𝗳𝘂𝗹𝗹𝘆 𝘁𝗵𝗿𝗼𝘂𝗴𝗵: ✅ Structured curriculum covering Python, SQL, ML, and visualization ✅ Real-world case studies that build your portfolio ✅ 1:1 mentorship from data scientists at top companies ✅ Resume + interview prep tailored for working professionals

268

10 Kommentare

Much of deep learning still feels more like alchemy than science, but optimizing model performance doesn't have to - even at huge scale! DeepMind researchers shared an excellent 12-part series on how to scale LLMs. This series (link in comments) aims to demystify the science of scaling language models: how TPUs (and GPUs) work and how they communicate with each other, how LLMs run on real hardware, and how to parallelize your models during training and inference so they run efficiently at massive scale. If you've ever wondered "how expensive should this LLM be to train?" or "how much memory do I need to serve this model myself?" or "what's an AllGather?", this series will be useful. This will help researchers designing new architectures and engineers working to make current LLMs run faster. Promising model architectures routinely fail because they can't run efficiently at scale or because no one puts in the work to make them do so. The series also provides useful perspective on the evolving distinction between scientists and engineers in AI. While I believe there's still a meaningful distinction, this work illustrates that scaling considerations are engineering topics that ML researchers now need to master - something that wasn't as critical 4+ years ago. Here is the outline: Part 1: Preliminaries Chapter 1: A Brief Intro to Roofline Analysis Chapter 2: How to Think About TPUs Chapter 3: Sharded Matrices and How to Multiply Them Part 2: Transformers Chapter 4: All the Transformer Math You Need to Know Chapter 5: How to Parallelize a Transformer for Training Chapter 6: Training LLaMA 3 on TPUs Chapter 7: All About Transformer Inference Chapter 8: Serving LLaMA 3 on TPUs Part 3: Practical Tutorials Chapter 9: How to Profile TPU Code Chapter 10: Programming TPUs in JAX. Part 4: Conclusions and Bonus Content Chapter 11: Conclusions and Further Reading Chapter 12: How to Think About GPUs Have fun! Excited to hear what you think of the series. #ai #genai #llm

173

13 Kommentare

Just published a video tutorial on how to build and iterate on a Graph RAG pipeline using Kuzu, marimo and DSPy (Community). I've been using all these tools a lot lately, but when used together, I believe they have a lot of synergy with one another, so allow me to elaborate: ✅ When working on an idea like Graph RAG, the starting point is that you have a knowledge graph that you can query (ideally with Cypher in Kuzu 😄). DSPy makes it very simple to compose together modules that help you use LMs to write Cypher. This tutorial covers the key steps. ✅ The traditional way to work with interactive workflows has (thus far), been Jupyter notebooks. However, marimo is paving the way for a new paradigm in Python: the SAME Python file can simultaneously serve as a notebook, a script AND an interactive app! ✅ To retrieve from the graph, a modular Text2Cypher pipeline is built with the following components that are written as a custom DSPy module: 1. Schema pruning (to trim down the graph schema as context for the next step) 2. Text2Cypher (Using an LM to generate Cypher queries) 3. Answer generation (Using an LM to inspect the retrieved context from the graph and answer in natural language). It's a joy to be able to build with a truly modern stack like uv, marimo, Kuzu and DSPy, and to be building composable pipelines that allow a rapid iteration feedback cycle. And the best part: these are ALL open source software! ✅ The DSPy pipeline shown in the tutorial was quite simple (no optimization). It's very clear that even without optimization, DSPy shows a lot of promise to make it easier to work with LMs for any arbitrary tasks. Graph RAG isn't something that needs to be a pre-built, commoditized library - with the flexibility of DSPy's modules, you can build almost anything of any complexity, and interweave your language model calls with deterministic code. I want to go a lot deeper into the abstraction philosophy of DSPy and why I'm excited about it, and am working on a blog post related to the same, so stay tuned! In the meantime, install marimo, fire up a Kuzu database and give this workflow a try! 😄 https://lnkd.in/gX_wN2Dh

89

6 Kommentare

I (finally) implemented Qwen3 Mixture-of-Experts from Scratch in pure PyTorch The Qwen3 model suite recently added new open-weight models (Instruct, Thinking, and Coder), and I couldn't resist... As I mentioned a few weeks ago, I've been using the older (and smaller) Qwen3 dense models as a starting point for experimentation and research due to their really good performance. After last week's release, I finally sat down and coded the MoE variants as well. The purpose of this re-implementation is to have human-readable code to better understand the internals and make it easier to adapt or modify for downstream tasks. If you are curious, you can check out the notebook here: https://lnkd.in/g_zb6K26 tldr: - Qwen3 Coder Flash (30B-A3B) architecture - MoE setup with 128 experts, 8 active per token - Pure PyTorch in a standalone Jupyter notebook - Roughly 60 GB memory requirement (runs on a single A100 or newer)    Happy tinkering!

7.610

229 Kommentare