AI Trending

Project directory

Projects

Open-source AI projects tracked by the leaderboard, ordered by GitHub stars.

Python 6 stars

IonDen/mlx-train-perf

Fused, logit-free linear-cross-entropy loss, RAM-fit planner, and benchmark harness for MLX fine-tuning on Apple Silicon

Overview: `mlx-train-perf` is a set of tools designed to fine-tune models on Apple Silicon with reduced memory usage, improved performance, and a planner for RAM availability. Key features: - Fused, logit-free linear-cross-entropy loss - Sequence packing for short examples - Flash-attention training path for long sequences Tech stack: Python Why it matters: By optimizing memory usage and providing a planner for RAM availability, `mlx-train-perf` allows for more efficient fine-tuning of models on Apple Silicon, potentially reducing training times and improving overall performance.
Jupyter Notebook 6 stars

Jacob12138xieyuan/Hand-gesture-controled-Arduino-car-using-machine-learning-model

Overview: This project demonstrates how to use pre-trained machine learning models, specifically VGG16, to create a robust model for hand gesture-controlled car control. The project includes detailed steps on creating a dataset, training a customized model, and integrating a user interface for real-time recognition. Key features: - Creating a dataset for training - Training a customized model using VGG16 - Implementing a user interface for hand gesture recognition - Integrating an Arduino board for Bluetooth and motor control Tech stack: Keras, VGG16, Python, Jupyter Notebook Why it matters: This project showcases the practical application of pre-trained models in machine learning, demonstrating how to leverage professional models for robust training with limited data. It provides a clear example of integrating machine learning with hardware control, making it useful for developers looking to create interactive and autonomous systems.
Python 6 stars

Joonsun-Hwang/clm-train

Training HuggingFace's CLMs with Accelerate

### Overview: This project provides a comprehensive guide for fine-tuning HuggingFace's CLMs (Large Language Models) using Accelerate and PEFT (Performance Efficient Fine-Tuning). It includes detailed installation instructions, configuration options, and examples for both multi-GPU data parallel and DeepSpeed training. The project also offers inference capabilities for evaluating the trained models. ### Key Features: - Multi-GPU Data Parallel Training - DeepSpeed Fine-Tuning - TPU Configuration for Accelerate - Input Data Preparation and Loading - Fine-Tuning and Inference Scripts ### Tech Stack: - Python ### Why it Matters: This project serves as a practical guide for developers looking to fine-tune HuggingFace's CLMs efficiently, leveraging the latest advancements in training models with Accelerate and PEFT. The project includes detailed installation steps, configuration options, and examples, making it a valuable resource for anyone interested in improving the performance and efficiency of their language models.
HTML 6 stars

KaiFelixBennett/RadeonForge

Fine-tune your own LLM on an AMD Radeon GPU — the easy, tested way. QLoRA via ROCm on Windows/WSL2 & Linux, a worked Gemma-4 example, a reusable live training dashboard, and a smoke test that proves the loss falls.

Overview: Fine-tune your own language model (LLM) on an AMD Radeon GPU using the RadeonForge project, a tested and easy-to-follow path that includes a smoke test and a reusable live training dashboard. Key features: - Fine-tune your own LLM on an AMD Radeon GPU - A tested path from a blank machine to a model - A smoke test to prove your GPU can train before fine-tuning - A production-quality live training dashboard - A reusable Python file for your own model training - Consistent training output with valid JSON Tech stack: Python 3.12, ROCm 7.2, Windows/WSL2, Linux Why it matters: Fine-tuning allows you to train your own LLM reliably and efficiently, ensuring your model's behavior is baked into the weights, making it perform reliably. It's cheaper, faster, and runs offline, ensuring data sovereignty. The smoke test proves your GPU can train before fine-tuning, making the process straightforward.
Python 6 stars

KenyonY/dtflow

Inspect, clean, transform and ship LLM training data from one CLI; dt view is the interactive entry point.

### Overview: dtflow is a command-line tool designed to inspect, clean, transform, and ship large language model (LLM) training data from a single command line interface. It provides an interactive entry point called `dt view` that allows users to explore, filter, and transform data in real-time. ### Key Features: - **Interactive Entry Point:** `dt view` provides an interactive interface to explore and manipulate LLM training data. - **CLI Interface:** dtflow operates on a terminal, making it accessible from any command line environment. - **Data Formats Support:** Supports JSONL, NDJSON, JSON, CSV/TSV, Parquet, Arrow, and Excel files. - **Schema Inspection:** Provides a schema for JSONL files, including types, null rates, and value distributions. - **Filtering and Sorting:** Filters and sorts data based on various criteria, such as turns, roles, and specific search queries. - **Conversion Presets:** Converts data between different formats, including OpenAI Chat, ShareGPT, Alpaca, and DPO. - **Export Options:** Supports exporting data in various formats, including OpenAI messages, and allows for easy sharing with tools like ShareGPT, Alpaca, and DPO. - **Pythonic API:** All commands accept `-` for stdin and write to stdout, allowing for easy chaining and composition. - **Language Independence:** The interface is in English, and `dt lang zh` can be used to switch to Chinese. ### Tech Stack: - **Python:** The primary language used for development and
Python 6 stars

KleinYuan/tf-ft

Implementation on tensorflow fine tuning of generic CNN based model

Overview: This project involves fine-tuning generic CNN-based models, such as AlexNet, VGG-16, and others, using TensorFlow. It focuses on extending pre-trained models by freezing specific layers and connecting them with custom fully connected layers. Key features: - Fine-tuning generic CNN-based models - Extending pre-trained models by freezing specific layers - Connecting pre-trained layers with custom fully connected layers Tech stack: Python Why it matters: This project is valuable for developers looking to enhance pre-trained models by customizing them for specific tasks, making them more effective and efficient. Repository: KleinYuan/tf-ft Primary language: Python GitHub stars: 6 GitHub description: Implementation on TensorFlow fine tuning of generic CNN based models README excerpt: This project aims to fine-tune generic CNN-based models, such as AlexNet, VGG-16, and others, using TensorFlow. It focuses on extending pre-trained models by freezing specific layers and connecting them with custom fully connected layers. The project includes a detailed manual on how to set up the project, including downloading pre-trained weights and running the training process.
Python 6 stars

Lahdhirim/NLP-financial-question-answering-tool

Fine-tuning a text-to-text transformer model (T5) on a financial question answering dataset. Includes data preprocessing, training, evaluation pipelines, and a web app for inference built with Flask and Angular.

### Overview: This project demonstrates how to fine-tune a text-to-text model on a financial question answering dataset using the Hugging Face Transformers library. It provides a fully customizable pipeline for data preprocessing, model fine-tuning, evaluation, and serves model inference through a Flask-based web app. ### Key Features: - Fine-tuning of a text-to-text model (T5) on a financial dataset - Data preprocessing, model fine-tuning, and evaluation pipelines - Inference via a Flask-based web application ### Tech Stack: Python ### Why It Matters: The T5 architecture is chosen for its effectiveness in generative question answering tasks, making it ideal for tasks that demand coherent and contextually relevant natural language output. ### Repository: Lahdhirim/NLP-financial-question-answering-tool ### Primary Language: Python ### GitHub Stars: 6 ### GitHub Description: Fine-tuning a text-to-text transformer model (T5) on a financial question answering dataset. Includes data preprocessing, training, evaluation pipelines, and a web app for inference built with Flask and Angular.
Python 6 stars

LianHe-BI/Basic-Qwen-3B-SD-Prompt-SOUL-ARCHITECT-v2.0-DEMO

EN: An overfitted SD prompt engine with severe "aesthetic snobbery," forcibly transforming mundane ideas into professional-grade physical rendering instructions. CN: 一个具备“审美洁癖”的过拟合提示词引擎，强行将平庸构思纠偏为具备极致物理质感的工业级渲染指令。

Overview: SOUL_ARCHITECT_v2.0 is a cutting-edge digital rendering engine designed for developers, utilizing advanced AI techniques to transform mundane ideas into professional-grade physical renderings. This tool is built on NVIDIA Blackwell architecture, leveraging sparse computing and aggressive weight distribution to achieve unparalleled physical fidelity. Key features: - Fine-tuned physical parameter reconstruction focusing on Subsurface Scattering and Anisotropic Filtering. - Overcomes the "aesthetic snobbery" by training with a high loss of 0.47, ensuring that even low-fidelity concepts are rendered with extreme physical realism. - Utilizes native BF16 sparse computing for efficient use of GPU resources. Tech stack: Python Why it matters: SOUL_ARCHITECT_v2.0 offers unparalleled physical rendering capabilities, making it indispensable for developers looking to create high-quality, realistic renderings in a professional environment. Its ability to handle extreme weight distribution and physical parameter reconstruction sets it apart from other rendering tools, ensuring that even the most complex and detailed concepts are rendered with exceptional realism. Repository: LianHe-BI/Basic-Qwen-3B-SD-Prompt-SOUL-ARCHITECT-v2.0-DEMO Primary language: Python GitHub stars: 6 GitHub description: An overfitted SD prompt engine with severe "aesthetic snobbery," forcibly transforming mundane ideas into professional-grade physical rendering instructions.
Python 6 stars

MahmoudHussienMohamed/Agentic-Network-Monitoring

Agentic Network Monitoring: An autonomous multi-agent SOC system powered by fine-tuned local LLMs

### Overview: This project implements a Multi-Agent Network Security Monitoring System using a fine-tuned Llama 3.2-3B foundation model. It is designed to autonomously monitor private networks, detect security threats, and provide actionable response strategies. ### Key features: - **Observer Agent**: Monitors network traffic and detects anomalies. - **Responder Agent**: Provides immediate tactical mitigation and response plans. - **Consultant Agent**: Offers strategic long-term security analysis and policy recommendations. ### Tech stack: Parameter-Efficient Fine-Tuning (LoRA) ### Why it matters: This project leverages fine-tuning to create highly specialized agents, resulting in higher accuracy for specific tasks, operational efficiency, data privacy, and structured & consistent output.
Rust 6 stars

Metrale/metrale-inference

Carbon-friendly Pure Rust Inference Engine

Overview: Metrale-inference is a carbon-friendly Pure Rust Inference Engine designed for efficient and sustainable computation. Key features: - Energy-efficient operations - Zero carbon footprint - Rust language implementation Tech stack: Rust Why it matters: Metrale-inference is crucial for developers looking to build sustainable and energy-efficient applications, making it an essential tool for environmentally conscious projects.
Python 6 stars

MrAnayDongre/Inference-Kernels

LLM inference kernels from scratch in Triton: KV cache, FlashAttention, PagedAttention, RMSNorm, RoPE, SwiGLU, and benchmarks.

### Overview: This repository is a hands-on project that implements various LLM inference kernels from scratch, focusing on KV cache, FlashAttention, PagedAttention, RMSNorm, RoPE, SwiGLU, and continuous batching. The goal is to make the core mechanisms visible, runnable, benchmarkable, and explainable, providing insights into the mechanisms behind modern LLM inference systems. ### Key Features: - KV cache - Paged KV simulation - Triton fundamentals - Fused row/element kernels - FlashAttention - PagedAttention decode - Continuous batching - Quantization - Speculative decoding - Benchmarks ### Tech Stack: Python ### Why It Matters: This project aims to demystify the mechanisms behind modern LLM inference systems, making the core ideas visible, runnable, and benchmarkable. It provides a deeper understanding of how these systems work and can be improved.
Python 6 stars

Mrzhiyao/glm53-a800-vllm

Reproducible vLLM deployment for GLM-5.3-Flash on 8x NVIDIA A800 SM80 GPUs

Overview: This project provides a reproducible vLLM deployment for GLM-5.3-Flash on 8x NVIDIA A800 SM80 GPUs, including fixed source code baseline, SM80 integration patches, final coverage files, Docker build scripts, 1M context startup script, multi-modal configuration, and pressure tests. Key features: - Fixed source code baseline - SM80 integration patches - Final coverage files - Docker build scripts - 1M context startup script - Multi-modal configuration - Pressure tests Tech stack: Python Why it matters: This project offers a reliable and reproducible way to deploy GLM-5.3-Flash on NVIDIA A800 GPUs using vLLM, ensuring consistent performance and ease of deployment. GitHub stars: 6 Repository: Mrzhiyao/glm53-a800-vllm
Dart 6 stars

Msr7799/Atlas-AI

Cross-platform Flutter AI chat application for Android, Linux, and Windows. Features a fine-tuned agent capable of training other agents (like instructors) using Google's new A2A service.

### Overview Atlas AI is a sophisticated AI assistant application built with Flutter, featuring native Arabic language support and advanced conversational capabilities. The application integrates multiple AI models and provides a seamless, cross-platform experience with modern UI design and robust performance optimizations. ### Key Features - **Multi-Model AI Integration** - **Groq Models**: 10 different models including Llama 3.1, Mixtral, and Gemma - **GPTGod Service**: 17 advanced models with GPT-4 support - **Tavily Search**: Real-time web search integration - **Hugging Face**: Access to open-source models - **Local AI**: Offline model support - **Language Support** - **Native Arabic Support**: Full RTL layout and Arabic language processing - **Multi-language Interface**: English and Arabic UI - **Localized Content**: Context-aware responses in Arabic - **Modern User Interface** - **Material Design 3**: Modern, responsive design system - **Dark/Light Mode**: Dynamic theming with user preferences - **Cross-Platform**: Consistent experience across all platforms - **Accessibility**: Full accessibility support ### Tech Stack Flutter ### Why it Matters Atlas AI is designed to provide a powerful and intuitive AI assistant experience, making it an essential tool for developers and professionals alike. Its advanced features, seamless integration, and robust performance make it a valuable addition to any AI assistant toolkit.
JavaScript 6 stars

Naraku215/MD-chunker

a powerful Markdown chunking tool that understands document structure. Unlike naive token splitters, it protects atomic elements (code, math, tables), merges by semantic affinity, and scores chunk quality — ready for RAG and fine-tuning workflows.

### Overview: This project is a powerful Markdown chunking tool that intelligently protects atomic elements like code blocks, math formulas, tables, and lists, and scores each chunk based on quality dimensions. It is designed for RAG pipelines and LLM fine-tuning workflows. ### Key Features: - **Structure-Aware Chunking**: Parses heading hierarchy to build a document outline, then splits and merges sections intelligently. - **Atomic Element Protection**: Code fences, display/inline math, Markdown tables, HTML tables, and lists are replaced with placeholders before splitting, then restored. - **5-Dimension Quality Scoring**: Each chunk receives a 0-100 score based on length adequacy, heading presence, sentence completeness, atomic integrity, and content variety. - **Semantic Affinity Merging**: Short chunks are merged with their most semantically related neighbor using heading-path similarity. - **Context Preservation**: Sub-chunks receive a `> Context: Chapter > Section > Subsection` blockquote prefix when a section is split. - **Visual 3-Pane Workspace**: Upload, preview, edit, save, and export chunks through an intuitive web UI. - **Dual-Mode Usage**: Works both as a standalone web application and as an importable Node.js library function. - **Export Formats**: JSON and JSONL. - **i18n**: Full English and Simplified Chinese support with browser language auto-detection. - **No Database Required**: All storage is file-system based. ### Tech Stack: This project is built with Next.js 14 (App Router),
Python 6 stars

NazmulTakbir/FlexiCache

[MLSys-26] FlexiCache: Leveraging Temporal Stability of Attention Heads for Efficient KV Cache Management

Overview: FlexiCache is a hierarchical KV-cache management system designed to address the memory bottleneck in large language model serving, particularly in long-context and long-generation workloads. By leveraging temporal stability of attention heads, FlexiCache optimizes GPU memory usage, reduces attention computation and host-device transfer overhead, while maintaining model quality. Key features: - Hierarchical KV-cache placement - Periodic reranking for stable heads - Classification of heads as stable or unstable - Retention of full context in host memory for stable heads Tech stack: Python Why it matters: FlexiCache efficiently manages the KV cache in large language models, reducing memory usage and improving performance, especially in high-throughput scenarios, without compromising model accuracy.
Python 6 stars

NiLabs-Org/ladder

Ladder: small open models fine-tuned for competitive programming. QLoRA training + verifiable eval that runs on Kaggle/Colab GPUs.

Overview: Ladder is a small open model fine-tuning and evaluation pipeline designed for competitive programming, specifically targeting Codeforces-style problems. It leverages QLoRA training and runs on free GPUs, ensuring everything runs on Kaggle or Colab T4s, making it verifiable and adaptable for various environments. Key features: - Fine-tuning and evaluation pipeline for competitive programming - Verifiable evaluation without relying on another model's output or BLEU scores - Runs on free GPUs, excluding full fine-tuning, bf16, and flash-attention - Data consists of reasoning traces from Codeforces problems, decontaminated against benchmarks - Training uses 4-bit QLoRA on Qwen2.5-Coder-3B-Instruct - Eval generates a program and runs it against up to 20 test cases, reporting pass@k Tech stack: Python Why it matters: Ladder is crucial for developers looking to improve their skills in competitive programming, providing a reliable and verifiable method to fine-tune models for Codeforces-style problems without the need for expensive GPU resources. Repository: NiLabs-Org/ladder Primary language: Python GitHub stars: 6 GitHub description: Ladder: small open models fine-tuned for competitive programming. QLoRA training + verifiable eval that runs on Kaggle/Colab GPUs.
Python 6 stars

PRITHIVSAKTHIUR/StrangerAI

Turning Ideas to Product - StrangerAI - StrangerZone. Recommended to Deploy inside Huggingface Spaces SDK as GRADIO

Overview: StrangerAI is a conversational AI model designed to enhance user experience by providing personalized interactions. It leverages the power of HuggingFace Spaces SDK to create a seamless interface, making it ideal for developers looking to deploy AI solutions quickly. Key features: - Personalized Conversations: Tailored interactions based on user preferences and history. - Easy Deployment: Integrates seamlessly with HuggingFace Spaces SDK, ensuring quick deployment. - User-Friendly Interface: Utilizes GRadio for a smooth and intuitive experience. Tech stack: Python Why it matters: StrangerAI is a powerful tool for developers aiming to create AI-driven applications that can engage users effectively and efficiently. Repository: PRITHIVSAKTHIUR/StrangerAI Primary language: Python GitHub stars: 6 GitHub description: Turning Ideas to Product - StrangerAI - StrangerZone. Recommended to Deploy inside Huggingface Spaces SDK as GRADIO README excerpt: ![alt text](assets/9.png)
Python 6 stars

Podwarden/lm-warden

Your own OpenAI-compatible LLM API on your own NVIDIA GPUs. vLLM and llama.cpp behind one control plane, one port and a browser UI: pull models from Hugging Face, issue API keys with per-key usage, see what the GPUs are doing. Self-hosted with Docker Compose; nothing reports home.

### Overview: LM Warden is a self-hosted OpenAI-compatible language model API that leverages NVIDIA GPUs. It allows developers to access and manage large language models directly on their hardware, providing a controlled environment with per-key usage tracking and real-time GPU usage monitoring. ### Key Features: - **Self-Hosted with Docker Compose**: Runs on Linux and macOS with Docker, providing a secure and isolated environment. - **Control Plane**: Manages models and keys, ensuring per-key usage tracking and usage attribution. - **Model Lifecycle Management**: Tracks model lifecycles and ensures proper key minting and usage tracking. - **GPU Monitoring**: Real-time monitoring of GPU usage, power draw, and token consumption. - **API Gateway**: Provides a secure and isolated API gateway for developers to interact with the model. ### Tech Stack: - **Python**: The primary programming language used for development and deployment. - **Docker Compose**: Used for container orchestration and deployment. - **vLLM v0.32.0**: The underlying engine for language models. - **llama.cpp**: The model engine used for the API. ### Why It Matters: LM Warden simplifies the process of accessing and managing large language models, ensuring that developers can focus on their applications without worrying about the underlying infrastructure. It provides a controlled environment, per-key usage tracking, and real-time GPU monitoring, making it an ideal solution for developers looking to integrate language models into their projects. ### GitHub Metadata: - **Repository**: Podwarden/lm-warden - **Stars**:
Python 6 stars

Riccorl/ner-serve

Simple NER model using Docker, FastAPI, ONNX and Multilingual Mini-LM.

### Overview: A simple Natural Language Processing (NLP) model utilizing Docker, FastAPI, ONNX, and Multilingual Mini-LM. The model is designed for live applications and can be accessed through a Streamlit interface. ### Key Features: - **Model**: A Multilingual Mini-LM model optimized for NLP tasks. - **Technology Stack**: Docker, FastAPI, ONNX, and Multilingual Mini-LM. - **Environment Variables**: - `TIMEOUT`: Controls worker timeouts to prevent resource exhaustion. - `WORKERS_PER_CORE`: Determines the number of workers based on CPU cores. - `MAX_WORKERS`: Limits the number of simultaneous processes. - `LOG_LEVEL`: Configures the logging level for Gunicorn. ### Tech Stack: - Docker - FastAPI - ONNX - Multilingual Mini-LM ### Why It Matters: This model is optimized for real-time applications, making it suitable for live interfaces and ensuring efficient resource management. The use of Docker ensures portability and ease of deployment across different environments.