Projects
Featured
skill.installer
Created a no-account web tool that resolves a public AI-agent skill link, previews its files, and packages the complete version-pinned skill folder as a ZIP download.
Decision Playground
Built an interactive playground for Baseten System One decision models, with typed questions, probability and threshold views, and inspectable requests and responses.
Other projects
KPI Dashboard & ELT Pipeline
Engineered an end-to-end ELT pipeline that ingests 51K+ sales records from JSON, loads into SQLite, computes KPIs via SQL, and renders a real-time Flask web dashboard fully automated.
📌 Business Problem
The sales team relied on manual spreadsheet analysis to track KPIs, leading to delayed reporting, inconsistent metrics, and no single source of truth. Leadership needed a self-refreshing dashboard for real-time performance visibility.
📂 Data
- Source: StoreSales.json 51,291 sales records
- Features: 24 columns covering order details, customer data, location, product info, and financial metrics
- Database: SQLite with single normalised sales table (13.3 MB)
🔬 Methodology
Extract: Ingest JSON via Pandas → Load: Write to SQLite with schema auto-creation → Transform: SQL aggregate queries to compute 5 KPIs (Total Sales, Total Profit, Quantity Sold, Avg. Discount, Profit Margin) + category breakdowns and Top-10 products → Serve: Flask web app with HTML dashboard.
💡 Key Insights
- $12.6M total sales with $1.47M profit across 178K units
- Average discount of 14.29% across all transactions
- Technology category leads revenue; Office Supplies leads volume
- Identified Top-10 products contributing disproportionately to profit
📈 Business Impact
- Dashboard replaced ~8 hours/week of manual Excel reporting
- Provided leadership with real-time KPI visibility for quarterly planning
- Automated ELT pipeline ensures consistent, reproducible metrics
- Scalable architecture supports additional data sources and KPIs
AI-Powered Reporting Automation
Built an end-to-end business intelligence pipeline that takes raw weekly sales CSV data, detects anomalies via dual statistical methods, generates AI-powered narrative briefs explaining each anomaly, and delivers a self-contained interactive HTML dashboard — all in under 5 seconds.
📌 Business Problem
Traditional business reporting is slow and manual — an analyst pulls data, builds charts, writes commentary, and formats a deck. By the time it reaches decision-makers, the data is already stale. This pipeline automates the entire reporting workflow from raw CSV to executive brief in one command.
📂 Data
- Source: 104 weeks of synthetic weekly business data covering 2 years of operations
- Dimensions: Sales revenue, units sold, marketing spend, regional breakdowns, product category performance
- Pipeline input: A single CSV — no database, no server, no configuration beyond an optional API key
🔬 Methodology
5-module pipeline: (1) EDA + dual-axis trend visualisation → (2) Dual anomaly detection (Z-score ±2.5σ + IQR 1.5× union) with cross-reference to prior-week marketing spend → (3) AI narrative generation via Claude Sonnet 4 through Vercel AI Gateway, with graceful fallback to data-driven placeholder logic if no API key → (4) Weekly intelligence brief with WoW/MoM metrics and executive summary → (5) Self-contained HTML dashboard with KPI cards, anomaly briefs, and embedded base64 charts — auto-opens in browser.
💡 Key Insights
- Z-score catches extreme outliers while IQR catches mild deviations — using the union of both ensures nothing is missed
- The AI layer is an upgrade, not a dependency: pipeline works fully offline with data-driven narratives
- Cross-referencing anomalies with prior-week marketing spend identifies spend-driven deviations vs. organic shifts
- Modular architecture: each of the 5 pipeline stages can run independently or as part of the full orchestrated sequence
📈 Business Impact
- What previously took an analyst 2–3 hours now runs automatically in under 5 seconds
- Executives get a 2-sentence summary per week — no scrolling through spreadsheets
- Marketing leads get immediate visibility into whether spend spikes drove anomalies
- Data teams get a production-ready template: swap the CSV, swap the prompt, done
Exploratory Data Analysis Portfolio
A two-part EDA investigation urban air quality patterns across NYC neighbourhoods and property market valuation gaps between assessed vs. actual sale prices demonstrating rigorous data-cleaning and visual storytelling.
📌 Business Problem
Before any predictive model can succeed, the underlying data must be understood. These EDAs answer foundational questions: Which neighbourhoods face the worst pollution? How well do government property assessments match actual market prices?
📂 Data
- Air Quality: ~1,000 environmental monitoring records pollutant indicators, geographic locations, time periods
- Property Sales: ~10,000 real estate transactions assessed values, sale amounts, sales ratios, property types
🔬 Methodology
Data Ingestion (CSV/Excel via Pandas) → Null handling & type conversion → Univariate analysis (histograms, KDE) → Bivariate analysis (scatter, box plots) → Correlation heatmaps → Statistical summarisation → Publication-ready Matplotlib/Seaborn charts.
💡 Key Insights
- Certain NYC neighbourhoods have 2× the pollution levels of city-wide averages
- Property assessments systematically undervalue properties in high-demand towns
- Box plots revealed extreme outlier sales that summary statistics missed entirely
- Seasonal air quality variation follows predictable, actionable patterns
📈 Business Impact
- EDA findings directly informed feature selection for subsequent ML models
- Property analysis revealed systemic valuation bias actionable for government assessors
- Demonstrated a reproducible EDA framework applicable to any new dataset
Deepfake Image Detector
Built a CNN-based binary classifier to detect AI-generated facial images in real-time, deployed via a Streamlit web app with confidence scoring supported by a published research paper.
📌 Business Problem
With the proliferation of AI-generated imagery, media organisations and security teams need automated tools to flag potentially manipulated facial images before they're published or used for fraud.
📂 Data
- Source: Curated dataset of real and AI-generated (deepfake) facial images
- Preprocessing: Resized to 128×128, normalised pixel values (0–1), 80/20 train-test split
- Model size: ~38 MB
🔬 Methodology
Image preprocessing (resize, normalise, RGBA→RGB) → Custom 3-layer CNN (32→64→128 filters, MaxPooling, Dropout=0.5) → Binary classification (sigmoid output) → Trained with Adam optimiser (lr=0.001) + Binary Crossentropy → Evaluated with confusion matrix & classification report → Deployed via Streamlit with real-time upload & prediction.
💡 Key Insights
- Sub-second inference enables real-time screening of uploaded images
- Confidence scoring provides probability-based risk assessment rather than binary yes/no
- Dropout regularisation (0.5) prevents overfitting on limited training data
- Research paper documents methodology for academic reproducibility
📈 Business Impact
- Deployable tool for media verification workflows and content moderation
- Streamlit interface enables non-technical users to perform deepfake audits independently
- Research contribution advances the deepfake detection knowledge base
- Architecture is extensible to video detection and ensemble methods
Prompt Refinement - AI Prompt Enhancer
Built a Manifest V3 Chrome extension that refines rough prompts directly inside ChatGPT, Claude, and DeepSeek through Vercel AI Gateway, while keeping API keys isolated and every submission under the user's control.
Problem
Writing effective prompts often requires repeated editing, reformatting, and context switching. Users needed a quick way to improve clarity and structure without leaving their AI chat or giving an extension permission to send messages automatically.
How It Works
- Adds a Refine action to ChatGPT, Claude, and DeepSeek, with a standalone popup for use on any page
- Sends the prompt through a Manifest V3 service worker to Vercel AI Gateway using the user's chosen model
- Replaces the original text only when refinement succeeds and the user has not edited the prompt while the request is running
- Leaves the refined prompt ready for review and never auto-submits it
Key Decisions
- Keeps the API key inside the trusted service worker and stores it in
chrome.storage.local, never exposing it to content scripts or AI websites - Stores only the model ID in Chrome Sync and keeps no prompt history, analytics, or advertising data
- Uses a 30-second timeout and maps authentication, budget, rate limit, network, and provider failures to safe user-facing errors
- Preserves the prompt's intent, constraints, language, and meaningful formatting instead of inventing new requirements
Outcome
- Delivers prompt refinement across three major AI chat platforms plus a portable popup workflow
- Protects in-progress user edits and leaves website text unchanged whenever a request fails
- Supports any accessible Vercel AI Gateway model through a configurable
provider/modelidentifier - Runs with vanilla JavaScript, HTML, and CSS with no bundler or runtime dependencies
FloatTab - Picture-in-Picture Browser Extension
Built a Chrome extension that pops any website into a small always-on-top floating window with full interactivity, using the Document Picture-in-Picture API with automatic fallback to view-only mode.
📌 Problem
Switching between browser tabs to reference documentation, watch tutorials, or monitor chat while working is disruptive. Alt-tabbing breaks focus and context. Users needed a way to keep a secondary page visible and interactive alongside their primary workspace without juggling windows.
🔬 How It Works
- Interactive Mode: Opens a fully clickable, scrollable mini-window of the site using the Document Picture-in-Picture API (Chrome 116+)
- View-Only Mode: Automatically falls back to a live mirror of the tab when a site blocks iframe embedding (banks, social media, etc.)
- Auto-Detection: Extension detects which mode works for each site and switches seamlessly with no user intervention
- Architecture: Manifest V3 with background service worker, content scripts for DOM injection, and offscreen documents for mirror rendering
💡 Key Decisions
- Used Document PiP API instead of traditional PiP to enable full HTML interaction, not just video playback
- Built graceful fallback logic so the extension never shows an error, it just silently downgrades to view-only
- Kept the UX to a two-click flow: click icon, click "Float This Tab"
- Zero configuration, no accounts, no permissions beyond activeTab
📈 Outcome
- Works on any website without site-specific configuration
- Handles DRM-protected and embedding-restricted sites without crashing
- Sub-second launch time from click to floating window
- Fully local, no data leaves the browser
TOON Exporter - Token-Efficient Web Content Converter
Built a universal Chrome extension that converts any web content into TOON (Token-Oriented Object Notation), a compact data format that uses 40-60% fewer tokens than JSON, designed for LLM workflows.
📌 Problem
Feeding web content (articles, chat logs, structured data) into LLMs wastes tokens on verbose JSON/XML markup. There was no efficient way to extract, structure, and compress web content for LLM context windows without manual reformatting.
🔬 How It Works
- Smart Structure Detection: Auto-classifies selected text as chat dialogue, key-value pairs, lists, or article content and applies the optimal TOON schema
- Full Chat Export: Auto-scrolls ChatGPT and Claude conversations to load lazy-loaded messages, then extracts the full thread with role attribution
- Rich Content Extraction: DOM-to-Markdown converter preserves code blocks, tables, headings, and formatting while stripping UI artifacts
- Chunking Engine: Splits large conversations into configurable chunks (default 50 messages / 32K chars) for manageable LLM input
💡 Key Decisions
- Designed TOON as a CSV-inspired tabular notation that achieves 40-60% token reduction vs. JSON while remaining human-readable
- Built multi-strategy extraction for ChatGPT/Claude: falls back through data attributes, class selectors, and markdown blocks
- Right-click context menu integration for zero-friction capture
- Export history stores up to 50 recent conversions for re-access
📈 Outcome
- Works on any website with site-specific optimisations for ChatGPT and Claude
- Achieves 40-60% token savings vs. raw JSON export
- Supports copy-to-clipboard,
.toonfile download, and browsable export history - Full TypeScript reference implementation with benchmarks included in the repo
AI Operations Copilot
Built a local-first agentic RAG application for employee support that retrieves policy evidence, applies deterministic SLA and escalation rules, and resolves or creates reviewer handoffs — achieving 80% resolution rate and 96.67% tool-selection accuracy on a 30-case evaluation.
📌 Business Problem
Organisations handle thousands of employee support tickets daily, but front-line teams lack immediate access to policy documents, SLA rules, and escalation criteria. Manual triage is slow, inconsistent, and unauditable. An automated assistant was needed that retrieves the right evidence, follows deterministic business rules, and creates a clear reviewer handoff when it cannot resolve a case.
📂 Data
- Source: Policy documents (indexed into Qdrant vector store), mock employee profiles, and simulated ticket records
- Storage: SQLite for agent_runs, retrieved_evidence, tool_calls, escalations, evaluation_runs, and policy_documents; Qdrant for policy vectors
- Evaluation: Fixed 30-case evaluation suite with employee and ticket scenarios across resolution, escalation, and clarification paths
🔬 Methodology
React + Vite frontend (employee workspace, reviewer dashboard, evaluation dashboard) → FastAPI backend orchestrating a bounded LangGraph agentic workflow → Policy retriever queries Qdrant for relevant evidence with deterministic lexical fallback → Typed audited tools interact with mock ticket and employee systems, recording every invocation before and after execution → Deterministic SLA and escalation rules authorize escalations (not the LLM) → Every retrieval is audited before/after execution for full traceability.
💡 Key Insights
- Tool-selection accuracy of 96.67% — the agent reliably chooses the right tool for each query type
- Escalation accuracy of 96.67% — deterministic rules prevent hallucinated escalations
- Retrieval precision@3 of 83.33% — Qdrant vector search returns relevant policy evidence in the top 3 results
- 0 hallucination failures across the full 30-case evaluation — every policy claim is backed by retrieved evidence
📈 Business Impact
- 80% resolution rate — 24 of 30 cases resolved automatically without human intervention
- p95 latency of 2.1 seconds — well under the 8-second target for production readiness
- Answer correctness of 95.56% across resolved cases
- Every completed run retains evidence snapshots and full tool timelines for compliance auditability
cc-byok — BYOK Launcher for Coding Agents
Built a cross-platform CLI configuration wrapper that launches Claude Code, Codex, Codex App, and OpenCode through BYOK providers, storing API keys in the OS keychain and injecting them via environment variables — never writing secrets to config files.
📌 Problem
Developers using coding agents like Claude Code, Codex, and OpenCode through API gateways face repetitive setup: manually configuring environment variables per session, managing API keys across multiple tools, and handling different provider protocols (Anthropic-compatible vs OpenAI-compatible). There was no unified launcher that stored keys securely in the OS keychain and injected them at launch time.
🔬 How It Works
- Init: Creates persistent non-secret config in ~/.cc-byok/config.json
- Provider Add: Stores the API key under service cc-byok in the OS keychain (macOS Keychain, Linux Secret Service, Windows Credential Manager)
- Use: Selects provider and model for future launches
- Launch: Reads the key from the keychain, sets environment variables per target protocol, and launches the coding agent as a child process — Claude Code receives Anthropic-compatible env vars; Codex targets receive OpenAI-protocol env vars
💡 Key Decisions
- API keys are stored exclusively in the OS keychain and read only at launch time — never written to config files, never logged
- Provider protocols are isolated: Anthropic-compatible for Claude Code, OpenAI-protocol for Codex targets; custom gateways are Anthropic-compatible only
- cc-byok makes no network requests — it is purely a configuration wrapper and process launcher
- Existing Codex Desktop config is backed up before the first managed change to .codex/config.toml.cc-byok.bak
📈 Outcome
- Single-command launch for Claude Code, Codex, Codex App, and OpenCode through any configured provider
- Cross-platform: macOS Keychain, Linux (GNOME Keyring/KWallet), and Windows Credential Manager
- Zero secrets in config files; terminal I/O inherited directly; returns the agent's exit code
- Provider and model overrides at launch time without changing the saved selection
hearth - Terminal Chat
Built a persistent terminal chat interface for local Ollama models with streamed responses, resumable conversations, readable JSON history, model switching, and a bordered TUI designed for focused local AI work.
📌 Problem
Local Ollama users needed a reliable terminal chat workflow that could remember the active model, resume previous conversations, switch models quickly, and preserve readable history without forcing them into a browser-based interface.
🔬 How It Works
- Starts Ollama when needed, opens a new chat by default, and reuses the remembered model whenever possible
- Renders a bordered terminal UI with conversation output, a fixed input box, and a status line showing model and context usage
- Streams assistant responses directly inside the output box while persisting conversations as readable JSON files
- Supports
hearth --continue,hearth --resume <id-or-title>, model listing, saved chat listing, and help commands
💡 Key Decisions
- Integrates directly with the local Ollama API so chats stay local-first and work with installed models
- Stores conversation files as plain JSON under the user's home directory for easy inspection, backup, and recovery
- Keeps the input box and status line anchored so long responses and terminal resizing do not break the chat layout
- Implements slash commands for model selection, session loading, system prompts, search, regeneration, editing, saving, and exit flows
📈 Outcome
- Provides a reusable CLI/TUI chat experience for local language models with persistent sessions and searchable history
- Makes model management available through both non-interactive commands and arrow-key pickers
- Preserves previous messages across restarts through JSON-backed conversation storage
- Includes a manual QA script covering startup, resume, model switching, streaming, search, regeneration, editing, and terminal resizing
AI Code Reviewer
Built a MERN-stack AI-powered code review tool integrating Deepseek R1 via Groq API for fast inference, generating automated feedback on code quality, security vulnerabilities, and performance optimizations.
📌 Business Problem
Manual code review can slow development teams down, especially for routine quality, security, and performance checks. The goal was to build an AI-assisted reviewer that gives developers immediate, actionable feedback before human review.
🔬 Methodology
MERN-stack application with a React frontend, Node.js and Express backend, MongoDB persistence, and Deepseek R1 accessed through the Groq API for low-latency code analysis.
💡 Key Features
- Generates automated code quality and security feedback
- Surfaces performance optimization suggestions
- Uses a responsive React UI to present review output clearly
- Stores review history through the backend data layer
📈 Outcome
- Reduces manual effort for routine code quality checks
- Accelerates early review cycles with fast AI inference
- Provides specific, actionable suggestions for developers
Seat Booking System
Built a full-stack React + Spring Boot seat reservation application with MySQL persistence, dynamic pricing tiers, validation rules, and a responsive glassmorphism interface.
📌 Business Problem
Seat reservation systems need reliable availability tracking, pricing logic, and validation that prevents invalid bookings. This project implements the core booking workflow across a full-stack web application.
🔬 Methodology
React handles the interactive booking UI, Spring Boot exposes REST endpoints for booking operations, and MySQL persists seat and reservation data.
💡 Key Features
- Dynamic pricing tiers based on selected seat category
- Smart validation rules for reliable booking flow
- Persistent reservation data through MySQL
- Responsive UI with light and dark theme support
📈 Outcome
- Demonstrates complete frontend-to-backend booking logic
- Provides a reusable foundation for venue or event booking
- Shows full-stack integration across UI, API, and database
LLM REST API
Built a Flask-based API server exposing the Maincoder-1B code generation model with configurable generation parameters, GPU-accelerated inference on Colab, and public access through ngrok.
📌 Business Problem
Developers often need quick remote access to an LLM without managing full deployment infrastructure. This project exposes a code generation model behind a simple REST API for external application integration.
🔬 Methodology
Flask provides the API layer, Transformers runs the model, Google Colab supplies GPU-backed inference, and ngrok exposes a temporary public endpoint for remote usage.
💡 Key Features
- REST endpoint for remote LLM code generation
- Configurable generation parameters such as temperature
- GPU-accelerated inference through Google Colab
- Error handling for stable request processing
📈 Outcome
- Makes model inference accessible through a simple API
- Reduces setup friction for experiments and integrations
- Demonstrates practical LLM serving with lightweight tools
MathReason-1.5B Fine-Tuning Blueprint
Designed a reproducible supervised fine-tuning workflow for DeepSeek-R1-Distill-Qwen-1.5B, using NVIDIA's OpenMathReasoning dataset to improve step-by-step mathematical reasoning.
📌 Objective
Define a repeatable path for adapting a compact reasoning model to mathematical problem solving while preserving its general language capabilities.
📂 Training Data
- Dataset: NVIDIA OpenMathReasoning, with curated mathematical questions and solution traces
- Preparation: filter malformed or overlong examples, deduplicate by problem, and prevent benchmark contamination
- Format: convert validated examples into the base model's chat format and split by problem
🔬 Training Plan
Use supervised fine-tuning with LoRA, falling back to QLoRA when GPU memory is limited. The workflow covers baseline evaluation, data preparation, adapter checkpointing, validation, model export, and inference testing with fixed seeds and versioned configuration.
💡 Evaluation Design
- Compare base and adapted models under identical decoding settings
- Measure GSM8K and MATH accuracy, invalid-output rate, and latency
- Keep evaluation examples separate from training data
- Track loss stability and watch for catastrophic forgetting
📈 Intended Outcome
- Reusable adapter, tokenizer configuration, and training metadata
- Documented evaluation report showing before-and-after results
- Reproducible CLI workflow for training, evaluation, and inference
Abliterated LLM Server
Automated a Google Colab-ready, multi-model llama.cpp server that downloads quantized Qwen models, exposes OpenAI-compatible endpoints, and publishes them through an ngrok tunnel.
📌 Problem
Running local LLMs remotely often requires separate setup for model downloads, serving, public networking, and client compatibility. This project condenses that workflow into one repeatable script.
🔬 How It Works
The script installs llama.cpp and ngrok, retrieves quantized GGUF models from Hugging Face, starts llama.cpp in multi-model router mode on a local port, verifies the registered models, then opens an HTTPS tunnel and prints its public URL.
💡 Key Features
- OpenAI-compatible
/v1endpoints for client integration - Multi-model routing from a shared model directory
- Q4_K_M quantized GGUF models for more modest hardware needs
- Automatic cleanup of prior server processes and diagnostic logs
📈 Outcome
- Provides a repeatable path from Colab runtime to remote LLM API
- Works with clients that accept a custom OpenAI-compatible base URL
- Documents tunnel, secret-handling, and resource considerations
SnakeJev — AI-Driven Snake Game
Built a classic Canvas Snake game where Vercel AI Gateway evaluation models select each move, protected by hard safety rules and an automatic BFS fallback bot.
📌 Problem
Let an AI control a fast, stateful game without allowing a delayed, low-confidence, or invalid response to end a run. The game needs both model-driven strategy and deterministic safety controls.
🔬 How It Works
Each animation-frame decision sends a compact representation of the grid, snake, food, board, and legal moves to a serverless endpoint. The endpoint evaluates a selected Jev or Laya model through Vercel AI Gateway and returns a structured direction, probabilities, and confidence score.
💡 Reliability Controls
- Client and server pre-filter lethal and 180-degree moves
- Confidence and probability gates reject unreliable model decisions
- BFS automatically takes over after invalid, unsafe, or low-confidence output
- Origin checks, request limits, and body-size caps protect the API route
📈 Outcome
- Demonstrates structured AI evaluation in an interactive browser game
- Supports live model switching between Jev and Laya
- Includes unit, API, safety-gating, and simulation test coverage
skill.installer
Created a no-account web tool that resolves a public AI-agent skill link, previews its files, and packages the complete version-pinned skill folder as a ZIP download.
📌 Problem
Installing an AI-agent skill from a public repository often means cloning a whole project or manually copying nested files. This tool turns a skill link into a ready-to-unzip package.
🔬 How It Works
The application accepts skills.sh and GitHub repository, tree, or SKILL.md URLs. Its route handlers resolve the target skill, inspect its contents, select an exact source version, and build a fresh ZIP without executing any downloaded code.
💡 Key Features
- Catalog browsing alongside direct-link resolution
- Preview of included files before download
- Support for repositories containing multiple skills
- Optional GitHub token support to reduce anonymous API rate limits
📈 Outcome
- Delivers complete skill folders, including nested and binary files
- Keeps source versions consistent within every downloaded archive
- Includes unit and browser-test tooling for the resolver and download flow
Claude QoL Browser Extension
Built a cross-browser extension for claude.ai that adds chat search, conversation navigation, speech tools, forking, exporting, and personalised preferences.
📌 Problem
Long Claude conversations are difficult to navigate, search, reuse, and preserve. The extension adds the interaction tools needed to make an active chat history easier to work with.
💡 Key Features
- Global and chat-level text search across conversation branches
- Conversation forking, compacting, and saved navigation points
- Speech-to-text and text-to-speech with browser and BYOK providers
- Chat and project exports to ZIP, HTML, and JSON, plus ZIP import
🔬 Implementation
Content and isolated scripts integrate with the claude.ai UI, while browser-extension manifests support Chrome, Firefox, and desktop-client launcher use. Local helper libraries manage search, export archives, settings, and speech providers.
📈 Outcome
- Available through the Chrome and Firefox extension stores
- Offers practical workflow controls without changing the underlying chat service
- Supports portable conversation archives for reuse and backup
Fine-Tuning-Small
Created a beginner-friendly QLoRA pipeline for adapting Qwen2.5-0.5B-Instruct to mathematical reasoning on GSM8K with only 4 GB of GPU VRAM.
📌 Objective
Provide an approachable, resource-conscious supervised fine-tuning project for improving mathematical reasoning on a small instruction-tuned language model.
📂 Model & Data
- Base model: Qwen2.5-0.5B-Instruct
- Dataset: 2,000 GSM8K mathematical reasoning samples
- Target environment: a GPU with 4 GB of VRAM
- Adaptation: 4-bit QLoRA with LoRA rank 8
🔬 Training Pipeline
The notebook formats questions and answers through the model chat template, establishes a baseline, loads the model in 4-bit precision, trains with TRL's SFTTrainer for one epoch, then saves the LoRA adapter and tokenizer for inference.
📈 Evaluation Goal
- Evaluate the original and adapted models with identical GSM8K settings
- Compare mathematical answer accuracy before and after fine-tuning
- Produce a reusable adapter for further experimentation