AlphaSignal’s Post

🚀 AI Chapter Takeaways #4 – Build a Large Language Model (Ch.2: Working with text data) Question 4: Describe the sliding window approach for creating training examples from text. Why is stride selection important? Answer: Sliding window = generate overlapping input-target pairs for next-token prediction. Example: Text: "The cat sat on the mat" Tokens: [1,2,3,4,5,6], context=4 Stride=1 → overlapping windows   Input=[1,2,3,4] → Target=[2,3,4,5]   Input=[2,3,4,5] → Target=[3,4,5,6] Stride=4 → non-overlapping   Input=[1,2,3,4] → Target=[2,3,4,5]   Input=[5,6,...] → Target=[6,...] Trade-offs: Small stride → more samples, higher redundancy Large stride → efficient, fewer samples Best practice: stride = context length → avoids overfitting and maximizes efficiency.

🚀 Struggling with slow or lossy OCR pipelines? DeepSeek-OCR offers an open-source, LLM-integrated vision-text compression solution that accelerates text extraction while preserving context across multi-page documents and images. Here’s how it works: ↳ Robust pretraining: Uses context-aware visual text datasets for natural OCR error recovery and end to end pipeline stability. ↳ Model aware inference: Filters image text trajectories to match model capacity, enabling sustained exploration of document layouts and fonts. ↳ Optimized pipeline: Leverages vLLM streaming with concurrency tuning (~2500 tokens/s on A100) to balance speed and accuracy. ↳ Deliberative reasoning: Fewer, precise text calls combined with deep internal representation for peak text fidelity. Open-source baseline that transforms OCR for research and industrial pipelines. Check it out on GitHub: https://lnkd.in/d8jzEjw2 Share this with your network if you found this insightful ♻️ Follow me (Botanic.AI) for more insights on AI and Machine Learning!

I built Lean-Agentic because I wanted a system that could both invent and verify new mathematical ideas at the speed of thought. Lean-4 showed what was possible with formal proofs, but it was never designed for the kind of interactive, AI-driven exploration we’re doing today. So I rebuilt it from the ground up in Rust, creating a high-performance language that compiles to WebAssembly and runs anywhere: browser, client, or integrated directly with AI frameworks like Claude Code and MCP. You can launch it instantly with: npx lean-agentic repl This opens a real-time environment where you can explore, test, and prove theorems in milliseconds. Lean-Agentic also exposes a full suite of MCP tools, allowing agents to create, verify, and analyze proofs directly through natural language. It gives AI systems the ability to reason with mathematical certainty. At its core, Lean-Agentic combines dependent type theory with live theorem discovery. It doesn’t just check correctness, it invents new logical paths, explores structures, and validates them with cryptographic signatures. Every proof is verifiable, timestamped, and signed, showing exactly when and how a new result was achieved. Because it’s built in Rust, it runs hundreds of proofs per second, opening up new frontiers for AI reasoning, formal safety validation, and autonomous scientific discovery. It’s fast, auditable, and real. Lean-Agentic turns mathematical creativity into a verifiable process you can run anywhere. It’s not just faster, it’s a new way to create and prove truth. NPM: https://lnkd.in/gxpKqTYN GitHub: https://lnkd.in/g87_Hi-6

🚀 Day 18/100 of my AI Engineer Challenge. ✅ Today’s Topic: Machine learning- K-Nearest Neighbor(KNN) Algorithm 🔹KNN is a supervised learning algorithm used for classification (and sometimes regression). 🔹Implement a simple program on find a distance between two point 🔹How it works: 1.Choose a value of K (number of neighbors). 2.Calculate the distance between the new data point and all existing data points. (Common: Euclidean distance) 3.Select the K nearest neighbors. 4.Take a majority vote among the neighbors for classification. 5.Assign the most common class to the new data point. 🔹 Key takeaway: 1. Distance Formula (Euclidean) d(p,q)=√∑(pi−qi)^2=√(p1-p2)^2+(q1-q2)^2 2.Choosing K Small K → Model sensitive to noise. Large K → More stable but may ignore small patterns. Often use odd K to avoid ties. code 📁 :[https://lnkd.in/gvTbxzYD]

Tiny Models, Infinite Loops: How Recursive Reasoning Beats Giant LLMs The new paper “Less is More: Recursive Reasoning with Tiny Networks” by Alexia Jolicoeur-Martineau (Samsung SAIT Montreal) delivers a stunning result 10,000× fewer parameters, yet better reasoning. While today’s Large Language Models (LLMs) rely on billions of parameters to mimic reasoning, this work flips the script: what if reasoning doesn’t need scale, but recursion? 🧠 The Core Idea Instead of memorizing patterns, the proposed Tiny Recursive Model (TRM) “thinks in loops.” A single small network repeatedly refines its answers updating internal states and revisiting its own output, like a human double-checking logic steps. Each recursion layer acts as a thought iteration, improving the previous one. This process happens without growing the model, only deepening its reasoning path. ⚙️ Architecture in Brief Single lightweight network (~7 M parameters) Two key steps: 1. Update latent reasoning state z ← net(x, y, z) 2. Update answer y ← net(y, z) Looped T times, with only the final pass backpropagated Uses EMA (Exponential Moving Average) for stability No attention layers or large context windows just recursion and feedback The design eliminates the heavy fixed-point and dual-network assumptions of older Hierarchical Reasoning Models (HRM). Training becomes faster, simpler, and less memory-intensive. 📊 Results That Redefine Efficiency On structured reasoning benchmarks like Sudoku-Extreme, Maze-Hard, ARC-AGI-1, and ARC-AGI-2, TRM outperforms both HRM and several LLMs (Gemini 2.5 Pro, o3-mini, Deepseek R1) despite using less than 0.01% of their parameters. Task TRM Accuracy LLM Baselines Sudoku-Extreme ~87 % Near 0 – few % ARC-AGI-1 ~45 % Gemini 2.5 Pro ≈ 37 % These results show that reasoning ≠ scaling iterative refinement can outperform raw size. 🚀 Why This Matters Recursive reasoning could shift AI from “memorizing data” to “thinking in steps.” It opens the door to: Edge AI & on-device reasoning (phones, IoT) Greener compute with drastically lower energy use Better generalization on small, logic-heavy datasets It’s a powerful reminder that intelligence may not come from bigger networks, but from smarter loops.

Just read a nice article on arXiv, "Less is More: Recursive Reasoning with Tiny Networks" by Alexia Jolicoeur-Martineau. It's a good read with a cup of morning coffee. For so long, we’ve all been conditioned to think about sheer scale in AI, right? We assume that winning the parameter race is how magic happens. But guess what? A tiny model just beat the giants at their own game! (allegedly) The new Tiny Recursive Model has only 7 million parameters. That’s peanuts compared to the massive LLMs we usually talk about. And yet, this little engine is actually outperforming models like Gemini 2.5 Pro on complex reasoning challenges like Sudoku-Extreme and ARC-AGI. I mean, we're talking about a model with less than 0.01% of the parameters delivering better results on a pure reasoning task! So, what's its secret sauce? It’s all about the process, not the size. Instead of trying to crank out the perfect answer in one go (which, let's be honest, can be brittle), TRM uses a recursive approach. It literally makes a guess, then refines that answer step-by-step, over and over. It’s like the model is taking notes, thinking things through, and doing self-correction as it goes. This really makes you realize that for our super-hard, structured problems, the answer might be this kind of efficient, specialized reasoning engine. But here's the kicker: as cool as this is, we haven't seen a large-scale enterprise fully adopt and productionize this model structure yet. It's fantastic in the lab, but can this tiny, recurrent engine handle the scale and robustness demands of real-time commerce and data? That's the billion-dollar question. Once we know better cost, latency, and throughput metrics, this will be an interesting option to pursue. It’s an incredible lesson in efficiency and smart architecture. Do we really need a massive, expensive net for everything, or can we start doing more with less?

Less is more in AI: Samsung SAIT Montréal unveiled a 7M‑parameter Tiny Recursive Model (TRM) that rivals or surpasses vastly larger LLMs on hard reasoning benchmarks like ARC‑AGI, challenging the “bigger is better” playbook. By iteratively refining a latent scratchpad and provisional answer in a think/act loop, TRM trades speed for accuracy and shows how recursion can substitute for sheer scale on structured tasks. Highlights: 7M parameters, two layers, recursive reasoning with alternating “think” and “act” updates on a latent state and candidate solution 🤔 Results: ~45% ARC‑AGI‑1 and ~8% ARC‑AGI‑2 under the paper’s evaluation, outperforming much larger models including DeepSeek‑R1, o3‑mini, and Gemini 2.5 Pro on these tests. 🧩 Puzzles: 87.4% on Sudoku‑Extreme and 85.3% on Maze‑Hard, showing strong generalization on structured reasoning tasks. 🔨🔧Open and reproducible: code and materials are publicly available for experimentation and adaptation under permissive terms. 🤤 Caveat: specialized for structured puzzles rather than open‑ended chat, and slower in wall‑clock time due to multi‑step recursion. Why it matters: 🔥🔥Demonstrates a practical path to parameter‑efficient, lower‑cost reasoning that could run on edge or constrained hardware while maintaining strong accuracy on targeted tasks. 🔥🔥Points toward hybrid systems where a tiny recursive reasoner complements larger LLMs, improving reliability on exacting logic while keeping compute budgets in check.

Fine-Tuning LLMs: The Real Difference Between “Full” and “Parameter-Efficient” Fine-Tuning In the world of Large Language Models, fine-tuning is where the real magic happens — but not all fine-tuning is created equal. Here’s the breakdown 👇 🔹 Full Fine-Tuning You update every single weight in the model. ✅ Maximum performance on your task ❌ Requires enormous GPU memory ❌ Creates a new copy of the model for each task Great for research labs. Not so practical for startups or rapid experimentation. 🔹 Parameter-Efficient Fine-Tuning (PEFT) You freeze the base model and train only a small set of adapter parameters. Techniques like LoRA, QLoRA, DoRA, and Spectrum make this possible. 💡 The SuperAnnotate team notes that LoRA can reduce trainable parameters by up to 10,000× while still delivering near full-tuning performance. That means lower GPU bills, faster iteration, and less catastrophic forgetting. 🔹 Alternative Adaptation Methods Other approaches — like multi-task fine-tuning, sequential fine-tuning, and instruction tuning — teach models to handle multiple tasks or follow human-like prompts. And if you want knowledge without retraining? Use RAG (Retrieval-Augmented Generation) — it doesn’t touch model weights at all, just brings in external context when needed. 💭 The takeaway: Fine-tuning isn’t one-size-fits-all. Choosing the right approach depends on your compute budget, data size, and how much control you need. 📢 What’s your go-to method for adapting LLMs — full fine-tuning, PEFT, or RAG? #AI #MachineLearning #LLMs #FineTuning #LoRA #QLoRA #DoRA #RAG #DeepLearning #AIMastery

GUIs are dead and AI killed them. I've been thinking about this for weeks. Every abstraction layer in computing eventually gets replaced by something more intuitive. We went from punch cards to command lines, command lines to graphical interfaces. Now we're watching GUIs die in real time. I started noticing it in my own work. When was the last time you actually opened Finder? Or clicked through a file tree? I realised I haven't done it in months. I just tell Claude what I need: "move these files here," "find everything from last week," "set up this project structure." Done. This isn't about convenience. It's a fundamental shift. While researching this, I found an article by Sean (0xs34n) that nailed exactly what I'd been thinking. He traces the 50-year arc from Xerox PARC's GUI in 1973 to today's AI agents. The pattern is clear: each generation of computing makes the previous one look primitive. Not because it was bad, but because we found a better way to translate human intent into machine action. Here's the thing Steve Jobs understood decades ago - he said technology should either be beautiful or it should be invisible. He was obsessed with both. But what we're seeing now goes beyond even his vision. He imagined better interfaces. He couldn't imagine no interface at all. The cognitive load we've been carrying for 50 years - remembering folder structures, learning keyboard shortcuts, navigating nested menus - it's all evaporating. We're not learning to speak computer anymore. The computer is learning to speak human. Think about what this means: the bicycle for the mind just became a teleporter. You don't pedal, steer, or balance. You just say where you want to go. Sean's article is worth reading if this interests you. It's called "The Death of the User Interface" and it captures what a lot of us are starting to feel but haven't articulated yet. The interface isn't being simplified. It's being eliminated. And that might be the most user-friendly thing that could possibly happen.

Updates and new features: ⭐ Claude Sonnet 4.5 ⭐ It replaces Claude Sonnet 4. See the release note from Anthropic here: https://lnkd.in/eEN3MDfc 🧠 Memory of the conversation 🧠 We've significantly expanded conversation memory capacity. Your model can now access context from the entire conversation history, no matter how long the conversation is. 🎨 Formatting of the AI answer 🎨 The design of the AI responses has been improved. The spaces between paragraphs and titles are now more adjusted. The quotes, the tags and the generated tables have a better color design. ⛵ Bye bye Midjourney ⛵ Our Midjourney provider stopped its service last week. Unfortunately, we found no serious alternative as Midjourney has not yet been providing its own API. While Midjourney currently ranks 4th in our image model usage (behind Nano Banana, GPT Image, and FLUX) and 5th in benchmark performance (after Recraft), it holds a special place in our hearts. We may recreate its 4-image generation feature with other models in the future. We hope Midjourney eventually launches a developer-friendly API. Until then, we'll sail our separate ways.