awesome-repositories.com
ब्लॉग
MCP
awesome-repositories.com

AI-संचालित खोज के साथ बेहतरीन ओपन-सोर्स रिपॉजिटरी खोजें।

एक्सप्लोर करेंक्यूरेटेड खोजेंओपन-सोर्स विकल्पसेल्फ-होस्टेड सॉफ्टवेयरब्लॉगसाइटमैप
प्रोजेक्टMCP सर्वरहमारे बारे मेंहम रैंकिंग कैसे करते हैंप्रेस
कानूनीगोपनीयताशर्तें
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·

13 रिपॉजिटरी

Awesome GitHub RepositoriesLow-Bit Weight Quantization

Converting model weights to low-bit precision formats like INT4 and FP8.

Distinct from Intel Hardware Acceleration: Focuses on weight quantization for AI models specifically, rather than general GPU video decoding acceleration.

Explore 13 awesome GitHub repositories matching devops & infrastructure · Low-Bit Weight Quantization. Refine with filters or upvote what's useful.

Awesome Low-Bit Weight Quantization GitHub Repositories

AI के साथ बेहतरीन रिपॉजिटरी खोजें।हम AI का उपयोग करके सबसे सटीक रिपॉजिटरी खोजेंगे।
  • fminference/flexllmgenFMInference का अवतार

    FMInference/FlexLLMGen

    9,362GitHub पर देखें↗

    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

    Reduces model weight memory by approximately 70% using 4-bit quantization with minimal accuracy loss.

    Pythondeep-learninggpt-3high-throughput
    GitHub पर देखें↗9,362
  • intel-analytics/bigdlintel-analytics का अवतार

    intel-analytics/BigDL

    8,845GitHub पर देखें↗

    BigDL एक PyTorch एक्सेलेरेशन फ्रेमवर्क और डिस्ट्रीब्यूटेड इन्फरेंस इंजन है जिसे लार्ज लैंग्वेज मॉडल्स के लिए डिज़ाइन किया गया है। यह Intel हार्डवेयर पर मॉडल्स चलाने के लिए एक टूलकिट प्रदान करता है, जिसमें क्वांटाइज़ेशन टूल्स और पैरामीटर-कुशल फाइन-ट्यूनिंग के लिए लाइब्रेरीज़ शामिल हैं। यह प्रोजेक्ट कई हार्डवेयर एक्सेलेरेटर्स में मॉडल वर्कलोड को वितरित करने के लिए पाइपलाइन पैरेललिज़्म के उपयोग के माध्यम से खुद को अलग बनाता है। यह मेमोरी फुटप्रिंट को कम करने और टेक्स्ट जनरेशन लेटेंसी को घटाने के लिए लो-बिट इंटीजर क्वांटाइज़ेशन और सट्टा डिकोडिंग (speculative decoding) का उपयोग करता है। यह सिस्टम मॉडल ऑप्टिमाइज़ेशन में व्यापक क्षमताओं को कवर करता है, जिसमें वेट कम्प्रेशन और क्वांटाइज़्ड मॉडल लोडिंग शामिल है। यह प्री-ट्रेंड मॉडल्स को विशिष्ट कार्यों के अनुकूल बनाने के लिए हार्डवेयर-एक्सेलेरेटेड ट्रेनिंग रूटीन को भी सपोर्ट करता है।

    Compresses LLM weights into low-bit precision formats to reduce memory usage and increase execution speed.

    Python
    GitHub पर देखें↗8,845
  • intel/ipex-llmintel का अवतार

    intel/ipex-llm

    8,836GitHub पर देखें↗

    Intel XPU LLM Acceleration Library is a toolkit designed to accelerate large language model inference and finetuning on Intel CPUs, GPUs, and NPUs. It provides a distributed inference engine for scaling models across multiple accelerators, a multimodal model runtime for vision and speech tasks, and a low-bit model quantization tool for converting weights into INT4, FP8, and GGUF formats. The project features a parameter-efficient finetuning framework that enables model adaptation using QLoRA and DPO on Intel hardware. It distinguishes itself by providing specialized optimizations for Intel XP

    Converts model weights to low-bit precision formats like INT4 and FP8 to maximize performance on Intel hardware.

    Python
    GitHub पर देखें↗8,836
  • 01-ai/yi01-ai का अवतार

    01-ai/Yi

    7,822GitHub पर देखें↗

    Yi is a bilingual language model and foundation model designed for natural language processing, reasoning, and reading comprehension in both English and Chinese. It is built as a transformer-based architecture capable of general purpose text generation and conversational tasks. The model is distinguished by its ability to function as a long context system, processing and analyzing extended input sequences up to 200k tokens. It also supports quantized versions that use low-bit precision to reduce memory footprints, enabling execution on consumer-grade hardware. The project covers a broad rang

    Provides low-bit weight quantization to reduce memory footprint for execution on consumer-grade hardware.

    Jupyter Notebooklarge-language-models
    GitHub पर देखें↗7,822
  • ericlbuehler/mistral.rsEricLBuehler का अवतार

    EricLBuehler/mistral.rs

    6,597GitHub पर देखें↗

    mistral.rs is an inference engine for large language models that runs locally and exposes models behind OpenAI and Anthropic-compatible APIs. It serves as a multi-model serving platform, capable of loading several models in a single server process with per-request routing and on-demand loading and unloading. The engine supports multimodal inference, processing text alongside images, video, audio, and speech inputs, and includes a quantized model deployment runtime that reduces memory use and speeds up inference on consumer hardware. The project distinguishes itself through an agentic tool exe

    Uses per-column weight data from calibration text to allocate more precision to high-impact weights during quantization.

    Rustllmrustuqff
    GitHub पर देखें↗6,597
  • lightning-ai/lit-llamaLightning-AI का अवतार

    Lightning-AI/lit-llama

    6,081GitHub पर देखें↗

    Lit-llama is a PyTorch-based implementation framework for the LLaMA language model, providing a system for pre-training, fine-tuning, and high-performance inference. It includes a pre-training pipeline for creating foundational language models from scratch and tools for running pretrained weights to generate natural text and predict sequences. The project provides specialized toolkits for parameter-efficient fine-tuning using low-rank adaptation and lightweight adapters. It also includes a quantization library that reduces model memory footprints through four-bit and eight-bit precision to en

    Ships a quantization library that reduces memory footprints via GPTQ-based 4-bit and 8-bit precision.

    Python
    GitHub पर देखें↗6,081
  • ace-step/ace-step-1.5ace-step का अवतार

    ace-step/ACE-Step-1.5

    6,002GitHub पर देखें↗

    ACE Step 1.5 is a local text-to-music generation and audio editing system that runs on consumer hardware. It transforms plain-language descriptions into full-length songs with lyrics, and can edit existing audio through cover generation, vocal removal, track separation, and selective repainting. The system supports multilingual prompts and lyrics in over 50 languages, and provides precise control over musical structure including duration, BPM, key, and time signature. The project distinguishes itself through a dual-stream diffusion architecture that processes separate latent streams for vocal

    Suno generates complete songs in under ten seconds on a standard consumer GPU while using less than four gigabytes of video memory.

    Python
    GitHub पर देखें↗6,002
  • baichuan-inc/baichuan-7bbaichuan-inc का अवतार

    baichuan-inc/Baichuan-7B

    5,654GitHub पर देखें↗

    Baichuan-7B is an open-source 7 billion parameter bilingual Transformer model designed for text generation and few-shot learning across Chinese and English. It is built on a large Transformer architecture trained on a bilingual corpus, enabling it to produce coherent text in both languages from a single model. The model incorporates several optimization techniques that distinguish it from standard large language models. It uses rotary position embeddings that can extrapolate to longer sequences than seen during training, allowing context extension beyond the original 4096-token training lengt

    Reduces model memory by approximately 70% using 4-bit weight quantization with minimal accuracy loss.

    Pythonartificial-intelligencecevalchatgpt
    GitHub पर देखें↗5,654
  • panqiwei/autogptqPanQiWei का अवतार

    PanQiWei/AutoGPTQ

    5,073GitHub पर देखें↗

    AutoGPTQ एक मॉडल कम्प्रेशन फ्रेमवर्क है जिसे लार्ज लैंग्वेज मॉडल्स के मेमोरी फुटप्रिंट को कम करने और इन्फरेंस गति बढ़ाने के लिए डिज़ाइन किया गया है। यह मॉडल वेट्स को कंप्रेस करने के लिए GPTQ एल्गोरिदम का उपयोग करता है, जिससे ये मॉडल्स सीमित VRAM वाले हार्डवेयर पर चल सकते हैं। यह टूलकिट एक आर्किटेक्चर क्वांटाइजेशन पाइपलाइन प्रदान करता है जो विभिन्न न्यूरल नेटवर्क आर्किटेक्चर के लिए कस्टम मॉडल क्लासेस के एकीकरण का समर्थन करता है। इसमें डिप्लॉयमेंट के दौरान मैट्रिक्स गुणन को तेज करने के लिए ऑप्टिमाइज़्ड कर्नेल के साथ एक मिक्स्ड-प्रिसिजन इन्फरेंस इंजन शामिल है। यह फ्रेमवर्क कैलिब्रेशन और क्वांटाइजेशन से लेकर डाउनस्ट्रीम सटीकता मूल्यांकन तक, पूर्ण वेट-कम्प्रेशन वर्कफ़्लो को कवर करता है। ये टूल्स बेंचमार्क कार्यों पर मूल वेट्स के खिलाफ क्वांटाइज्ड मॉडल्स के आउटपुट की तुलना करके परफॉरमेंस लॉस को मापते हैं।

    Implements the GPTQ algorithm for post-training weight quantization to reduce model size.

    Python
    GitHub पर देखें↗5,073
  • autogptq/autogptqAutoGPTQ का अवतार

    AutoGPTQ/AutoGPTQ

    5,070GitHub पर देखें↗

    AutoGPTQ एक मॉडल कम्प्रेशन टूलकिट और पोस्ट-ट्रेनिंग क्वांटाइजेशन फ्रेमवर्क है जिसे लार्ज लैंग्वेज मॉडल्स के मेमोरी फुटप्रिंट को कम करने के लिए डिज़ाइन किया गया है। यह न्यूरल नेटवर्क वेट्स को कंप्रेस करने के लिए GPTQ एल्गोरिदम का उपयोग करता है, जिससे हार्डवेयर आवश्यकताएं कम होती हैं और VRAM उपयोग कम होता है। यह प्रोजेक्ट एक इन्फरेंस एक्सेलेरेटर के रूप में कार्य करता है जो ऑप्टिमाइज़्ड कर्नेल प्रदान करता है जो टोकन जनरेशन की गति को बढ़ाता है। इसमें मॉडल आर्किटेक्चर एक्स्टेंसिबिलिटी की सुविधा है, जो कॉन्फ़िगर करने योग्य पैटर्न्स के माध्यम से नई मॉडल संरचनाओं में क्वांटाइजेशन क्षमताओं को जोड़ने की अनुमति देती है। यह फ्रेमवर्क एक व्यापक क्वांटाइजेशन पाइपलाइन को कवर करता है, जिसमें लेयर-वार वेट कम्प्रेशन, कैलिब्रेशन-आधारित स्केल अनुमान और प्रिसिजन-विशिष्ट मेमोरी मैपिंग शामिल है। इसमें भाषा और सारांश कार्यों में सटीकता पर क्वांटाइजेशन के प्रभाव को मापने के लिए मॉडल परफॉरमेंस मूल्यांकन के लिए सिस्टम भी शामिल हैं।

    Implements the GPTQ algorithm for high-efficiency post-training weight quantization of large language models.

    Python
    GitHub पर देखें↗5,070
  • sakurallm/sakurallmSakuraLLM का अवतार

    SakuraLLM/SakuraLLM

    4,618GitHub पर देखें↗

    SakuraLLM is a multi-format document translation system that hosts large language models for translating Japanese text into other languages. It functions as an inference server that exposes translation models through an OpenAI-compatible API, allowing any tool supporting the OpenAI client format to send translation requests. The system is designed as a glossary-aware translation engine that applies user-defined term dictionaries to ensure consistent translation of proper nouns and names across outputs. The project distinguishes itself by supporting multiple high-performance inference backends

    Runs the translation model on NVIDIA and AMD GPUs with CPU-GPU hybrid inference for lower-memory setups.

    Python
    GitHub पर देखें↗4,618
  • baichuan-inc/baichuan2baichuan-inc का अवतार

    baichuan-inc/Baichuan2

    4,098GitHub पर देखें↗

    Baichuan2 प्री-ट्रेंड लार्ज लैंग्वेज मॉडल्स का एक संग्रह है, जिसमें बेस और चैट वेरिएंट शामिल हैं, जो नेचुरल लैंग्वेज जनरेशन और मल्टी-टर्न कन्वर्सेशनल AI के लिए डिज़ाइन किए गए हैं। यह इन मॉडल्स को कस्टम डेटासेट और विशिष्ट डोमेन के अनुकूल बनाने के लिए एक इन्फरेंस इंजन और फाइन-ट्यूनिंग फ्रेमवर्क प्रदान करता है। यह प्रोजेक्ट एक क्वांटिज़ेशन टूलकिट और एक इन्फरेंस इंजन की सुविधा देता है जो ग्राफिक्स प्रोसेसर, सेंट्रल प्रोसेसर और विशेष एक्सेलेरेटर सहित विविध हार्डवेयर पर मॉडल निष्पादन को सक्षम बनाता है। ये उपकरण सीमित हार्डवेयर पर मेमोरी उपयोग को कम करने और इन्फरेंस गति बढ़ाने के लिए लो-बिट वेट क्वांटिज़ेशन का समर्थन करते हैं। यह सिस्टम मल्टी-मशीन डिस्ट्रीब्यूटेड ट्रेनिंग, पैरामीटर-एफिशिएंट फाइन-ट्यूनिंग और मानव इंटरैक्शन के लिए सुपरवाइज्ड एलाइनमेंट सहित क्षमताओं की एक विस्तृत श्रृंखला को कवर करता है। इसमें मॉडल वर्शन रूपांतरण के लिए यूटिलिटीज भी शामिल हैं और कमांड-लाइन टूल या वेब-आधारित प्रदर्शनों के माध्यम से कन्वर्सेशनल इंटरफेस प्रदान करता है।

    Implements weight quantization to four or eight bits to reduce memory overhead and increase inference speed.

    Pythonartificial-intelligencebenchmarkceval
    GitHub पर देखें↗4,098
  • nunchaku-ai/nunchakununchaku-ai का अवतार

    nunchaku-ai/nunchaku

    3,883GitHub पर देखें↗

    Nunchaku is a 4-bit model quantization library and diffusion model inference engine designed to run large-scale neural networks on consumer GPUs. It functions as a GPU-accelerated optimizer that reduces VRAM usage and increases inference speed through weight compression and memory management. The project utilizes low-rank weight decomposition and SVD weight quantization to compress models to four-bit precision while maintaining visual fidelity. It employs kernel-level operator fusion to minimize data movement and hardware-aware precision mapping to adjust numerical precision based on the unde

    Provides a toolkit for compressing neural network weights into four-bit precision to reduce VRAM usage.

    Pythoncomfyuidiffusion-modelsflux
    GitHub पर देखें↗3,883
  1. Home
  2. DevOps & Infrastructure
  3. Intel Hardware Acceleration
  4. Low-Bit Weight Quantization

सब-टैग एक्सप्लोर करें

  • 4-Bit Quantization Tools2 सब-टैग्सTools that reduce model weight memory by approximately 70% using 4-bit quantization with minimal accuracy loss. **Distinct from Low-Bit Weight Quantization:** Distinct from Low-Bit Weight Quantization: focuses specifically on 4-bit precision rather than general low-bit formats like INT4 and FP8.
  • Consumer GPU Optimizations1 सब-टैगSpecialized configurations to allow large models to run on consumer-grade graphics cards. **Distinct from Low-Bit Weight Quantization:** Focuses on the execution target (consumer hardware) rather than the quantization process itself.
  • Importance Matrix CalibrationTechniques that use per-column weight data from calibration text to allocate more precision to high-impact weights during quantization. **Distinct from Low-Bit Weight Quantization:** Distinct from Low-Bit Weight Quantization: focuses on the calibration method for allocating precision, not the general technique of reducing bit width.