AI Video Producer | Brand & Web Designer for Startups
AI Video Producer | Brand & Web Designer for Startups
I’m an AI & Machine Learning engineer with expertise in deve
- 1x
- Hired
- 6
- Followers
I’m an AI & Machine Learning engineer with expertise in deve
Neuro Lend
My credit model scored 0.92 AUC. Then I changed one field on one applicant, female to male, and she went from approved to rejected. A lot of lending AI works like this: it says no in milliseconds, and nobody, not the customer and often not the bank, can say why. So I built NeuroLend. You fill in a loan application and watch the signal travel through every neuron until the output turns green or red. Then it shows why it decided, and the smallest change that would flip the answer. Rohan is rejected at 54% risk. If he cuts his other EMIs to ₹5,500 a month, or asks for ₹7.5 lakh instead of ₹9 lakh, he's approved.
Here's what's happening underneath. It's a small 8 → 10 → 6 → 1 network trained on 40,000 synthetic Indian loan applications, where I deliberately gave gender zero effect on the outcome. The "why" uses Integrated Gradients against an average applicant instead of raw activations, because glowing neurons look great but explain nothing to a human. Counterfactuals come from a binary search on each input the applicant can actually change, and a fairness check re-scores every applicant with only gender flipped. That check caught the bias that accuracy missed. Retraining with gender cut out of the network dropped the effect to exactly zero, and AUC stayed at 0.92. It all runs in plain JavaScript in the browser, about 0.005 ms per decision, with no server. Code is in the comments. How does your team test lending models for bias today?
Medium - https://medium.com/@anuragnagare77/neuro-lend-99cddd19faad
GitHub - https://github.com/AnuragNagare/Neuro-Lend.git
0
40
One Gate: Voice-controlled Gmail, Calendar, and Drive that can't fire the wrong thing
Every "AI agent" demo shows a voice command turning into a sent email like magic, but almost nobody shows the part that actually matters: what stops it from sending the wrong thing. I built proof: an agent that runs your Gmail, Calendar, Contacts, and Drive by voice reply to a thread, schedule a meeting, archive an email, find a file hands-free end to end, but never fires anything irreversible without you saying so. The honest hard part isn't getting an LLM to sound smart, it's this: a transcript goes to LLM against a strict JSON schema and comes back as an ordered plan, every step tagged reversible or not and exactly one thing in the whole system is allowed to check that flag. Finding a thread, drafting a reply, creating a calendar event: those just run.
The result covers real ground without ever feeling like it's guessing: forward or reply to email with the original quoted underneath, archive/label/trash, resolve a name to a real address through your Contacts first and your mail history as fallback, schedule an event that creates quietly and only emails the invite after a second confirmation, answer "what did John say" or "what's on my calendar Thursday" grounded in content actually fetched from your account not hallucinated. No backend, no server anywhere in the loop
0
90
Everyone's building AR filters and calling it "computer vision magic." Almost nobody's asking what's actually happening underneath — that most of these effects are just clever masking, not detection.
Here's proof. I built an invisibility cloak that runs entirely in the browser, no green screen, no chroma key, no model training.
https://github.com/AnuragNagare/Ghost-frame
4
2
326
What your attention heatmap isn't telling you
Everyone's staring at attention heatmaps and calling it "interpretability." Almost nobody's asking whether a single attention map actually tells you what the model used to make its decision.
It doesn't. Not on its own.
A raw attention map from layer 8 shows you what layer 8 attended to. It says nothing about how that signal got mixed, diluted, or overwritten by every layer before and after it. Attention rollout fixes this — and I built a walkthrough to show why it matters.
Here's what makes it more than a "pretty heatmap" demo:
Instead of visualizing one layer's attention, I traced how information actually flows through the full transformer stack.
→ Every layer's attention matrix is extracted, per head, per token
→ Multi-head attention is averaged, then combined with the residual connection (identity + attention) — this is the step most tutorials skip, and it's the one that actually matters
→ The combined matrices are matrix-multiplied layer by layer, rolling attention forward from input to output
→ The result: a single map showing genuine token-to-token influence across the entire network, not just one layer's snapshot
The overlay shows you everything:
→ Per-layer attention vs. rolled-out attention, side by side
→ Token importance scores overlaid directly on the input text
→ A comparison view: which tokens raw attention says "matter" vs. which ones rollout says actually matter
→ Head-level breakdown so you can see which heads specialize vs. which are noise
No black box. No "trust me, the model looked here." Just linear algebra, applied honestly across every layer instead of cherry-picking one.
Built with PyTorch + HuggingFace Transformers + Matplotlib. Runs on any pretrained transformer, fully offline.
⚠️ Important: attention rollout is an approximation, not ground truth. It assumes attention is the primary information pathway, which ignores MLP layers and can still mislead for very deep models. Treat it as a debugging lens, not proof of causality.
0
197
AI developer & backend engineer 💻
View more →
Websites, AI assistants and automations, built by engineers
AI Agent Developer | AI Integration for B2B SaaS
Flutter & full-stack dev shipping AI-powered apps.
AI Engineer with roots in 3D and a focus on security.
New to Contra
AI Engineer with roots in 3D and a focus on security.
Voice Cloning Lite: Lightweight Text-to-Speech Web App
Built a lightweight, zero-cost text-to-speech application that converts text into downloadable audio across 60+ languages. Designed as a practical, free alternative to premium voice synthesis APIs—prioritizing accessibility and zero cloud costs over premium voice realism.
Engineering Decisions & Trade-offs:
Free-Tier Architecture: Integrated Google Text-to-Speech (gTTS) to eliminate API costs and ensure the app remains permanently free to use. This comes with a trade-off: voice output is functional and clear, but slightly robotic compared to premium paid alternatives (e.g., ElevenLabs, Coqui XTTS).
Multi-Language Support: Enabled text-to-speech across 60+ languages with adjustable speed control.
Audio Export: Implemented MP3 generation and download functionality, allowing users to save synthesized audio directly from the browser.
Production Deployment: Deployed on Streamlit Cloud with graceful error handling for text length limits and network issues.
Tech Stack: Python, Streamlit, gTTS, HTML/CSS.
0
35
AI Assistant: Agentic Web Search & Math Solver
Built an intelligent AI agent that autonomously decides which tool to use—web search or a calculator—based on the user's query. Unlike a standard chatbot, this system uses agentic reasoning to route questions to the appropriate backend.
Engineering Challenges Solved:
Agentic Decision-Making: Implemented LangChain to give the LLM the ability to reason about user intent and select between a real-time web search tool (Tavily) and a secure mathematical expression evaluator.
Real-Time Information Retrieval: Integrated the Tavily Search API to fetch live, up-to-date answers for questions about current events and general knowledge.
Secure Math Evaluation: Built a sandboxed expression parser to safely evaluate mathematical queries without risking code injection, supporting complex calculations.
Tool-Calling Architecture: Designed a modular pipeline that allows the agent to chain multiple tools together when needed for complex queries.
Tech Stack: Python, LangChain, Groq API (Llama 3.1), Tavily Search API, Streamlit.
0
78
AI Art Generator (Full-Stack Next.js Application)
Built and deployed a production-ready web application that generates images from text prompts using distributed GPU networks and multiple AI models.
Engineering Challenges Solved:
Distributed AI Networks: Integrated the AI Horde API to offload generation to a global volunteer GPU network, eliminating cloud GPU hosting costs while maintaining high availability.
Multi-Provider Architecture: Designed a modular provider system supporting Stable Diffusion 1.5, SDXL, and Flux models, allowing users to switch between models seamlessly.
Async Job Handling: Implemented robust asynchronous polling to handle queued jobs, status updates, and graceful degradation during peak network load.
Production Deployment: Built with Next.js 14 (App Router) and TypeScript, deployed on Vercel with CI/CD pipelines.
Tech Stack: Next.js 14, TypeScript, Tailwind CSS, AI Horde API, Replicate API.
0
65
Data & AI Governance Consultant | Responsible AI | Power BI
