We just shipped Orato ASR and TTS: Hindi/Hinglish speech models built for real-time voice agents.Over the past few months, we've been building speech models for Orato, along with Anand Dubey: real-time voice agents for Indian calling workflows like customer support, appointment booking, insurance, and sales.𝗪𝗵𝗮𝘁 𝘄𝗲 𝗯𝘂𝗶𝗹𝘁: • Orato ASR: a full-parameter fine-tune of Qwen3-ASR-0.6B on ~1,000 hours of Hindi/English/Hinglish calling-domain audio• Orato TTS: a Hindi/Hinglish text-to-speech model built on IndicF5-TTS, with multi-speaker and voice-clone supportFine-tuning improved WER across every benchmark we tested against the base model, with the biggest gains exactly where it matters most for a voice agent: noisy, accented, telephony-style speech (Lahaja: 25% relative improvement, Kathbath: 24.6%), not just clean studio audio nobody actually calls on.Both models are live on Hugging Face, access is auto-approved, so go ahead and try them:🔗 ASR: https://lnkd.in/g-3VDDiV🔗 TTS: https://lnkd.in/gYsk9nJQThis is just the start. Everything we learned getting here is already shaping what we're building next.Would genuinely love to hear your feedback if you give these a try.

GenAI Interviewer Question SeriesInterview: Two retrieved documents contain different answers to the same question. One is from last year, while the other was updated yesterday.Question:How would you design the retrieval and ranking pipeline to identify the authoritative and most recent information?Explanation: Metadata Filtering: Store document version, effective date, source, department, and authority level as metadata during ingestion.Retrieval: Use hybrid search to retrieve semantically relevant documents, then apply metadata filters where appropriate.Authority Ranking: Assign higher ranking to trusted sources, such as official policies, over drafts or user-generated documents.Recency Ranking: Boost documents with newer effective dates, not simply upload timestamps.Reranking: Use a cross-encoder/reranker combining relevance, authority, version, and freshness signals.Conflict Detection: If two high-confidence sources still conflict, trigger a conflict-resolution step rather than blindly selecting one.Generation: Instruct the LLM to prioritize the authoritative, latest effective document and provide citations.Evaluation: Measure retrieval accuracy, freshness, source correctness, and conflict-resolution accuracy.

Production AI is not "pick a model, write a prompt, ship."Here’s what’s actually inside an AI engineer’s brain before production.The model is only one part of the system.The hard part is making the whole thing reliable, affordable, and useful for a real user problem.Here’s the mental checklist:→ User problem:What exact job is the user trying to get done?If this is fuzzy, everything after this is optimization around the wrong target.→ Retrieval:Do we need RAG at all?If yes, what should be retrieved, how fresh should it be, and what happens when retrieval returns weak context?→ Agent behavior:Should this be a simple prompt flow or a real agent?More tool use means more power... and more ways to fail.→ Latency:How long can the user reasonably wait?A great answer in 18 seconds is often worse than a good answer in 3.→ Token cost:What does each request cost at scale?Long context, multiple retries, and agent loops quietly turn into a budget problem.→ Evals:How will we know the system is good?Not just "it worked in the demo" but task success, answer quality, safety, and consistency.→ Retries:What fails transiently, and what fails permanently?You need different handling for timeout, empty retrieval, malformed output, and tool failure.→ Rate limits:What happens under real traffic?One happy path test says nothing about production concurrency.→ Logging:Can we trace what happened for one bad response?Prompt, retrieved chunks, tool calls, model output, latency, and final decision should all be visible.→ Structured output:What happens when the model breaks your JSON?Because eventually it will.→ Guardrails:What is the model allowed to say, do, or trigger?Especially when answers can affect money, data, or customer trust.The key takeaway:Production AI is not prompt engineering.It is systems engineering around a probabilistic model.And the best teams keep coming back to one question:Does this actually solve the user’s problem... better, faster, or cheaper?

Y Combinator just open-sourced a multiplayer Agent Harness for your entire company 🤯One agent shared by everyone. Each person uses it privately, teams use it together in Slack.It's called QM. 100% Open Source under MIT license. Most agent setups are built like personal assistants. One person, one context. Run that for a whole team and everything collides. Shared credentials, tangled memory, zero permissions.QM flips the design. Every employee gets an isolated workspace with their own memory, files, keychain, and a durable sandbox where installed tools stay installed. The same agent then shows up in shared Slack channels and projects to work with the team.And it's harness-agnostic. Claude Code, Codex, OpenCode, and Pi all drive the same core, so your deployment isn't locked to one vendor.What teams run on it:• Inbox triage on a schedule, with reply drafts in your writing voice• Internal web apps the agent builds and publishes to specific people• Repo work: tests, PRs, CI monitoring• Crons and watches that keep working while nobody's onlineSecurity comes in three postures. Strict pauses every tool call for human approval. Auto screens external data with a classifier before it reaches the model. Everything is audited under each person's own credentials.Deploys to your own AWS or Fly account with one command.My favorite detail: they only accept contributions as written descriptions, not code. You describe the change in a markdown file, the maintainers implement it. One of the four listed contributors is Claude itself.

Lately, I've been interviewing AI Engineer candidates with 1–2 years of experience.One thing surprised me.Almost everyone can talk about RAG.Almost everyone has built AI agents.Most have used LangChain, LangGraph, OpenAI, Claude, or Gemini.But when the conversation moves beyond frameworks......that's where many interviews start to slow down.I ask simple questions like:"Why do embeddings work?""Why does chunk size affect retrieval?""Why does an attention mechanism matter?""What actually happens before an LLM generates the first token?"The room usually goes quiet.It made me realize something.We're getting really good at building AI applications.But we're slowly skipping the fundamentals that make those applications reliable.AI tools can write code.They can generate APIs.They can even scaffold an entire project.But they can't replace your understanding.If retrieval quality drops...If latency suddenly doubles...If hallucinations increase...If your AI agent gets stuck in a loop...The solution isn't another framework.It's understanding what's happening underneath.Frameworks will change.Models will change.The fundamentals won't.That's why, before every interview, I'd rather revise concepts like:→ Transformers→ Attention Mechanism→ Embeddings→ Tokenization→ Vector Search→ HTTP & APIs→ System Design→ Databases→ Evaluation→ Python fundamentalsThese are the concepts that help you explain why something works, not just how to build it.If you're preparing for AI Engineer interviews, don't spend all your time learning the next framework.Spend some time strengthening the foundation that every framework is built on.If you want to clear AI interviews 99% confidently, this Interview Kit is for you.Learn in depth → Practice → Perform → Crack the jobEnroll here: https://lnkd.in/guPzFkTe

Claude Code commits leak secrets 2x more than humans.(28M hardcoded secrets shipped to GitHub in 2025)GitGuardian tracked every public commit on GitHub last year and found Claude Code-assisted commits leaked credentials at 3.2%, against a 1.5% human baseline.Karpathy described vibe coding as "fully givegiving in to the vibes, embrace exponentials, and forgetting that the code even exists." When you stop reading diffs, you stop seeing what went into them.A key you pasted into the prompt for context gets written into a config file, and the agent has no reason to treat it differently from any other string.Most people end up wiring the verification themselves. A pre-commit hook that shells out to a scanner, or a script that pipes findings back into the agent's context.Both are glue you now maintain, and both run outside the session where the code gets written.SonarQube (by Sonar) ships a CLI that removes the glue entirely, and one command wires it into Claude Code:```sonar integrate claude -p <your-project>```That registers the hooks and configures the SonarQube MCP server in the same step, which gives you three layers running against the agent's work:→ Secrets detection runs on every prompt you submit and every file the agent reads or writes.→ Static analysis checks whatever your agent just wrote, using the same rules a full CI scan would apply.→ The MCP server puts those findings in Claude's context, so it reads its own issues and fixes them.Secrets detection and the MCP server both work on the SonarQube free tier, while the deeper code analysis and verification layer with is part of Sonar Vortex requires a paid plan with the proper entitlementIn the video below, a real-format GitHub token gets intercepted at prompt submission, before the model ran.Every DIY setup works until the agent's workflow changes and the glue quietly stops firing. Verification that ships with the tool doesn't have that failure mode.Link to the GitHub repo in the first comment. _____Share this with your network if you found this insightful ♻️Follow me Akshay Pachaar for more insights and tutorials on AI and Machine Learning!

Fine-Tune 100+ LLMs without writing a single line of code! LLaMA-Factory lets you train and fine-tune open-source LLMs and VLMs without writing any code. Here's why it's a game changer for fine-tuning: • Fine-tune 100+ LLMs/VLMs with built-in templates (LLaMA, Gemma, Qwen, Mistral, DeepSeek, and more). • Zero-code CLI & Web UI for training, inference, merging, and evaluation. • Supports full-tuning, LoRA, QLoRA, freeze-tuning, PPO/DPO, OFT, reward modeling, and multi-modal fine-tuning. • Speeds up training/inference with FlashAttention-2, RoPE scaling, Liger Kernel, and vLLM backend. • Integrates experiment tracking via LlamaBoard, TensorBoard, Weights & Biases, MLflow, and SwanLab. It's 100% Open Source Link to the Github repo in the comments! If you're into ML, LLMs, RAG, and AI Agents, I share AI apps, Open Source Projects and tutorials every week. Subscribe to AI Engineering (it's free): https://lnkd.in/gfkzKZYk

Google recently launched the new AI File Search API -- which means you may not need to set up your own vector DBs for RAG. This is a fully managed RAG layer where Google handles storage, chunking, embeddings, retrieval, and citations for you. You just upload files and call generateContent. That’s it. What it does: - Makes RAG dead simple for solo builders and teams who don’t want to manage infra. - Cuts down cost + dev time since storage + query-time embeddings are free. How it works: - You upload files (PDFs, DOCX, TXT, JSON, code files, etc.) into a File Search Store. - Google automatically chunks, embeds, and indexes them using the latest Gemini Embedding model. - At query time, the model performs vector search over your uploaded data. - Relevant chunks are injected automatically into the prompt inside generateContent. - Responses come with citations that point to the exact chunks used. - You only pay once for initial embedding (around $0.15 per million tokens), everything else is free. It’s basically RAG without the whole “RAG pipeline.” Pretty exciting if you're building AI tools, internal assistants, customer support bots, or anything that needs grounding in private data. ♻️ Share it with anyone who’s trying to simplify their RAG stack :) I share tutorials on how to build + improve AI apps and agents, on my newsletter 𝑨𝑰 𝑨𝒈𝒆𝒏𝒕 𝑬𝒏𝒈𝒊𝒏𝒆𝒆𝒓𝒊𝒏𝒈: https://lnkd.in/gaJTcZBR Link to the announcement: https://lnkd.in/gXTPhX57

Agent-maintained wikis will become the default context layer for AI systems. And OpenWiki is one of the best examples I've seen... → https://lnkd.in/deSmhGBn Traditionally, documentation has been a manual process. You write it. It slowly goes out of date. Nobody wants to maintain it. Now we have OpenWiki. It continuously builds and maintains a wiki for either: • Your codebase • Your personal knowledge This is also how I think about LLM wikis. I use them as the context layer between my Second Brain and the work my AI systems actually perform. Instead of giving an agent direct access to everything I know, I let it navigate a structured wiki that evolves over time. Then the wiki becomes an interface between humans and AI agents. For repositories, it can: • Generate documentation • Keep it updated as the code changes • Create architecture diagrams • Explain relationships between components For personal knowledge, it can ingest sources like: • Local repositories • Gmail • Notion • Web search • Hacker News • X ...and synthesize them into a continuously evolving personal wiki. OpenWiki outputs everything in Google's Open Knowledge Format (OKF). This means the knowledge isn't trapped inside a proprietary database. It's stored as linked Markdown documents that are: • Human-readable • LLM-readable • Git-friendly • Vendor-neutral We'll see many more systems adopt this pattern. Not because it's another documentation tool… But because it gives agents a living knowledge layer instead of asking them to rediscover the same information every session. If you're building AI assistants, coding agents, or long-term memory systems, OpenWiki is definitely worth studying. GitHub: https://lnkd.in/deSmhGBn

This is the most (practical) Agentic AI Course. Taught by Andrew Ng, available for free on Deeplearning AI. Also with practical assignments to complete :) Here's what it covers: Reflection → AI reviews its own output. → Catches mistakes automatically. → Like code review, but smarter. Tool Use → Connects AI to real APIs. → Databases, web search, code execution. → Not just text generation anymore. Planning → Breaks big tasks into steps. → Adapts when things go wrong. → Real problem solving, not scripts. Multi-Agent Systems → Multiple AI agents working together. → Each one handles a specific job. → This is how production systems scale. Check it out here: https://lnkd.in/dtiWR7qn Bookmark this before you lose it. Repost ♻️ for people learning agentic AI. Check my profile for more resources on AI 👋

AI Engineer Interview Question: "Your agent crashes at step 200 of 240. What happens next?"Most candidates say "we retry the run" and stop there, which is the wrong half of the answer. What the interviewer is actually testing:Retrying is the easy part. The cost of that retry is the real question.200 steps is 40 minutes of tokens you already paid for, plus tool calls that already changed things. If the run state lived in process memory, a pod eviction or a routine deploy takes all of it. You start again at step 1, pay for every step twice, and every write fires a second time.A journaled run goes forward from step 201 instead. 3 things make that work.1. Checkpoint the run state. Write each finished step to a durable store before the next one starts. The unit is the step boundary. LangGraph's MemorySaver is in-process, so it dies with the process.2. Key every mutation. Mint the idempotency key before the call and store it with the step. The dedupe has to live at the provider, since your retry logic died too.3. Replay reads, skip sends. Repeatable calls run again. Anything that spends money or reaches a human loads its recorded result. Model output counts as a side effect.One line worth saying out loud in that interview: a checkpoint is not durable execution. Something outside the process still has to notice the death and restart the run.What is your agent's run state sitting in right now, Postgres or the process that is about to get redeployed?Connect/Follow for more such deep dives.

Ultimate guide for Building AI Agents. 📹 Videos: 1. LLM Introduction: https://lnkd.in/dYunDzPz 2. LLMs from Scratch: https://lnkd.in/dKpTM6QP 3. Agentic AI Overview (Stanford): https://lnkd.in/dYfBSz7a 4. Building and Evaluating Agents: https://lnkd.in/dFAvUnFW 5. Building Effective Agents: https://lnkd.in/dmEFwhEX 6. Building Agents with MCP: https://lnkd.in/d6TY_jS5 7. Building an Agent from Scratch: https://lnkd.in/dMFgGxhr 8. Philo Agents: https://lnkd.in/d8DS_d_2 🗂️ Repos 1. GenAI Agents: https://lnkd.in/dKbmSuuj 2. Microsoft's AI Agents for Beginners: https://lnkd.in/dzs92TgE 3. Prompt Engineering Guide: https://lnkd.in/gJjGbxQr 4. Hands-On Large Language Models: https://lnkd.in/dxaVF86w 5. AI Agents for Beginners: https://lnkd.in/dzs92TgE 6. GenAI Agentshttps://lnkd.in/dEt72MEy 7. Made with ML: https://lnkd.in/d2dMACMj 8. Hands-On AI Engineering:https://lnkd.in/dSWSJuax 9. Awesome Generative AI Guide: https://lnkd.in/dJ8gxp3a 10. Designing Machine Learning Systems: https://lnkd.in/dEx8sQJK 11. Machine Learning for Beginners from Microsoft: https://lnkd.in/dBj3BAEY 12. LLM Course: https://lnkd.in/dcnAPv8h 🗺️ Guides 1. Google's Agent Whitepaper: https://lnkd.in/gFvCfbSN 2. Google's Agent Companion: https://lnkd.in/gfmCrgAH 3. Building Effective Agents by Anthropic: https://lnkd.in/gRWKANS4. 4. Claude Code Best Agentic Coding practices: https://lnkd.in/gs99zyCf 5. OpenAI's Practical Guide to Building Agents: https://lnkd.in/guRfXsFK 📚Books: 1. Understanding Deep Learning: https://lnkd.in/dTTE2K9X 2. Building an LLM from Scratch: https://lnkd.in/g2YGbnWS 3. The LLM Engineering Handbook: https://lnkd.in/gWUT2EXe 4. AI Agents: The Definitive Guide - Nicole Koenigstein: https://lnkd.in/dJ9wFNMD 5. Building Applications with AI Agents - Michael Albada: https://lnkd.in/dSs8srk5 6. AI Agents with MCP - Kyle Stratis: https://lnkd.in/dR22bEiZ 7. AI Engineering: https://lnkd.in/dzS6DHyW 📜 Papers 1. ReAct: https://lnkd.in/gRBH3ZRq 2. Generative Agents: https://lnkd.in/gsDCUsWm. 3. Toolformer: https://lnkd.in/gyzrege6 4. Chain-of-Thought Prompting: https://lnkd.in/gaK5CXzD. 5. Tree of Thoughts: https://lnkd.in/gRJdv_iU. 6. Reflexion: https://lnkd.in/gGFMgjUj 7. Retrieval-Augmented Generation Survey: https://lnkd.in/gGUqkkyR. 🧑🏫 Courses: 1. HuggingFace's Agent Course: https://lnkd.in/gmTftTXV 2. MCP with Anthropic: https://lnkd.in/geffcwdq 3. Building Vector Databases with Pinecone: https://lnkd.in/gCS4sd7Y 4. Vector Databases from Embeddings to Apps: https://lnkd.in/gm9HR6_2 5. Agent Memory: https://lnkd.in/gNFpC542 6. Building and Evaluating RAG apps: https://lnkd.in/g2qC9-mh

A two-person red team used AI agents to pentest applications the way a human researcher would, not a scanner and it started closing gaps enterprise security teams were missing.Now the tool behind it is open-source.It is called Strix.Most people run a vulnerability scan by giving AI one static task:"Flag anything that looks like a known CVE pattern."Strix takes a more active approach.First, the agent maps the application's live attack surface.Then it launches itself against each entry point, attempting to actually break it.Each run happens in an isolated environment, where it can:> Test endpoints dynamically instead of pattern-matching> Build a working proof-of-concept exploit> Inspect raw requests through a built-in HTTP proxy> Confirm the bug is real before reporting itIt behaves like a real security researcher instead of a static scanner — dynamically testing applications and validating vulnerabilities with proof-of-concept exploits.It doesn't tell you "this might be exploitable." It shows you the exploit.This is an open-source AI agent that replaces the first pass of a pentest.github.com/usestrix/strix

LMCache: reuse KV cache to speed up AI inferenceLong-context and multi-turn LLM apps often recompute the same tokens again and again. LMCache reduces that wasted work.Why this matters:- Lower time-to-first-token for long prompts and RAG- Better GPU utilization under repeated or similar requestsHow LMCache works:- Reuses KV cache for repeated text, not just prefixes- Stores KV cache on GPU, CPU, or disk- Allows cache reuse across different serving instances- Integrates with vLLM and SGLang for KV cache offloading- Works well for multi-turn chat and RAG workloads- It’s a practical way to treat KV cache as shared infrastructure instead of a per-request artifact.♻️ Share it with anyone who’s running LLMs in production :)I share tutorials on how to build + improve AI apps and agents, on my newsletter 𝑨𝑰 𝑨𝒈𝒆𝒏𝒕 𝑬𝒏𝒈𝒊𝒏𝒆𝒆𝒓𝒊𝒏𝒈: https://lnkd.in/gaJTcZBRLink to repo: https://lnkd.in/ekp-uBjy

AI interviews aren't getting harder.They're getting more practical.A few years ago, knowing embeddings and vector databases was enough.Today, interviewers want to know what happens after you deploy.Can your agent remember past conversations?How do you prevent context windows from overflowing?When should you use PostgreSQL instead of a vector database?How do you update millions of embeddings without downtime?How do you isolate memory between users?How do you reduce vector search latency?These aren't trick questions.They're production problems.In this carousel, I cover 15+ interview questions that go beyond definitions.You'll Understand:• Short-term vs long-term memory architecture• Conversation memory management• Relational vs document vs vector databases• Hybrid search with BM25 + Vector Search + RRF• HNSW, IVF, IVF-PQ, and DiskANN• Multi-tenant memory isolation• Embedding versioning and document updates• Retrieval metrics like Recall@K, MRR, and NDCG• Production failure modes and caching strategiesOne thing I've noticed after taking interviews:Strong candidates don't just explain what a technology does.They explain why it was chosen, what trade-offs it introduces, and how it behaves in production.That's what separates someone who has watched tutorials from someone who can build AI systems.If you're preparing for AI Engineer, GenAI Engineer, or LLM Engineer interviews, save this carousel.If you want to clear AI interviews 99% confidently, this Interview Kit is for you.Learn in depth → Practice → Perform → Crack the jobEnroll here: https://lnkd.in/guPzFkTe♻️ Repost if this helped➕ Follow Naresh Edagotti for more real-world AI breakdowns

AI agents are the next leverage layer.But most people still don’t know where to start.Here’s a complete roadmap to go from “curious” to shipping real AI agents:✦ Chapter 1: Understanding AI Agents (the foundation).✦ Chapter 2: Popular AI agent frameworks you should actually know.✦ Chapter 3: Specialized frameworks + emerging protocols.✦ Chapter 4: Step-by-step: Build your first AI agent.✦ Chapter 5: Hosting & deployment (get it live).✦ Chapter 6: Security & compliance (don’t get burned).✦ Chapter 7: Advanced topics + future directions.✦ Chapter 8: Your Journey in AI Agent DevelopmentNo fluff. No hype.Just a structured path from zero → deployed agent.If you’re serious about building AI agents (not just consuming it), this is your starting point.Get FREE access here: https://lnkd.in/dMGZuZAj

I finally decided to pull the trigger and set up a little local Linux box to run my agents on. The reason why I did this is that my MacBook Pro was completely dying under the strain of agents.I got Asus NUC 15 Pro, Ultra 7 255H CPU, 96GB of RAM, 2TB SSD. The whole thing was about $3000, but you can do it way cheaper too. My boy math is that it a Mac Studio could be as much as $10,000, so I'm practically making money.Codex has great Remote support for this set up, much smoother than I thought - I can create new tasks from my Codex mac app or from my phone - all feels pretty similar to how local tasks work. Then I use Tailscale to move any files around too, delightful. I'll leave it next to my router hidden away, no extra clutter around the house.Set up took a couple of hours, it took a bit of back & forth, but agents are pretty good at holding your hand during the setup.Inspired by a Theo YouTube video about moving to Linux, really not as scary as I thought.Sticker art by a wonderful London based artist Natalia Shaloshvili.

🤷 Nico Martin 1w Liquid AI just released LFM2.5-2.6B, and it is wild what a model this compact can do. I built a research agent that runs entirely in the browser and puts its full think, plan, and act loop on display. Give it a question and it: - Creates an explicit action plan - Reasons about the next step - Chooses and calls tools - Inspects each result - Updates the plan and repeats It does not stop after one tool call. The agent keeps looping until every step in the plan is complete. Along the way, it can ask clarifying questions, use local context, delegate focused research to an isolated Wikipedia subagent, and collect sources. Once the plan is done, it turns the evidence into a cited response and downloadable research paper. The incredible part is the size: just 2.6B parameters. That makes LFM2.5 seriously fast on-device with WebGPU, while still being capable enough to plan, reason, use tools, and finish multi-step objectives. The model, agent loop, and inference pipeline all run locally. No inference server, no account, and prompts and outputs stay in the browser. Small models are not just autocomplete. They can be agents at the edge. Try the research agent in your browser: https://lnkd.in/dZwa9PAN Explore the code on GitHub: https://lnkd.in/d4aq-zEE More about the release: https://lnkd.in/dqXb5dvk

Master these LLM questions before your next interview 👇 40 questions, grouped the way a real LLM interview actually moves — definitions first, production last. Save this and work through one topic a day. 1) LLMs: Fundamentals & Comparison • What are Large Language Models (LLMs)? • How are LLMs different from traditional language models? • What are Foundation Models? 2) Tokenization & Embeddings • What is tokenization, and why is it important in LLMs? • What role do embeddings play in LLMs? • How do LLMs handle out-of-vocabulary (OOV) words? 3) Encoder–Decoder & Pretraining Objectives • What are Sequence-to-Sequence (Seq2Seq) models? • What is the difference between an encoder and a decoder? • How do autoregressive models differ from masked models? • What is Next Sentence Prediction (NSP)? 4) Transformer Architecture & Attention • How does the Transformer overcome the challenges of traditional Seq2Seq models? • What are positional encodings in LLMs? • What is attention in Transformer models? • What is Multi-Head Attention? • How are attention scores computed in Transformers? • What is the softmax function, and why is it used in attention? • How is the dot product used in self-attention? 5) Decoding & Sampling Strategies • What is beam search, and how does it differ from greedy decoding? • Explain the concept of temperature in LLM text generation. • What is the difference between top-k sampling and top-p sampling? • How does Adaptive Softmax speed up LLMs? 6) Loss Functions, Gradients & Backpropagation • What is cross-entropy loss, and why is it used in language models? • How are gradients computed with respect to embeddings? • What is the role of the Jacobian matrix in backpropagation? • What is the vanishing gradient problem, and how do Transformers solve it? • What are eigenvalues and eigenvectors, and how are they used in dimensionality reduction? • How is KL divergence used in evaluating LLMs? 7) Fine-Tuning & Parameter-Efficient Training • What are LoRA and QLoRA? • How can catastrophic forgetting be mitigated in LLMs? • How does Parameter-Efficient Fine-Tuning (PEFT) prevent catastrophic forgetting? • What is model distillation, and how is it applied to LLMs? 8) Overfitting & AI Model Types • What is overfitting, and how can it be prevented? • What are Generative and Discriminative models? • What is the difference between Discriminative AI and Generative AI? Want detailed answers to all 40? Every question is fully solved inside the 22 course AI Interview Master Bundle — 1200+ interview questions with answers, company-wise question sets, and beginner-friendly, scenario-first explanations - https://lnkd.in/g9GVkihi

I trained a VAD model from scratch in about a 20-hour A100 GPU run. But first question: what is VAD? Voice Activity Detection asks one simple thing: is anyone speaking right now?𝐖𝐡𝐚𝐭 𝐕𝐀𝐃 𝐃𝐨𝐞𝐬- VAD reads audio frame by frame.- Each frame is labeled as speech or non-speech.- Silence and noise should stay inactive.- Human speech should switch listening on.[This type of post takes a lot of effort to make, so I would appreciate it if you could repost this so that more people can learn about Audio AI fundamentals.]𝐖𝐡𝐲 𝐈𝐭 𝐌𝐚𝐭𝐭𝐞𝐫𝐬- Classic agents run VAD before ASR, the LLM, and TTS.- VAD gives boundaries: when to listen, stop, and ignore the room.- If VAD is wrong, the rest of the voice stack already feels broken.𝐌𝐨𝐝𝐞𝐫𝐧 𝐒𝐩𝐞𝐞𝐜𝐡-𝐓𝐨-𝐒𝐩𝐞𝐞𝐜𝐡- Newer systems are moving beyond strict turn-taking.- Full-duplex models listen while speaking.- That enables barge-in, interruptions, pauses, and natural timing.- The timing problem becomes turn detection, semantic VAD, and interruption control.𝐅𝐫𝐚𝐦𝐞𝐬 𝐀𝐧𝐝 𝐇𝐨𝐩 𝐒𝐞𝐪𝐮𝐞𝐧𝐜𝐞- The waveform is split into 25 ms frames.- The model advances with a 10 ms hop, so nearby frames overlap.- Speech is continuous, but models need fixed slices.- Overlap keeps context between frames.𝐒𝐜𝐨𝐫𝐞𝐬 𝐓𝐨 𝐃𝐞𝐜𝐢𝐬𝐢𝐨𝐧𝐬- Every 10 ms frame gets P(speech), a value between 0 and 1.- Above the start threshold, speech begins.- Below the end threshold for long enough, the segment closes.- Those rules turn probabilities into speech regions.𝐌𝐨𝐝𝐞𝐥 𝐀𝐫𝐜𝐡𝐢𝐭𝐞𝐜𝐭𝐮𝐫𝐞- I used a MarbleNet-style network from scratch.- It uses stacked 1D depthwise-separable convolution blocks.- Blocks use residual connections, batch norm, ReLU, and dropout.- A final 1x1 convolution maps features to speech/non-speech logits.𝐓𝐫𝐚𝐢𝐧𝐢𝐧𝐠 𝐒𝐞𝐭𝐮𝐩- Trained in roughly 20 GPU-hours.- The model has about 143k parameters.- The causal receptive field is around 1.7 seconds.- Training used LibriSpeech, MUSAN, and RIRS mixtures.- Checkpoint exported to ONNX.𝐓𝐞𝐬𝐭 𝐑𝐞𝐬𝐮𝐥𝐭𝐬- Clean speech was detected as speech.- Generated silence returned no speech segments.- Speech mixed with white noise still produced a usable region.[Just a quick reminder to repost this post]Paper Sourcehttps://lnkd.in/gMBcPP6mHere is the Github Codehttps://lnkd.in/gZygfWQ8Model weightshttps://lnkd.in/g9Kmrh2eI have also implemented a Speech to text transformer from scratch Here is a Detailed Visual Blog & Videohttps://lnkd.in/gs8bGSwWI Mayank Pratap Singh will be posting more Audio AI implementations and breaking down Audio and LLM inference concepts in future posts, so if you are interested in Audio deep learning and LLM inference optimization, follow me Mayank Pratap Singh for that.