Projects

Journal analysis tools treat each entry in isolation, losing insight from patterns over time. Cloud LLM APIs also differ in availability and cost, requiring flexible provider routing.

Built a FastAPI backend with a RAG pipeline (sentence-transformers all-MiniLM-L6-v2, FAISS cosine search, prompt augmentation), multi-provider LLM routing, a BYOK token vault, and a ReAct-style agentic layer built from Groq API primitives (no LangChain) with 5 tools and observable planning traces. Evaluated retrieval with a golden test set and agent accuracy with a 10-case benchmark.

RAG retrieval: 0.80 precision@3, 1.0 MRR. Agent eval: 90% pass rate, 0.92 tool recall, 0.77 precision, 4.8s avg latency. Working multi-provider gateway with live demo, provider diagnostics, and reproducible eval harness.

Public ADS-B feeds expose raw aircraft positions but not interpretable signals about unusual behavior. An analyst can see thousands of points on a map, but not which aircraft deserve attention or why.

Built a FastAPI backend that ingests commercial and military telemetry, maintains in-memory aircraft state, and runs a sequential enrichment pipeline: Kalman filtering for state estimation, DBSCAN for pattern detection, and IsolationForest for anomaly scoring. The backend pushes GeoJSON to a Next.js + MapLibre frontend and exposes natural-language query, region summary, and anomaly explanation endpoints backed by Claude.

Built and deployed a full ML inference pipeline processing 11,000+ live aircraft per 60-second cycle, with Kalman state estimation, DBSCAN spatial pattern detection, and IsolationForest anomaly scoring. Captured 4 real Claude anomaly explanations from live flight data, including a US military helicopter (GRZLY71) executing a racetrack surveillance orbit. Implemented Fleet Analytics, on-demand feature vector display, and a collapsible Pattern Drill-Down. Fixed a state persistence bug that was silently discarding anomaly scores between non-scoring cycles. System runs continuously on Fly.io with CI/CD via GitHub Actions. Full technical write-up in CASE_STUDY.md.

Learners often have useful content but limited time to read. They need a way to transform raw notes and documents into listenable study material.

Built a modular backend pipeline (prompt/file ingestion → LLM summarization → TTS audio output) with a React frontend shell. Prioritized backend API completeness and evidence-linked documentation before frontend polish.

Backend API fully operational with health checks, lecture generation, and audio output endpoints. Frontend auth and layout deployed but end-to-end user flow still in progress.

Skill bartering platforms rely on keyword search and manual browsing, which misses relevant matches across categories (e.g., a React developer seeking woodworking and a carpenter wanting to learn coding).

Built a three-tier architecture: Next.js 14 frontend on Vercel, Supabase (PostgreSQL + pgvector + RLS) for data/auth, and a FastAPI AI backend on Railway running sentence-transformers (all-MiniLM-L6-v2). Skills are embedded on creation and matched via cosine similarity with cross-category explanations.

Deployed end-to-end with 23 routes, 10 skill categories, real-time messaging, trade proposals, ratings, and AI-powered match recommendations. Demonstrates full-stack ownership from auth flows to embedding-based matching.

Embedding generation for SkillSwap's semantic skill-matching needed cheaper, faster inference on CPU without sacrificing match quality or requiring GPU hardware.

Exported the production sentence-transformer to ONNX via Hugging Face Optimum, applied INT8 dynamic quantization (88 MB → 23 MB, ~74% reduction), and swept batch sizes 1–64. Benchmarked p50/p95/p99 latency and throughput across PyTorch baseline, ONNX Runtime, and quantized ONNX configurations. Validated accuracy with cosine similarity against the PyTorch baseline.

ONNX + INT8 batch=32 achieved 2.9ms p50 latency and 602 req/s — a ~9× throughput improvement over PyTorch single inference. Model size reduced ~74%. Quantized embeddings maintained 0.962 mean cosine similarity vs. baseline. 17 passing tests with GitHub Actions CI.

Standard VAEs balance reconstruction fidelity against latent space regularity via a single β hyperparameter, but the impact is hard to reason about without hands-on experimentation.

Built encoder/decoder with configurable latent dimensions, trained across 6 β values, and measured reconstruction loss, KL divergence, and sample quality. Exported latent space interpolations and reconstructions as evidence.

Clear demonstration of how β controls the reconstruction–disentanglement tradeoff. Low β (0.1) gives sharp reconstructions but tangled latents; high β (10) gives smooth latent space but blurry outputs. 19/19 tests passing.

Full fine-tuning of LLMs is expensive. LoRA reduces trainable parameters by 95%+, but how does rank affect quality? Practitioners need empirical guidance for choosing configurations.

Applied LoRA to GPT-2 attention layers across 5 rank/alpha configurations on SAMSum (500 train examples). Evaluated each with ROUGE-1/2/L and BERTScore. Visualized training curves, ablation heatmaps, and before/after comparisons.

Rank 8 with alpha 16-32 captures most fine-tuning benefit at 0.65% of model parameters. Even rank-2 (202K params) substantially beats zero-shot. Methodology is model-size-agnostic and applies directly to Llama, Mistral, and other transformers.

Understanding RL requires building environments and agents from scratch — not just calling library APIs. How do tabular and deep RL methods compare on the same task?

Implemented WindyGridWorld (Gymnasium API), tabular ε-greedy Q-learning, and a DQN with experience replay and target network. Systematic comparison of convergence, sample efficiency, and solution quality.

Tabular Q-learning converges fast on small state spaces; DQN generalizes but needs replay buffer tuning. Full environment/agent separation following Gymnasium patterns. 24/24 tests passing.

Most practitioners use optimizer libraries without understanding the math. How do BGD, momentum, and Adam actually differ in convergence behavior across different curvature regimes?

Implemented all three optimizers and a feedforward neural network with full backpropagation in pure NumPy. Benchmarked on Rosenbrock, ill-conditioned quadratics (κ=2–500), and MNIST classification. Visualized 3D loss landscapes and gradient norms.

Adam achieves ~93% MNIST accuracy vs SGD ~85%. Condition number study shows Adam effectively reduces effective κ. He initialization critical for ReLU networks. 29/29 tests passing, zero external ML dependencies.