Hi, I'm Abhinav Gupta

Pipeline Architecture

Technical Excellence

• Condition Assessment: Capable of independent diagnosis for both eyes (e.g., detecting Right Eye: Cataract while Left Eye: Normal).
• Optimization: Achieved 93% ROC-AUC and 85% F1-score on validation/test sets using hyperparameter tuning with Optuna.
• Active Learning Feedback: Implemented a backpropagation loop where MLP misclassifications trigger embedding refinement in BioMedCLIP to maximize class separability.
• Production Ready: Response time under 0.2 seconds, ensuring real-time diagnostic capability.

Tech Stack

What it does

• Processes 1.2 lakh IPD claims per month (4,200/day) in approximately 5 hours — a workload that previously required 68 manual staff working 10 hours/day.
• Brought processing cost down to ~₹2.2L/month for 1.2L claims, saving ₹14 lakh/month compared to the manual process.
• Fully configurable — supports any dialysis or cataract claim type without code changes; rules are toggled per document class at runtime.
• The pipeline processed and helped adjudicate ₹144 crores worth of claims end-to-end (total claims value handled, not savings).

Technical Breakdown

• Document Classifier: Sentence-transformer model (all-MiniLM-L6-v2) supporting 14+ medical document classes with multi-label capability — 94% TP, 83% FN. Can classify two documents on the same page independently.
• Computer Vision Models: Custom MobileNetV2-based human detection (97%+ TP) and cataract eye detection (97%+ TP) models, both improved from a 79% baseline during the project.
• Adjudication Engine: Dynamic rule-based engine with 62+ configurable rules. Rules are assigned per document type, giving precise per-class adjudication control. Achieves 93% TP accuracy end-to-end.

Stack

Impact & Scale

• Processes 42,000 handwritten prescriptions per day (12.3 lakh/month) across 5 claim task types, running 18 hours continuously in production.
• Replaces a costlier LLM solution — saves ₹3 lakh/month with an accepted trade-off of ~6% accuracy drop, a deliberate engineering decision based on cost-benefit analysis.
• Inference time reduced from 52 seconds → 1.2 seconds per claim — a 43× speedup — through quantization and inference engine optimisation.

Model Selection Rationale

• Benchmarked MedGemma 27B, Qwen 2.5 32B, and InternVL 3.5 38B. Selected InternVL for its superior vision encoder — Shanghai AI Lab's custom architecture on top of Qwen 2.5 32B — which consistently outperformed the others on degraded, handwritten medical text.
• Ran a 1-month stealth-mode trial processing 12 lakh real claims in parallel before switching the production pipeline over.
• Applied destructive testing to probe for hallucinations under edge-case inputs; validated 18-hour sustained runtime stability before full deployment.

Optimisation Techniques

• PEFT with LoRA / QLoRA for parameter-efficient fine-tuning; 4-bit quantization to fit a 38B model on available GPU memory.
• LM Deploy for optimised inference; batch processing, token-length management, deadlock prevention, and OOM safeguards for 18-hour continuous operation.

Stack

Overview

Teams upload a folder of labelled documents — the folder name becomes the class label. The platform automatically trains all three approaches, benchmarks them against the dataset, and recommends the optimal model. Weights are exported in standard formats (ONNX, TorchScript, etc.) ready for deployment. No training or testing scripts needed.

Three Approaches (auto-benchmarked)

Stack

How it works

• Upload a JSONL or Excel file containing prescription images and expected outputs → select models to run → receive a structured side-by-side comparison report.
• Supports GPT-4o (direct API or Azure), Gemini 2.5+ (Vertex AI or direct), and Qwen 2.5 32B/72B (via OpenRouter) — with flexible credential inputs for each provider.
• Extracts patient information, prescribed medicines, and diagnosis; validates extracted medicines against the Tata 1mg database for accuracy.
• Outputs per-prescription and per-medicine accuracy scores, field coverage rates, and token/API cost breakdown per model.

Stack

What was added

• Call-level tracing across both pipelines — every request, model call, and processing step is captured with full context for debugging and auditing.
• Per-stage cost attribution, giving the team visibility into which steps consume the most API budget and where to optimise.
• Latency, throughput, and error rate dashboards monitored in production on an ongoing basis.

Stack