Forem: praveena 0506

𝗠𝗶𝘀𝘀𝗶𝗼𝗻 𝗛𝗼𝗻𝗲𝘆𝗽𝗼𝘁: 𝗛𝗼𝘄 𝗜 𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗲𝗱 𝗮𝗻 𝗔𝘂𝘁𝗼𝗻𝗼𝗺𝗼𝘂𝘀 𝗔𝗜 𝘁𝗼 𝗦𝗰𝗮𝗺 𝘁𝗵𝗲 𝗦𝗰𝗮𝗺𝗺𝗲𝗿𝘀

praveena 0506 — Tue, 03 Mar 2026 06:48:55 +0000

I Over-Engineered an AI to Gaslight Financial Scammers at 80ms Latency 🍯👴
Scammer: "URGENT: Your SBI account is blocked. Send OTP."
Me, an intellectual: spins up an asynchronous, multi-agent AI pipeline to systematically destroy their patience.

We all get those spam texts. Most normal, well-adjusted humans just block the number and move on with their lives. But as a developer, I saw a problem: Ignoring scammers doesn't waste their time. So, rather than doing something useful with my weekend like fixing my broken Docker containers, I built an Autonomous Counter-Scamming Agent.

Welcome to Project Grandpa.

The Architecture of Petty Vengeance
The goal wasn't just to talk to them. A basic while True loop with a randomized response could do that. I wanted to build a system that baits them, maintains a consistent, infuriating persona, and silently harvests their threat data in the background.

Here is the tech stack I used to make a scammer question their life choices:

1. The Brain: DSPy & Llama-3 🧠
I could have used a basic OpenAI wrapper, but why write an if statement when you can use a declarative programming framework to mathematically optimize a confused 72-year-old man?

I used DSPy to define a rigorous Cognitive Engine. The persona? Ramachandran. He’s 72, he doesn't know what a "UPI" is, his caps-lock is occasionally stuck, and he is very eager to give you his bank details if he could just figure out how to unlock his phone.

I ran this on Groq’s LPUs (Llama-3). Because when a scammer asks for my OTP, the AI needs to generate five paragraphs of pure, unfiltered technological confusion in under 80 milliseconds.

2. The Extraction Trap: Regex & Background Tasks 🕸️
While the LLM is distracting them with questions about "where the 'any' key is," the real work happens in the background.

Every incoming message is parsed through deterministic Regex patterns. The moment the frustrated scammer drops a "secure" UPI ID (like scammer.fraud@fakebank) or a phone number to "call for help," the system silently intercepts it.

It then triggers a background FastAPI task to POST their structured threat data straight to a callback URL for the authorities. They think they are extracting my bank details, while I am literally JSON-serializing their identity.

3. The Backbone: FastAPI & Render ⚡
Built on an async FastAPI event-loop, because wasting scammers' time should be highly concurrent and non-blocking.

But here’s the best part: Cloud APIs rate-limit you. Groq occasionally throws a 429 Too Many Requests. Instead of letting the server crash, I built a custom zero-retry fallback. If the LLM chokes, the API instantly catches the exception and returns:

"Oh dear, my internet seems slow. Can you say that again?"

It takes <0.08 seconds to execute, and it is a canonically perfect boomer response. It’s not a bug; it’s a feature.

Is AI going to take our jobs? Maybe. But today, it’s taking the jobs of scam victims.

If you want to spin up your own honeypot, check out the source code below. Feel free to fork it, add your own personas, and deploy it. Ruining a scammer's day should be open-source.

👾 Source Code:

Have you ever built something incredibly complex for an incredibly petty reason? Let me know in the comments. 👇

The Zombie AI: How I Built a Model That Refuses to Die (and Why I Fired BERT)

praveena 0506 — Sun, 18 Jan 2026 14:49:17 +0000

A story of failure, Cloudflare blocks, and why I chose a "dumb" model over a Transformer to save money.

🥔 The Problem: AI Models age like Milk
Let’s be honest. Most of our ML projects are liars. We train them on a CSV from 2023, show off the 98% accuracy on LinkedIn, and then... abandon them. The moment you deploy that model, it starts rotting. The world changes. The Supreme Court passes new judgements. But your model is still living in the past, blissfully ignorant.

I refused to build another "Potato Model" (one that sits there and rots). I wanted to build Legal Eagle AI—a system that wakes up, drinks coffee, reads the news, and gets smarter every day without me nagging it.

🤦‍♂️ Phase 1: The "I am a Genius" Phase (And the inevitable crash)
My Grand Plan:

Write a script to scrape Indian Kanoon (Government legal archives).

Train a massive Transformer.

Change the world.

The Reality: I wrote the scraper. I hit "Run". And Cloudflare immediately punched me in the face. 🥊 403 Forbidden. Access Denied. Are you a robot?

I tried header spoofing. I tried rotating user agents. Cloudflare looked at my cute little Python script and laughed. I had a fancy architecture but literally zero data.

💡 Phase 2: The "Lazy Engineer" Pivot
They say "Laziness is the mother of invention." Instead of fighting the firewall, I went around it.

I realized Google News RSS Feeds are:

XML (Deliciously easy to parse).

Real-time.

Unblockable. (Google wants you to read the news).

But wait! RSS feeds don't come with labels like "Win" or "Loss." I didn't have a budget to hire interns to label data. So, I built the "Vacuum Cleaner." 🧹

I wrote a "dumb" Heuristic Engine that scans headlines for words like "Acquitted" or "Allowed" and stamps them as WIN. If it sees "Dismissed", it stamps LOSS. Boom. Infinite, free, labeled training data. Take that, Cloudflare.

🧠 Phase 3: Why I Fired BERT (The Controversy)
Warning: This section might offend NLP purists.

Everyone asked me: "Why didn't you use a Transformer? BERT is SOTA! Do you even Attention Mechanism bro?"

Look, I know how Transformers work. I actually built one from scratch (seriously, I hand-coded the Multi-Head Attention math—you can check the pain and suffering in my Deep Dive Repo here
).

But here is the thing about Transformers:

They are Divas. 💅

They demand GPUs.

They eat RAM like Chrome tabs.

They are s-l-o-w.

I am a student running on free cloud tiers. I cannot afford a Diva. I need a Toyota Corolla. So, I used a PyTorch EmbeddingBag network.

The difference?

BERT: Reads the text, contemplates the existential meaning of the word "the," checks the context of the previous 500 tokens... [Latency: 400ms].

My Model: Averages the vectors. Smashes them into a Linear Layer. Done. [Latency: 12ms].

It is 10x faster, runs on a standard CPU, and costs $0. And guess what? It’s 95% accurate. Efficiency > Hype.

☁️ Phase 4: The Immortal Architecture (MongoDB + Airflow)
A Zombie AI needs a brain that doesn't get wiped when the server restarts. If I stored my data in a .csv on Heroku, it would vanish every 24 hours. (RIP).

So I brought in the heavy hitters:

MongoDB Atlas (The Brain Bucket):

Why? Because legal text is messy. SQL tables scream if you miss a column. MongoDB just takes the JSON and says "Thank you."

Now, even if my code crashes, the Knowledge Base survives in the cloud.

The "Groundhog Day" Loop:

I designed the system to mimic an Apache Airflow DAG.

6:00 AM: Wake up.

6:05 AM: Scrape Google.

6:10 AM: Auto-Label.

6:15 AM: Retrain the Model.

If the Supreme Court changes a law today, my model learns it by dinner time.

🐳 The "Works on My Machine" Vaccine
To ensure this delicate house of cards doesn't collapse when I move it from my laptop to the cloud, I wrapped the whole thing in Docker. And I used Poetry because requirements.txt is stuck in 2015 and I like my dependencies deterministic, thank you very much.

📈 The Verdict
Initial Loss: 1.08 (My model was basically flipping a coin).

Final Loss: 0.26 (After 5 epochs of auto-scraped data).

I built a system that feeds itself, teaches itself, and runs for free. Sometimes, the "dumb" solution is actually the smartest one.

🔗 Code & Proof
The Immortal Project: Legal Eagle AI Repo

Discussion: Have you ever ditched a "State of the Art" model because it was just too expensive/slow for production? Let me know in the comments! 👇

Rebuilding Modern AI for... Fun? A Transformer Story.

praveena 0506 — Thu, 13 Nov 2025 05:40:20 +0000

Sure, You Can import transformers. Or You Could Just Rebuild Modern AI From Scratch, I Guess.

We've all done it. pip install transformers, from transformers import AutoModel, and... you're a modern AI developer. It's magic.

But what's really happening under the hood? What's going on in that "Attention Is All You Need" paper that everyone cites but maybe... didn't fully read?

I decided to find out. I went on a quest to rebuild the Transformer Encoder from scratch in PyTorch. No nn.Transformer allowed.

My goal: To build a model that could perform Text Classification (specifically, sentiment analysis) on the IMDB movie review dataset. And, just maybe, to finally understand what q, k, and v really mean.

Spoiler: it worked. And it was a journey. Here's how I did it.

Why Suffer? (The Real Goal)
Okay, sarcasm aside, why do this?

Because "using" an API and "understanding" an architecture are two different things. This project is about moving from being an "API user" to an "architect." I wanted to know why the design works, and that meant building the "Lego bricks" myself.

The architecture I built is an Encoder-Only model, the same conceptual design used by classic models like BERT for text understanding.

The Blueprint: Rebuilding the Core Components
I built the entire model as a set of PyTorch nn.Module classes. You can't just build one big class; you have to build the pieces first.

Problem: The Model is "Order-Blind" The MultiHeadAttention mechanism sees all words at once, like pulling them from a bag. It has no idea "man bites dog" is different from "dog bites man."

The Fix: PositionalEncoding.

How it Works: I had to build a class that creates a unique "position vector" for every word in the sequence using the famous sin and cos formulas from the paper. This isn't a learned vector; it's a fixed mathematical "fingerprint" for each position.

The Magic: You just add this position vector to the word's "meaning vector" (its embedding). The final vector the model sees is Vector("man") + Vector(position=0).

he Core: Multi-Head Attention (The "Head Chef")
This is the heart of the Transformer. It's not one giant "spotlight" of attention; it's 4 (or 8, or 12) smaller, "specialist" spotlights working in parallel.

I built this class to be a "Head Chef" that manages the whole process:

It hires 4 trainable "specialist" layers (w_q, w_k, w_v) to learn how to project the input vectors into Query, Key, and Value "subspaces."
It splits the main 256-dimension vector into 4 smaller "heads" (of 64-dimensions each).
It delegates the real math to a simple scaled_dot_product_attention function.
This is where the $softmax(\frac{QK^T}{\sqrt{d_k}})V$ formula lives.
It calculates the scores, masks out padding, and creates the new "blended" vector.It stitches the 4 "specialist" reports back together and passes them through one final trainable w_o layer.

With my EncoderLayer "Lego block" built, the rest was easy. I stacked 3 of them together, added an Embedding layer at the start, and a simple nn.Linear classifier head at the end.

And... it actually worked.

I trained it on 5,000 movie reviews from the IMDB dataset. After just 3 epochs, my Transformer—built from nothing but raw PyTorch and the paper—achieved 75% accuracy on the test set.

It learned!
you can find the code at [(https://github.com/praveena0506/Transformer-from-scratch)
]

Not All Returns Are Regrets – Some Just Need a Little AI Magic

praveena 0506 — Mon, 10 Mar 2025 16:52:16 +0000

Ever wondered what happens when you return a product? No, it doesn’t magically teleport back to the warehouse and get a second life (if only life worked like that!). Instead, it enters the chaotic world of Reverse Logistics, where companies must decide whether to recycle, repair, or resell the item.

Now, let’s be honest—humans already struggle with tough decisions (Do I really need another coffee?), so why not let AI handle return management too? That’s exactly what my project does! By leveraging AI, automation, and optimization algorithms, I have built a system that makes reverse logistics faster, smarter, and fraud-resistant.

🤖 CNNs: The AI That Judges Your Broken Stuff
One of the biggest challenges in reverse logistics is deciding what to do with a returned product. Manual classification is not only time-consuming but also prone to errors. This is where Convolutional Neural Networks (CNNs) come in.

🔍 How It Works:
My CNN model takes an image of the returned product and classifies it into one of three categories:

🔹 Repair – "I can fix this!" (Minor damages, repairable components)
🔹 Recycle – "No hope, buddy. Off you go to the scrap yard!" (Severe damage, unusable parts)
🔹 Resell – "Good as new! Let’s send it back to the shelves!" (Perfect condition, minimal/no damage)
this model work by classifying image based on damage level threshold value comparing with original image by product id as keyword

🎯 Why This Matters:
✅ Automates decision-making, reducing the need for manual inspections.
✅ Speeds up processing, ensuring quicker turnaround times.
✅ Minimizes waste, promoting a more sustainable supply chain.

Instead of humans spending hours inspecting returns, this AI-driven approach helps businesses streamline the return process, saving both time and money.

🔄 _If-Else Simulations: Because Returns Aren’t Always Straightforward
_
Not every return is simple. Some products are physically intact but electronically faulty, while others are damaged beyond repair. Instead of applying a one-size-fits-all rule, I implemented If-Else Simulations that dynamically adjust workflows based on different conditions.

🛠️ Key Factors Considered:
✅ Is the product physically damaged beyond repair? – If yes, route to recycling.
✅ Is the return window still valid? – If expired, return request is denied.
✅ Does the warehouse have spare parts? – If yes, route to repair instead of recycling.
✅ Is the item under warranty? – If yes, the return process follows a priority repair queue.

🔥 Benefits of This Simulation Approach:
🔹 Dynamic workflow automation – No fixed rules, everything is adaptive!
🔹 Real-time decision-making – Reduces manual intervention and speeds up processing.
🔹 Optimized logistics – Ensures returns are handled in the most cost-effective way.

By simulating different return scenarios, the system ensures that every product follows the most efficient path, reducing operational bottlenecks.

📦_ Barcode Verification: Because Fraud Exists!_
Let’s face it—not all returns are genuine. Some customers (we see you! 👀) try to return fake, swapped, or damaged products in hopes of getting a refund or replacement.

To combat return fraud, my system incorporates barcode verification, ensuring that only genuine returns make it through the process.

🔍** How Barcode Verification Works:**
✅ Scans the product barcode & matches it to the purchase database.
✅ Verifies if the returned item’s serial number matches the original purchase.
✅ Flags suspicious returns (wrong SKU, mismatched product details).
✅ Prevents unauthorized returns, reducing fraud-related losses.

💡 Why This Is a Game-Changer:
🔹 Reduces fraudulent returns, saving businesses millions in fake refunds.
🔹 Eliminates manual cross-checking, making return processing much faster.
🔹 Ensures customer trust, preventing abuse of return policies.

With barcode verification, businesses can instantly detect fraud attempts and take necessary action, preventing revenue loss.

🚚 Route Optimization: The Fastest Way to Return a Return
Once a return is classified (Repair, Recycle, Resell), the next big question is:
📍 Where should it go?

Transporting returns inefficiently can lead to higher costs, delays, and environmental impact. To solve this, I implemented Dijkstra’s Algorithm, which optimizes return routes based on:

✅ Shortest distance to repair centers, recycling hubs, or warehouses.
✅ Minimizing fuel consumption and transportation costs.
✅ Reducing carbon footprint by optimizing delivery schedules.

🚀 Why Route Optimization is Crucial:
🔹 Faster processing – Returns don’t sit idle, reducing wait times.
🔹 Lower costs – Smart routing minimizes unnecessary trips.
🔹 Eco-friendly – Fewer miles = reduced CO₂ emissions.

By leveraging route optimization, businesses can handle returns efficiently, cut costs, and reduce environmental impact at the same time!

📊 Power BI + SQL = Smarter Return Management
Reverse logistics isn’t just about moving products—it’s about understanding why returns happen and how to reduce them.

To provide insights into return patterns, I used Power BI and SQL to analyze:

📈_ Most common return reasons – Is it product defects, shipping damage, or customer misuse?_
🛠️ Repair vs. Scrap trends – How many returns are being successfully repaired vs. recycled?
🌍 Environmental impact – Tracking sustainability efforts, carbon footprint reductions.

With these insights, businesses can:
✅ Improve product design – Reducing common defects that lead to returns.
✅ Enhance logistics workflows – Optimizing inventory and return centers.
✅ Make data-driven decisions – Identifying opportunities to minimize return rates.

By combining AI-powered classification, barcode verification, and logistics optimization, my system revolutionizes how businesses handle reverse logistics.

✨** Why Does This Matter?**
Companies lose billions each year due to inefficient return processes. My approach solves this by making reverse logistics:

💰 Cost-effective – Automates return classification, reducing manual labor.
🌍 Sustainable – Ensures products are reused or recycled rather than wasted.
⚡ Efficient – Speeds up decision-making with AI-driven automation.

By leveraging AI, automation, and smart logistics, businesses can turn returns from a costly burden into an opportunity for efficiency and sustainability.

NLP-Poetry for the Digitally Challenged..

praveena 0506 — Mon, 20 Jan 2025 05:25:37 +0000

EVER WAnted to write a poem that resonates or read one and think, “This is beautiful, but what does it even mean?” Well, I decided to take that poetic confusion and turn it into an opportunity with some NLP magic and creativity. My project combines the power of poem simplification, poem generation, and figure-of-speech analysis to make poetry approachable for everyone—whether you’re a literature fan or someone who finds poetry intimidating.

Here’s what my project offers:
Simplify Complex Poems:

It scans for archaic words and replaces them with modern equivalents, making the language clearer.
Every word is cross-checked against a CSV file of frequently used English words to gauge complexity.
Words that feel overly complex? They get replaced with simpler synonyms, all while maintaining the poem’s structure and rhythm.

Generate Your Own Poem
Want to write a poem but need a little help? Just give a topic—whether it’s love, coffee, or cosmic mysteries—and let the API generate a unique poem for you.
It’s dynamic, so every topic results in a fresh, creative piece of poetry.

*Analyze Poetic Devices:
*
Curious about what makes a poem stand out? The project detects figures of speech like metaphors, similes, alliterations, and more, giving you a detailed breakdown of the artistic tools used in any poem.
Whether it’s to sound smart or genuinely understand the beauty of a piece, this feature is your best friend.
Why It Matters:
This tool bridges the gap between traditional poetic beauty and modern accessibility. It allows anyone to appreciate, create, and learn from poetry without needing a degree in literature. Whether you’re simplifying a classic, crafting your masterpiece, or analyzing hidden meanings, this project does it all.

With this project, I’m not just coding—I’m making poetry fun, relatable, and understandable for everyone. Dive into the code and let’s make poetry a little less intimidating and a lot more enjoyable—one verse at a time!

Let me know if you want further tweaks!