AI Trending

Project directory

Projects

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

C# 6 stars

thijse/LLMJson

Library to facilitate sharing json models with LLMs in C-sharp

Overview: LLMJson is a C# library designed to facilitate the sharing and interpretation of JSON models with Large Language Models (LLMs). It aims to address the limitations of LLMs in generating well-formed JSON, making it easier for developers to integrate LLMs into their applications. Key features: - Serializes and generates descriptions for JSON values. - Handles parsing of up to 2GB of JSON files. - Supports parsing of abstract classes and interfaces. - Provides robust handling of field values, including non-standard formats. - Offers special property wrappers for runtime manipulation of fields. Tech stack: C# Why it matters: LLMJson simplifies the process of integrating LLMs into applications by providing a way to serialize and interpret JSON models, making it easier for developers to leverage the capabilities of LLMs in their projects.
Python 6 stars

tsotchke/tensorcore

CUDA-equivalent tensor-core acceleration for Apple Silicon. C-ABI kernel library wrapping simdgroup_matrix (M1+) and mpp::tensor_ops (M5+): GEMM, FlashAttention, Conv2D, Q4_0/Q8_0 quantized inference, GGUF reader, full transformer training kernels. One binary, M1 → M5.

Overview: `tensorcore` is a software layer designed to bridge the gap between Metal GPUs and traditional CUDA hardware, enabling efficient tensor operations on Apple Silicon. It provides a CUDA-equivalent library that simplifies the development of AI models. Key features: - `tc_gemm` for matrix operations - `tc_attention_*` for attention mechanisms - `tc_conv2d_*` for convolutional layers - `tc_rmsnorm / RoPE` for normalization - `tc_swiglu / softmax / AdamW` for activation functions - `tc_gemv_quantized` for quantized inference - `tc_gguf_*` for GGUF reader - `tc_allreduce / broadcast / allgather` for communication primitives Tech stack: Python Why it matters: By providing a seamless integration between Metal GPUs and traditional CUDA hardware, `tensorcore` enables teams to leverage the full potential of Apple Silicon for training large AI models, reducing the need for expensive hardware upgrades and improving overall efficiency. Repository: tsotchke/tensorcore GitHub stars: 6 GitHub description: CUDA-equivalent tensor-core acceleration for Apple Silicon. C-ABI kernel library wrapping simdgroup_matrix (M1+) and mpp::tensor_ops (M5+): GEMM, FlashAttention, Conv2D, Q4_0/Q8_0 quantized inference, GGUF reader, full transformer training kernels. One binary, M1 → M5.
Jupyter Notebook 6 stars

ttop32/jpn_vert_traineddata

tesseract jpn_vert traineddata fintune

Overview: This project fine-tunes the Tesseract Japanese vertical (jpn_vert) model with 16 types of Japanese fonts to achieve a BCER (Best Character Error Rate) of 1% while improving text segmentation performance. Key features: - Fine-tuned Tesseract jpn_vert model with 16 Japanese fonts - Achieved BCER of 1% after fine-tuning - Improved text segmentation performance Tech stack: Jupyter Notebook Why it matters: This fine-tuning process enhances the accuracy and segmentation capabilities of the Tesseract Japanese vertical model, making it more suitable for Japanese vertical text recognition tasks.
Python 6 stars

vikrant-project/vikrant-OBLITERATUS

⚡ Advanced AI iteration framework featuring an 8-stage pipeline, automated fine-tuning, voice interaction, and security scanning.

Overview: vikrant-OBLITERATUS is an advanced AI iteration framework that features an 8-stage pipeline, automated fine-tuning, voice interaction, and security scanning. Key features: - Auto Fine-Tuning: Post-abliteration LoRA adapter recovers 89% of lost coherence. - Voice Pipeline: Transcribes audio input for abliteration and synthesizes output. - Real-Time Sessions: Live WebSocket sessions for collaborative research. - Dark Web Scanner: Cryptographic fingerprinting to detect adversarially modified models. Tech stack: Python. Why it matters: This framework provides a comprehensive solution for removing refusal mechanisms from large language models, ensuring production-grade model liberation with enhanced capabilities and security measures. Repository: vikrant-project/vikrant-OBLITERATUS Primary language: Python GitHub stars: 6 GitHub description: ⚡ Advanced AI iteration framework featuring an 8-stage pipeline, automated fine-tuning, voice interaction, and security scanning.
Python 6 stars

vishvaRam/Fine-Tuning-Siglip2-Vit-Model

This repository offers tools and guidance for fine-tuning the Siglip2 Vision Transformer (ViT) model. It includes scripts and best practices to adapt the model for custom datasets and tasks. Designed for researchers and developers, it ensures efficient fine-tuning and optimal performance for vision-based applicatio

Overview: This repository provides tools and guidance for fine-tuning the Siglip2 Vision Transformer (ViT) model, including scripts and best practices for adapting the model to custom datasets and tasks. It is designed for researchers and developers aiming for efficient fine-tuning and optimal performance in vision-based applications. Key features: - Fine-tuning scripts for ViT models - Adaptation of ViT models for custom datasets - Best practices for efficient fine-tuning Tech stack: Python Why it matters: This repository offers practical solutions for researchers and developers looking to enhance the performance of vision-based applications by fine-tuning the Siglip2 ViT model.
TypeScript 6 stars

waldekmastykarz/atifact

Turn HAR files, Claude Code, Copilot CLI, and Codex CLI logs into standardized ATIF v1.8 trajectory JSON — ready for debugging, visualization, fine-tuning, and RL pipelines.

Overview: atifact is a command-line tool that converts various agent logs into standardized ATIF trajectories, making it easier to debug, visualize, and fine-tune AI agent models. Key features: - Converts HAR files - Converts Claude Code logs - Converts Copilot CLI logs - Converts Codex CLI logs - Automatically detects and converts Vally Trajectory objects Tech stack: TypeScript Why it matters: atifact simplifies the process of extracting and standardizing agent logs, making it easier to work with and analyze AI agent trajectories for debugging, visualization, and fine-tuning purposes. Repository: waldekmastykarz/atifact Primary language: TypeScript GitHub stars: 6 GitHub description: Turn HAR files, Claude Code, Copilot CLI, and Codex CLI logs into standardized ATIF v1.8 trajectory JSON — ready for debugging, visualization, fine-tuning, and RL pipelines.
Python 6 stars

zamax14/Laya-Finetune

Fine-tune Laya, the open System One decision model, for any typed-decision task: synthetic data, RLCD, calibration and long context.

### Overview: Laya Finetune is a powerful tool for fine-tuning Laya, the open System One decision model, to perform any typed-decision task. It simplifies the process by providing a simple CLI and Python API, allowing users to quickly and efficiently fine-tune Laya for their specific needs. ### Key Features: - **Generate:** The answers are chosen first, and an LLM writes a text that has them. - **Verify:** A second LLM is used to verify the labels, ensuring accuracy. - **Train:** The model is trained with RLCD and calibrated to provide confidence scores. - **Calibrate:** The confidence is calibrated to improve accuracy. - **Grow Context:** The context is expanded up to 32k tokens, making it suitable for long decision-making tasks. ### Tech Stack: - **Python:** The primary programming language used for development and fine-tuning. ### Why It Matters: Laya Finetune simplifies the process of fine-tuning Laya, making it accessible to developers who want to leverage the decision model for their specific tasks. By providing a simple CLI and Python API, it reduces the learning curve and speeds up the fine-tuning process, making it an ideal solution for developers looking to improve the performance of their decision models.
Shell 6 stars

zeeb0tt/runpod-llm

Runpod-LLM provides ready-to-use container scripts for running large language models (LLMs) easily on RunPod.

Overview: Runpod-LLM provides a simple and efficient way to deploy large language models (LLMs) on RunPod, making it easy to use without needing deep knowledge of containerization or backend selection. Key features: - Easy Setup: Quick deployment using Docker images. - Flexible: Supports both Ollama and llama.cpp backends. - RunPod Modes: Choose between serverless and POD modes. Tech stack: Shell Why it matters: This tool simplifies the process of integrating LLMs into production environments, making it accessible for developers without extensive technical expertise.
Rust 6 stars

zenlm/engine

High-performance inference engine — Rust/MLX/GGUF

Overview: A high-performance inference engine built with Rust, MLX, and GGUF for efficient model deployment. Key features: - High-performance inference - Rust-based engine - Supports MLX and GGUF formats Tech stack: Rust Why it matters: This engine is optimized for fast model deployment, making it ideal for applications requiring real-time inference capabilities.
JavaScript 5 stars

AI-First-Community/Bodhi

An open, interactive knowledge graph of modern AI — 123 concepts from tokens & attention to LoRA, DPO, reasoning models, and agents, with typed connections. Fully offline, zero dependencies. Built on the Open Knowledge Format.

### Overview: Bodhi Map is an open, interactive knowledge graph of modern AI concepts, providing a comprehensive overview of 128 concepts from tokens & attention to LoRA, DPO, reasoning models, and agents. It is fully offline and zero dependencies, built on the Open Knowledge Format, making it accessible and easy to navigate. ### Key Features: - **Concepts Overview**: 128 concepts categorized into 12 clusters. - **Interactive Graph**: Nodes represent techniques, and edges represent connections and relationships. - **Type-Specific Edges**: Edges are labeled with types to indicate the nature of the connection. - **Fully Offline**: No internet required, perfect for offline use. - **Zero Dependencies**: No external libraries needed, making it lightweight and easy to install. ### Tech Stack: - JavaScript ### Why It Matters: - **Connections Between Techniques**: Understand how different AI techniques build upon each other and when to use them. - **Navigable Landscape**: A single, interactive graph that shows the entire landscape of modern AI. - **Self-Learning Tool**: Ideal for anyone learning or building with modern AI, including students, engineers, and educators. - **MIT-Licensed**: Open-source, MIT-licensed, ensuring freedom to use, modify, and share the project. ### Repository: - **AI-First-Community/Bodhi** - **Primary Language**: JavaScript - **GitHub Stars**: 5 ### See It In Action: - **Live App**: Explore concepts and their connections, search or click any node to see its relationships
Python 5 stars

AbdelStark/exitreceipt

Did the agent actually finish? Inspectable GLiNER2.5-Decide fine-tuning on task completion and evidence spans.

### Overview: ExitReceipt is a tool designed to evaluate the completeness of an agent's actions by comparing them against the evidence left behind. It uses GLiNER2.5-Decide for a yes/no decision and candidate evidence spans, fine-tuning a LoRA adapter to improve accuracy and detect missed completions. ### Key Features: - **GLiNER2.5-Decide Integration**: Uses GLiNER2.5-Decide for decision-making and evidence span analysis. - **LoRA Adapter Fine-Tuning**: The selected LoRA adapter is fine-tuned to improve accuracy and detect missed completions. - **Pairwise Comparison**: Evaluates the correctness of the agent's actions against the evidence left behind. - **External Test**: The tool is tested on 590 paired WorkBench tasks, including 158 runs across 79 tasks and 10 templates unseen during training. ### Tech Stack: - **Python**: The primary language used for development and evaluation. ### Why It Matters: ExitReceipt provides a way to objectively assess whether an agent has completed its task correctly by comparing its actions against the evidence it left behind. This is particularly useful in scenarios where the agent's output is not immediately clear, such as in complex decision-making processes. The tool's ability to detect missed completions and false positives can help in identifying and improving the agent's performance.
Python 5 stars

Ahghaffari/redditpersona

RedditPersona: Modular pipeline for community-conditioned LLM adaptation from Reddit

### Overview: RedditPersona is a modular pipeline designed for community-conditioned LLM adaptation from Reddit, focusing on training parameter-efficient LoRA adapters for different community grouping strategies. It collects Reddit data, builds structured user profiles, partitions users into five strategies, and evaluates the performance of each strategy on generation quality and persona fidelity metrics. ### Key features: - **Data Collection**: Collects Reddit data using AsyncPRAW. - **User Profiling**: Builds structured profiles and text corpora per active user. - **Community Grouping**: Orchestrates five interchangeable strategies for community partitioning. - **LLM Adaptation**: Fine-tunes a parameter-efficient LoRA adapter per strategy using QLoRA. - **Evaluation Metrics**: Evaluates each adapter on fluency, diversity, semantic fidelity, distributional alignment, and community identifiability. ### Tech stack: Python ### Why it matters: RedditPersona provides a systematic approach to community-conditioned LLM adaptation, ensuring that the model's output aligns with the characteristics of the communities it was trained on, thereby improving its relevance and effectiveness in real-world applications.
Python 5 stars

Alessio-Siciliano/Incremental-Learning-iCarl

Overview: This project is a Python implementation of iCaRL, a method for incremental learning and representation learning. It is based on the paper "Incremental Classifier and Representation Learning" by the authors. Key features: - Reproduces the results from the paper. - Contains two new proposals to improve accuracy. Tech stack: Python, PyTorch v1.5.0. Why it matters: This project is a valuable resource for developers looking to improve their understanding of incremental learning and representation learning techniques.
Jupyter Notebook 5 stars

AlexandreSajus/Intent-Classification

A benchmark of different approaches on the task of Intent Classification

Overview: This repository contains a benchmark of various approaches on the task of Intent Classification using the Silicone MapTask dataset. Key features: - Human Level Performance - Training from Scratch (LSTM) - Fine-Tuning (BERT) - Prompting (GPT-4) Tech stack: Jupyter Notebook Why it matters: This benchmark highlights the performance differences between different models and provides insights into the challenges of Intent Classification, particularly in the context of the Silicone MapTask dataset.
Python 5 stars

Amir-Mohseni/Whisper-Persian

A short repo for fine-tuning whisper on transcription tasks in different languages. With guides on quantizing and inferencing the model using gradio.

Overview: This repository provides a comprehensive guide for fine-tuning and deploying a Whisper model for Persian speech recognition. It includes detailed instructions on training the model, quantizing it for efficient local inference, and deploying it using Gradio. Key features: - Fine-tuning Whisper model on the FLEURS Farsi dataset - Quantizing the model for improved performance and reduced memory usage - Deploying the model using Gradio for easy access and integration Tech stack: Python Why it matters: This repository offers a practical solution for developers looking to enhance their speech recognition capabilities in Persian, making it accessible for local deployment and integration with other applications.
Unknown 5 stars

Anil-matcha/LoRA-Trainer-API

Compare Muapi LoRA trainer APIs with runnable examples

### Overview: This repository provides a comprehensive guide for developers to train image-generation LoRA adapters using Muapi's unified API. It offers practical examples and documentation for choosing a trainer, preparing datasets, submitting training jobs, and polling results. The repository includes comparisons between different trainers and detailed notes on dataset preparation, trigger words, and training parameters. ### Key Features: - **Trainer Comparison**: A table comparing various LoRA trainers, including FLUX, Qwen-Image, and Z-Image. - **Dataset Preparation**: Instructions on how to prepare datasets for training. - **Training Parameters**: Detailed notes on how to configure training steps, learning rates, LoRA ranks, and trigger words. - **API Examples**: Practical examples using `curl` and Python to submit training jobs and poll results. - **Pricing and Availability**: Information on pricing and availability, with the source of truth being the live Muapi page. ### Tech Stack: The repository uses Python and `curl` for its examples and documentation. ### Why it Matters: This repository is essential for developers looking to integrate image-generation LoRA adapters into their projects, providing a clear and practical guide through the training process.
Jupyter Notebook 5 stars

Arjun-08/Sequence-to-sequence-networks-for-multi-text-document-summarization

This repository explores the use of advanced sequence-to-sequence networks and transformer models, such as BERT, BART, PEGASUS, and T5, for summarizing multi-text documents in the medical domain. It leverages extensive datasets like CORD-19 and a Biomedical Abstracts dataset from Hugging Face to fine-tune these models.

Overview: This project explores the application of advanced sequence-to-sequence networks and transformer models, such as BART, BERT, PEGASUS, and T5, for summarizing multi-text documents in the medical domain. It leverages extensive datasets like CORD-19 and a Biomedical Abstracts dataset from Hugging Face to fine-tune these models. Key features: - Fine-tuning of transformer models on biomedical datasets - Evaluation using ROUGE metrics - Implementation of BART, BERT, PEGASUS, and T5 models Tech stack: Jupyter Notebook Why it matters: This project showcases the potential of transformer models in efficiently summarizing medical literature, which is crucial for healthcare professionals, researchers, and policymakers dealing with the exponential growth of medical research articles. GitHub stars: 5 Repository: Arjun-08/Sequence-to-sequence-networks-for-multi-text-document-summarization
Jupyter Notebook 5 stars

Assaoka/Guide-to-Advanced-LLM-Techniques

Este repositório é um tutorial completo e prático que explora metodologias avançadas para a classificação de sentimentos e emoções em textos, utilizando Modelos de Linguagem de Grande Porte (LLMs). O projeto foi desenvolvido para ser acessível, com todos os exemplos executáveis em ambientes gratuitos como o Google Colab.

### Overview: Este repositório é um tutorial completo e prático que explora metodologias avançadas para a classificação de sentimentos e emoções em textos, utilizando Modelos de Linguagem de Grande Porte (LLMs). O projeto foi desenvolvido para ser acessível, com todos os exemplos executáveis em ambientes gratuitos como o Google Colab. ### Key features: - Implementação de Engenharia de Prompt (Zero-Shot, Few-Shot, Chain-of-Thought) - Fine-Tuning eficiente com QLoRA - Destilação de Conhecimento para criar modelos menores - Ensembles de LLMs: Votação Majoritária e Negociação entre modelos ### Tech stack: Jupyter Notebook ### Why it matters: Este guia oferece uma visão clara e progressiva sobre técnicas avançadas para classificação de sentimentos em textos, utilizando Modelos de Linguagem de Grande Porte (LLMs). O uso de exemplos executáveis no Google Colab torna o conteúdo acessível e fácil de implementar em projetos reais.
Python 5 stars

BennedictQuanTon/LLM-Safety-Fine-Tuning

QLoRA fine-tuning of Qwen2.5-3B for prompt-injection robustness, grounded answering and strict JSON, plus a jailbreak classifier ensemble (DeBERTa-v3 + Qwen QLoRA, 0.991 hold-out ROC-AUC). Runs entirely on free Kaggle T4 GPUs, with training-health diagnostics and run benchmarking.

### Overview: This project focuses on fine-tuning a small instruction-tuned LLM (Qwen2.5-3B) using QLoRA for robustness against prompt injection and jailbreaks, while ensuring grounded answering and strict JSON formatting. The pipeline is designed to run efficiently on free Kaggle T4 GPUs, with built-in diagnostics and benchmarking capabilities. ### Key features: - **Prompt Injection Robustness**: Improves instruction following and output formatting. - **Jailbreak Classifiers**: Detects and mitigates prompt injection and jailbreaks. - **Grounded Answering**: Ensures answers are only based on the provided context. - **Training on Free GPUs**: Runs entirely on free Kaggle T4 GPUs, with diagnostics and benchmarking. ### Tech stack: Python ### Why it matters: This project is crucial for enhancing the safety and robustness of language models, particularly in applications where security and accuracy are paramount. The use of QLoRA fine-tuning ensures that the model remains adaptable and reliable, even under adversarial conditions, thereby improving overall user trust and satisfaction. ### Repository: - **Repository**: BennedictQuanTon/LLM-Safety-Fine-Tuning - **Stars**: 5 - **Description**: A reproducible, notebook-based pipeline for parameter-efficient supervised fine-tuning of small instruction-tuned LLMs on a single free GPU (Kaggle Tesla T4, 16 GB), with built-in training-health diagnostics and multi-run benchmarking.