Awesome GitHub RepositoriesInference Batching

Ce projet est un service d'intégration BERT haute performance et un serveur d'inférence conçu pour mapper des séquences de texte en vecteurs numériques de longueur fixe. Il fonctionne comme un microservice d'apprentissage automatique et un serveur de modèle distribué qui découple la gestion des requêtes du calcul lourd. Le système utilise une infrastructure de messagerie ZeroMQ pour fournir une communication à faible latence entre les clients distribués et le serveur d'inférence. Il incorpore le traitement par lots côté serveur et la mise à l'échelle de la charge de travail GPU pour maximiser l'utilisation du matériel et gérer des volumes de requêtes élevés. La plateforme prend en charge l'infrastructure de recherche sémantique en générant des intégrations transmodales pour le texte et les images au sein d'un espace vectoriel partagé. Cela permet la recherche transmodale, le classement de la pertinence du contenu et le reclassement des résultats basés sur l'alignement sémantique entre le contenu visuel et les descriptions textuelles. Le service peut être déployé en tant que microservice élastique accessible via les protocoles gRPC, HTTP ou WebSocket, avec un streaming duplex non bloquant pour gérer de grands ensembles de données.

StreamDiffusion is an interactive generative AI framework and inference engine designed for the low-latency delivery of image and video streams. It provides a real-time Stable Diffusion pipeline for text-to-image and image-to-image generation, enabling the creation of continuous generative image streams with minimized computational delay. The framework optimizes throughput using a pre-computed cache engine and residual-based guidance approximation to reduce the number of required model passes. It further manages GPU load through similarity-based frame skipping, which avoids redundant computat

FlexLLMGen is an inference engine and runtime designed to run large language models on a single GPU by combining weight compression with tensor offloading. It reduces model weight memory usage by approximately 70% through 4-bit quantization, and stores model parameters, attention cache, and hidden states across GPU, CPU, and disk to fit models larger than available GPU memory. The project distinguishes itself through a throughput-oriented batching approach that processes multiple generation requests together in large batches to maximize throughput on a single GPU. It also supports distributed

This project is an AI singing voice conversion system and vocal processor used for training generative voice models and converting vocal recordings or live input into a target voice. It functions as a VITS model trainer and a real-time voice changer that transforms vocal timbre and pitch to change the identity of a singer. The system provides a graphical management dashboard for controlling training hyperparameters and voice conversion presets. It supports low-latency audio streaming for live microphone input and employs pitch estimation to ensure precise matching between source and target vo

KServe is a Kubernetes-native platform for deploying and serving machine learning models as scalable inference services. It supports both generative AI models, including large language models, and traditional predictive models from frameworks such as TensorFlow, PyTorch, Scikit-Learn, XGBoost, and ONNX. The platform manages the full lifecycle of model deployments, including revision tracking, canary rollouts, A/B testing, and automatic rollbacks, and provides serverless scale-to-zero capabilities for cost-efficient resource management. KServe distinguishes itself through a standardized infere

KServe is an open platform for deploying and serving generative and predictive AI models on Kubernetes. It defines inference services as custom resources with declarative YAML specifications, enabling a Kubernetes-native approach to model deployment and lifecycle management. The platform leverages Knative-based serverless scaling for automatic scale-to-zero and revision management, and supports a pluggable serving runtime architecture that maps model formats to containerized execution environments. KServe distinguishes itself through model-aware autoscaling that scales replicas based on token

Ce projet est un guide architectural MLOps et un framework pour concevoir et déployer des systèmes d'apprentissage profond dans des environnements de production. Il fournit une approche structurée pour le déploiement de l'inférence de modèles, l'orchestration de pipelines ML et la création d'architectures de machine learning de niveau production. Le projet se distingue par un accent mis sur l'apprentissage profond distribué et l'IA en périphérie (edge AI). Il couvre des méthodologies pour paralléliser l'entraînement des modèles sur plusieurs GPU afin de gérer de grands jeux de données et applique des techniques comme la quantification et la distillation pour réduire la taille des modèles pour le matériel embarqué. La surface de capacité s'étend à la surveillance et à l'observabilité, incluant le suivi de la performance des modèles, la dérive des données et les métriques d'expérience. Il aborde également l'orchestration des flux de travail de données, le versionnage des jeux de données via des magasins d'objets, et la gestion des requêtes d'inférence à haut volume en utilisant le traitement par lots adaptatif et l'orchestration basée sur des conteneurs.

exllamav2 is a high-performance inference library designed for running large language models locally on consumer-grade GPUs. It provides a GPU-accelerated runner and quantization tools to enable model execution without reliance on cloud-based computing services. The project features a quantization utility that compresses models into mixed bitrates between two and eight bits to reduce video RAM requirements. It distinguishes itself through a batched text generator that handles grouped requests and deduplicates cache data to increase throughput. The library covers a broad capability surface in

exllamav2 is a high-performance inference engine and framework for executing large language models locally on consumer-class GPUs. It provides a complete system for local model deployment, including a specialized inference engine and tools for model quantization. The project features a multi-GPU inference framework that distributes workloads across multiple graphics cards to run models that exceed the memory capacity of a single device. It includes a GPU model quantizer capable of converting models into mixed-precision formats between 2 and 8 bits to balance memory usage and accuracy. The en

Ce projet est un framework de service de modèles PyTorch conçu pour déployer et mettre à l'échelle des modèles de machine learning en production via des endpoints réseau évolutifs. Il fonctionne comme un serveur d'inférence haute performance, un optimiseur et un gestionnaire de cycle de vie de modèle qui gère le chargement des modèles, le batching des requêtes et l'accélération matérielle. Le système se distingue par des capacités avancées d'orchestration et d'optimisation, telles que le chaînage de plusieurs modèles dans des workflows séquentiels utilisant des graphes d'exécution et l'utilisation du batching dynamique pour améliorer le débit et la latence. Il offre un support spécialisé pour l'IA générative et les grands modèles de langage (LLM) grâce au batching continu et au parallélisme de tenseurs. Les domaines de capacités étendus incluent la gestion des ressources GPU sur divers matériels comme NVIDIA, AMD et Apple Silicon, ainsi qu'une gestion complète du cycle de vie des modèles pour l'enregistrement, le versioning et la mise à l'échelle des workers. Il intègre également des outils d'observabilité pour suivre la santé du système et les performances des modèles via des métriques compatibles Prometheus. Le serveur est géré via une interface de ligne de commande utilisée pour le contrôle du cycle de vie et la configuration des paramètres d'exécution.

tiny-llm est un moteur d'inférence de grands modèles de langage et une implémentation de modèle transformer. Il sert de runtime pour modèles quantifiés et de gestionnaire de cache clé-valeur paginé, fournissant une pile d'inférence spécialisée optimisée pour Apple Silicon. Le système se distingue par des techniques d'exécution à haut débit, incluant le batching continu et l'attention paginée. Il utilise un système de mémoire paginée pour éliminer la fragmentation lors de la génération de jetons et emploie une déquantification à la volée des poids compressés pour réduire l'empreinte mémoire lors de la multiplication matricielle. Le projet couvre un large éventail de capacités d'architecture de modèle et de performance, telles que le routage par mélange d'experts (MoE), l'attention par groupes de requêtes (GQA) et l'attention flash. Il inclut la prise en charge d'une logique de décodage avancée, incluant le décodage glouton (greedy) et l'échantillonnage via des méthodes de température, top-k et top-p. L'implémentation est écrite en Python et inclut des noyaux bas niveau personnalisés pour accélérer le traitement des tenseurs sur le matériel.

LitServe est un framework de serveur d'inférence IA Python et un framework de service LLM conçu pour l'inférence à haute concurrence. Il fonctionne comme un serveur de modèle IA distribué et un moteur d'inférence à traitement par lots dynamique, fournissant les outils pour construire et héberger des serveurs personnalisés qui exécutent des modèles IA. Le framework se distingue par une file d'attente de requêtes à traitement par lots dynamique qui regroupe les requêtes d'inférence individuelles en tenseurs uniques pour maximiser le débit GPU. Il prend en charge la mise à l'échelle GPU distribuée, permettant aux charges de travail des modèles d'être réparties sur plusieurs accélérateurs matériels pour équilibrer les charges de calcul et augmenter la capacité totale. Le système fournit une interface wrapper de haut niveau qui découple le prétraitement et le post-traitement des requêtes de la logique d'exécution du modèle principal. Il inclut également des capacités pour le streaming de modèles en temps réel afin de fournir des sorties de manière incrémentale et utilise une boucle d'événements asynchrone pour gérer les requêtes réseau concurrentes.

LightLLM is a high-performance serving framework for deploying and executing large language models. It functions as a multi-GPU inference engine and server capable of handling dense architectures, mixture-of-experts designs, and multimodal models that process both text and images. The system is distinguished by its specialized support for Mixture-of-Experts models using expert parallelism and fused kernels. It implements structured text generation through deterministic state machines and pushdown automata to enforce precise output formats. To optimize throughput, the framework employs specula

WhisperLive is a real-time speech-to-text server that converts live audio streams into text using Whisper models. It functions as a backend service that receives microphone input via WebSockets and provides incremental transcriptions with word-level timestamps. The system utilizes a GPU-accelerated inference engine and a keyword-boosted transcription API to improve the recognition accuracy of domain-specific jargon, acronyms, and product names. It also includes a speaker diarization tool that clusters audio embeddings to identify and label different participants within a recording. Additiona

Lorax is a GPU-accelerated inference server and multi-adapter engine designed for serving large language models. It functions as a high-throughput system capable of deploying models via Kubernetes and managing the dynamic swapping of Low-Rank Adaptation adapters per request. The server distinguishes itself through multi-adapter dynamic batching, which allows requests using different adapter weights to be processed in a single GPU forward pass. It employs just-in-time adapter loading and weighted adapter merging to maximize throughput and enable multi-tasking without sacrificing performance.

mini-sglang is a collection of tools for large language model inference, serving as an OpenAI-compatible inference server, a memory-efficient prefill engine, and a tensor parallelism runtime. It also functions as a local batch processing engine for offline benchmarking and ablation studies. The project focuses on acceleration and memory management through a KV cache manager that reuses precomputed caches for shared request prefixes. It handles large model workloads by distributing tasks across multiple GPUs and manages peak memory consumption by splitting long input sequences into smaller chu

llm-d is a distributed serving framework designed for large language model inference. It functions as an inference orchestrator and gateway, providing a control plane for deploying model replicas and managing hardware accelerators. The system includes a batch inference scheduler and a cache manager to coordinate request flow and memory utilization. The project is distinguished by a disaggregated serving architecture that separates prefill and decode execution phases across specialized workers to maximize throughput. It employs a hardware-agnostic control plane and tiered cache offloading, mov