Projects

**Overview:** This project provides a framework for evaluating and comparing different customization techniques for foundation models, including RAG, fine-tuning, and a hybrid approach combining both methods. **Key features:** - Evaluates performance, cost, and latency across RAG, fine-tuning, and hybrid approaches. - Utilizes a synthetic dataset for experimentation. - Supports customization of the environment settings, knowledge base configuration, data source configuration, RAG, fine-tuning, and evaluation configurations. **Tech stack:** Python **Why it matters:** This framework helps developers determine the most effective approach for specific use cases by analyzing performance, cost, and latency across different customization techniques, ultimately aiding in the optimization of foundation models for business needs.

Overview: This project is a PyTorch implementation for fine-tuning the Segment Anything Model (SAM) on medical images, specifically designed for gastrointestinal endoscopy image segmentation. It includes comprehensive data preprocessing, multi-GPU distributed training, and model evaluation tools. Key features: - Fine-tuning SAM on custom medical datasets - Single-GPU and multi-GPU distributed training - Comprehensive data preprocessing and augmentation - Model evaluation and visualization tools Tech stack: Python Why it matters: This project provides a complete pipeline for fine-tuning SAM on medical images, making it a valuable resource for researchers and developers working in medical image segmentation.

### Overview A reasoning critic evaluates the quality of reasoning behind an answer, not just its correctness. This project fine-tunes open-source LLMs, such as Qwen and Mistral, into this role using a corpus of hand-written critique examples and external instruction data. The models are evaluated against a held-out benchmark to assess their performance. ### Key Features - Fine-tuning of open-source LLMs into reasoning-process evaluators. - Evaluates the quality of reasoning behind an answer. - Uses a corpus of hand-written critique examples mixed with external instruction data. - Evaluates against a held-out benchmark. - Two models were trained on identical data and compared head-to-head. ### Tech Stack Python ### Why it Matters Fine-tuning pulled both models toward the capability level embedded in the training data, from opposite directions. Qwen's trap detection came down (0.975 → 0.900, mild forgetting) while Mistral's came up (0.800 → 0.850, a gain): they converged toward the corpus. Format proved base-dependent: Mistral followed the output contract from the system prompt alone (base verdict rate 1.000), while Qwen needed the fine-tune to learn it (0.525 → 0.950). At n=40 a 0.05 delta is two questions, so the convergence is consistent but not statistically proven — and because it rests on the trap-detection metric, it is now best read as suggestive rather than

Overview: A toolkit designed to explore and build with NVIDIA NIMs, including LLMs, 3D generation, and speech recognition. Key features: - Local exploration of NVIDIA NIMs - Support for multiple NIM services including LLMs, image generation, 3D generation, and speech recognition Tech stack: FastAPI, Celery, Nuxt.js, Vue 3, Redis, Prometheus, Grafana, Flower Why it matters: Simplifies the process of experimenting with NVIDIA NIMs and enhances the development experience with enhanced functionality and monitoring tools. Repository: briancaffey/nvidia-nim-kit GitHub stars: 6 GitHub description: A toolkit to explore and build with NVIDIA NIMs README excerpt: 

### Overview DINOv2-LoRA Segmentation is a remote sensing semantic segmentation framework that leverages pretrained DINOv2 visual representations and parameter-efficient fine-tuning through Low-Rank Adaptation (LoRA). ### Key Features - **DINOv2 Foundation Model**: Pretrained visual representations for efficient transfer learning. - **CNN-Based Decoder**: Integrates CNN-based architectures for effective semantic segmentation. - **Decoder Architecture Benchmarking**: Evaluates multiple decoder architectures for optimal performance. - **Linear Probing**: Trains the decoder only, reducing the number of parameters to be fine-tuned. - **Full Fine-Tuning**: Fine-tunes the entire network, updating all parameters for better performance. - **LoRA-Based Adaptation**: Low-Rank Adaptation (LoRA) for efficient parameter-efficient transfer learning. - **Parameter-Efficient Transfer Learning**: Reduces the number of trainable parameters while preserving knowledge from the pretrained model. - **Remote Sensing Segmentation**: Land-cover semantic segmentation on remote sensing imagery. ### Why It Matters This project explores and benchmarks various decoder architectures and adaptation strategies, including linear probing, full fine-tuning, and LoRA-based transfer learning, to improve remote sensing semantic segmentation on the LOVEDA dataset.

### Overview: Plumb is a cutting-edge project that fine-tunes a multimodal Qwen3.8-27B model to excel at AIA G702/G703 pay-application review. The project focuses on extracting and verifying structured data from invoices, lien waivers, and change orders, ensuring every math error and discrepancy is corrected. This approach aims to improve accuracy and speed, making it a valuable tool for contractors and project managers. ### Key Features: - Fine-tuning a multimodal Qwen3.8-27B model on Modal/GCP free credits. - Extraction of SOV lines and G702 summary totals. - Cross-checking with contract SOV, prior approved apps, and change orders. - Emitting PASS or line-level exceptions with corrected figures. - Verifying arithmetic and cross-referencing with entitlements and waivers. - Emitting dense, deterministic RLVR rewards with every check recomputable. ### Tech Stack: Python ### Why It Matters: - The exact recipe that beat a frontier model at 1.7B in ReconForge, now 16× bigger. - Pure document-to-structured-data + deterministic reconciliation. - Real, dollar-denominated pain: 15% of pay apps are rejected for math errors. - Competitive gap: Siteline/Rabbet/Procore digitize but don't adjudicate against contract entitlements. - Perfect-level target: Every check is recomputable arithmetic. - The verifier gives dense, deterministic RLVR rewards. ### Directory Layout:

### Overview: A minimal language model pipeline designed to run on a laptop, from raw text to a tokenizer, pretraining, inference, fine-tuning, and reinforcement learning techniques. ### Key features: - Tokenizer - Model - Pretraining - Inference - Fine-tuning - Reinforcement Learning for Human Preferences (RLHF) and Verifiable Rewards (RLVR) ### Tech stack: JavaScript ### Why it matters: The pipeline is designed to be simple and accessible, making it suitable for developers and researchers alike. It includes all stages necessary for building and fine-tuning a language model, from raw text to a trained model that can be used with other tools. ### Repository: GitHub: changkun/minllm ### GitHub stars: 6 ### GitHub description: A minimal pipeline for making a language model, small enough to run on a laptop and written to be read. It goes from raw text to a tokenizer, a pretrained model, an inference engine, a fine-tuned chat model, and a model post-trained with reinforcement learning, first from human preferences (RLHF) and then from verifiable rewards (RLVR), and ends with that model in the format that other tools run. ### Stages: - **Tokenizer**: Byte-level BPE: training, encoding, decoding, special tokens - **Model**: Decoder-only transformer with RMSNorm, RoPE, SwiGLU and grouped-query attention - **Pretraining**: Data pipeline, AdamW, learning rate schedule, checkpoints: a model that writes stories

Overview: Vietnamese math reasoning distillation is a project that distills step-by-step math reasoning from Phi-3 (teacher) into TinyLlama-1.1B (student) using QLoRA and judge-filtered reasoning traces. Key features: - Vietnamese math reasoning distillation - Distilling from Phi-3 to TinyLlama-1.1B - Using QLoRA and judge-filtered reasoning traces Tech stack: Python, PyTorch, QLoRA, llama.cpp Why it matters: This project is crucial for improving math reasoning capabilities in language models, making them more effective in educational and research contexts.

Overview: This repository implements a two-stage training pipeline for chart question answering using Qwen3-VL, fine-tuned on the ChartQA dataset. It includes supervised fine-tuning and reinforcement learning for improved format compliance and accuracy. Key features: - Supervised fine-tuning on ChartQA dataset - Reinforcement learning (GRPO) for format compliance and accuracy improvement - Base model: Qwen/Qwen3-VL-2B-Instruct - SFT model: Nhaass/Qwen3-VL-2B-ChartQA - GRPO model: Nhaass/Qwen3-VL-2B-ChartQA-GRPO Tech stack: Python Why it matters: This project showcases the potential of Qwen3-VL for chart QA, combining supervised learning with reinforcement learning to enhance the model's performance and format compliance. Repository: cudnah124/ChartQA Primary language: Python GitHub stars: 6 GitHub description: Vision-language AI for chart question answering using Qwen3-VL with SFT and GRPO training

Overview: This project is a real-time voice AI assistant for the SAM 2 No Code Finetuning web application, providing users with natural conversation to learn about LoRA fine-tuning, manufacturing datasets, and the training configuration UI. Key features: - Real-time voice interaction through LiveKit agents - Access to a RAG knowledge base via MongoDB Atlas and Voyage AI - Integration with PostgreSQL for user authentication - Generation of conversation summaries for follow-up emails Tech stack: Python, LiveKit, Deepgram, OpenAI, Cartesia, Lemonslice, MongoDB Atlas, Voyage AI Why it matters: This project simplifies complex technical information into a user-friendly, conversational format, enhancing the user experience and making it easier for developers to understand the intricacies of LoRA fine-tuning and SAM 2 architecture.

### Overview: Mayaku is a real-time object detection, segmentation, and keypoint library designed for fine-tuning and exporting. It provides high accuracy and efficiency, making it suitable for various applications. ### Key features: - **Highest Fine-Tune AP at Nano Size**: Across all 100 datasets of RF100-VL, Mayaku-n averages 58.9 AP, surpassing RF-DETR nano (57.4) and YOLO26n (54.8). - **True Int8 Quantization**: The deploy graph uses only convolutions, ReLU, add, max-pool, and nearest resize, ensuring end-to-end quantization with quantization-aware training enabled by default. - **Runs and Deploys Everywhere**: No compiled extensions, deformable convolutions, or attention. Parity-tested exports to ONNX, Core ML, OpenVINO, and TensorRT. - **Detection and Instance Segmentation**: One API and one training loop for both detection and instance segmentation. ### Tech Stack: Mayaku is built with Pure PyTorch and is compatible with CUDA, Apple Silicon, and CPU. ### Why it Matters: Mayaku is designed to be the most accurate nano detector for fine-tuning on your own data, offering high accuracy and efficiency. It simplifies the process of fine-tuning models on your own datasets, making it ideal for real-world applications where speed and accuracy are crucial.

Overview: This repository provides a straightforward way to fine-tune OpenAI's `gpt-3.5-turbo` model using Python. It also requires the use of Google Sheets to prepare the training data. Key features: - Fine-tuning of `gpt-3.5-turbo` model - Utilizing Python for the process - Need for Google Sheets to prepare training data Tech stack: Python, Google Sheets Why it matters: This method simplifies the fine-tuning process, making it accessible to developers without extensive knowledge in machine learning or natural language processing.

### Overview: This project is a real-time disaster tweet detection system using TensorFlow, Keras, and Hugging Face Transformers. It fine-tunes a BERT model to classify tweets accurately and efficiently. ### Key Features: - **Fine-tuned BERT Model**: High-precision classification for disaster-related tweets. - **Real-Time Analysis**: Processes tweets quickly and accurately. - **Actionable Insights**: Provides timely information for emergency response. - **Scalable Solution**: Easily adaptable to different datasets and tasks. ### Tech Stack: - **TensorFlow**: Core framework for implementing and fine-tuning the BERT model. - **Keras**: Framework for building and training models. - **Hugging Face Transformers**: Pre-trained BERT models and utilities for NLP tasks. - **scikit-learn**: Traditional ML tasks for classification and evaluation. - **Matplotlib**: Visualization tools for model performance. - **Pandas**: Data manipulation and preprocessing for tweet analysis. ### Why It Matters: This system is crucial for decision-makers in emergency management, enabling them to respond quickly to disasters by providing accurate and actionable insights from real-time tweets.

### Overview: DeepSeek-V4-Flash-0731 is a high-performance language model optimized for 1,048,576-token context on two NVIDIA DGX Spark units with TP=2, achieving peak decode speeds of up to 653.2 tok/s (c=16) and 398.2 tok/s (c=16) for list and JSON, and 291.1 tok/s (c=32) for code and prose. The model features a 4-bit MLA KV cache and is designed for speculative decoding and deterministic KV-pin sizing, with a 3.23x concurrency at 1M tokens. ### Key features: - **Max Token Context**: 1,048,576 tokens - **GPU KV Cache Pool**: 3,386,611 tokens (3.23x @ 1M) - **Peak Decode Speed**: 653.2 tok/s (c=16) for list, 398.2 tok/s (c=16) for JSON, 291.1 tok/s (c=32) for code and prose - **Mixed-Kind Aggregate**: ~310 tok/s at c=12 - **Speculative Decoding Acceptance**: 0.63 / 4.16 tokens per step - **Long-Context Retrieval**: 994,397-token prompt verified on this config

### Overview: This project is an AI-powered book recommendation engine that uses semantic understanding and emotion intelligence to deliver highly relevant and personalized book suggestions. Leveraging LangChain, OpenAI embeddings, and emotion-aware NLP across 7,000 titles, it offers an interactive Gradio experience for intuitive exploration. ### Key Features: - Semantic vector search for content-based similarity. - Emotion and sentiment analysis from book descriptions. - Interactive Gradio dashboard for user-friendly book recommendations. - Integration of Python, Pandas, LangChain, OpenAI embeddings, transformers, Chroma vector database, and Gradio. ### Tech Stack: Python, Pandas, LangChain, OpenAI embeddings, transformers, Chroma vector database, Gradio. ### Why it Matters: By combining embedding-based retrieval, zero-shot text classification, sentiment and emotion analysis, and an interactive Gradio dashboard, this project demonstrates a complete end-to-end AI pipeline for an intelligent, emotion-aware semantic recommendation system.

Overview: Kurtis is a fine-tuning, inference, and evaluation tool designed for Small Language Models, specifically Huggingface's SmolLM2. It focuses on creating a space for genuine interaction and understanding, rather than complex tasks. Key features: - Fine-tuning for specific language models - Inference capabilities - Evaluation tools for various models Tech stack: Python Why it matters: Kurtis aims to provide a supportive and empathetic conversational AI, focusing on understanding and meaningful dialogue, rather than complex tasks or generating specific outputs like images or code.

### Overview: MiniChat is a minimalistic LLM chat UI inspired by Fooocus and Pi. It focuses on content and simplicity, using bold typography and a minimal design. ### Key features: - **Minimalistic Design**: Focuses on content with minimal design elements. - **OpenAI Compatible**: Supports OpenAI-compatible APIs, including Ollama, Portkey, and HuggingFace Text Generation Inference. - **Docker Support**: Runs with Docker, providing a lean image size of less than 2MB. ### Tech stack: TypeScript ### Why it matters: By keeping configuration minimal and focusing on content, MiniChat aims to provide a focused and efficient chat interface.

Overview: lollm is a small, readable inference engine designed specifically for studying how LLMs and related models run inference. It includes a thin loader, router, and generate loop, along with self-contained family packages optimized for clarity and verification against `transformers`. Key features: - Thin loader and router - Shared generate loop - Self-contained family packages (qwen2, qwen3, gemma2, gemma3, gemma4, qwen3_5) - GGUF and safetensors support for all families - Tokenizer optimized for clarity and verification against `AutoTokenizer` Tech stack: Python Why it matters: lollm provides a clear and verified way to study LLM inference, ensuring that the implementation is as close as possible to the original models while maintaining readability and verification against established benchmarks. Repository: giapnguyen74/lollm GitHub stars: 6 GitHub description: an AI inference for learning README excerpt: <img src="docs/lollm-logo.svg" alt="lollm — learn only LLM" height="72">

### Overview: GPUStack Operator enables the management and utilization of heterogeneous accelerators on Kubernetes, including GPUs, NPUs, and other accelerators. It provides features such as device discovery, RDMA networking, topology placement, shared cache, model delivery, and model deployment, making it a comprehensive solution for accelerating machine learning workloads. ### Key Features: - **Heterogeneous Devices**: Discover and allocate whole devices, shared devices, logical slices, or hardware partitions. - **RDMA Networking**: Provide RDMA network interfaces alongside accelerators. - **Topology**: Place related workloads within the requested network or location domain. - **KV Cache**: Share inference cache across workloads. - **Model Delivery**: Fetch, verify, and cache model weights on nodes. - **Model Deployment**: Run model serving replicas with routing and optional prefill/decode roles. - **GPU Instances**: Enter accelerator-backed container workspaces over SSH. ### Tech Stack: Go ### Why it Matters: GPUStack Operator simplifies the management and utilization of accelerators on Kubernetes, making it easier to deploy and scale machine learning workloads.

### Overview: This project explores the development and evaluation of Convolutional Neural Networks (CNNs) for skin lesion classification using the HAM10000 dataset. The dataset includes 7 skin cancer classes, including melanoma, which is the primary focus. Techniques such as data augmentation, generative adversarial networks, and transfer learning are utilized to improve model performance. ### Key features: - Data augmentation with image transformations and Generative Adversarial Networks. - Segmentation and transfer learning techniques. - Metrics extracted for accuracy, loss, sensitivity (Recall), specificity, F1-score, AUC, and precision. - Utilization of ConvNeXt, ResNetV2, ViT_B/32, and Xception architectures. ### Tech stack: Jupyter Notebook ### Why it matters: This project provides a comprehensive analysis of various CNN models and techniques for skin lesion classification, demonstrating the impact of configurations and transfer learning on model performance. The use of HAM10000 dataset and detailed metrics extraction ensures a thorough evaluation of the models' effectiveness.