कंज्यूमर GPU वाले PC पर हाई-स्पीड बड़े भाषा मॉडल सर्विंग

 (github.com/SJTU-IPADS)
1 पॉइंट द्वारा GN⁺ 2023-12-21 | 1 टिप्पणियां | WhatsApp पर शेयर करें
  • PowerInfer एक CPU/GPU hybrid inference engine है, जिसका उद्देश्य एकल कंज्यूमर GPU वाले personal PC पर LLM को locally serve करना है
  • इसकी मुख्य design LLM inference की activation locality का उपयोग करती है: बार-बार activate होने वाले hot neurons को पहले से GPU पर रखा जाता है, और input के अनुसार बदलने वाले cold neurons की computation CPU पर की जाती है
  • evaluation में PowerInfer ने बताया कि RTX 4090 single GPU पर कई LLMs, जिनमें OPT-175B शामिल है, के साथ औसतन 13.20 tokens/s और अधिकतम 29.08 tokens/s हासिल हुए, जो A100 की तुलना में 18% कम है
  • llama.cpp से तुलना में, Falcon(ReLU)-40B-FP16 demo में RTX 4090 24GB पर 11x speedup दिखा; evaluation में अधिकतम 11.69x improvement दिखा और model accuracy बनी रहती है
  • support scope मुख्य रूप से ReLU/ReGLU/Squared ReLU activation function models तक सीमित है; Mistral, original Llama, Qwen आदि currently supported नहीं हैं

PowerInfer जिस समस्या को हल करना चाहता है

  • PowerInfer local devices पर LLM को तेज़ी से चलाने के लिए CPU/GPU inference engine है
  • यह single consumer GPU वाले PC को target करता है, और low-latency LLM inference व serving इसका लक्ष्य है
  • design का core यह है कि LLM inference में neuron activation power-law distribution दिखाता है
    • कुछ hot neurons लगभग सभी inputs में consistent रूप से activate होते हैं
    • बड़ी संख्या में cold neurons specific input के अनुसार बदलते हैं

CPU/GPU hybrid inference तरीका

  • PowerInfer hot neurons को fast access के लिए पहले से GPU में load करता है, और cold neurons की computation CPU पर करता है
  • यह तरीका GPU memory requirement और CPU-GPU data transfer को घटाने पर केंद्रित है
  • इसके अलावा, adaptive predictor और neuron-aware sparse operators को integrate करके neuron activation और computational sparsity को optimize करता है
  • CPU-GPU hybrid inference में सभी dense activation blocks को automatically GPU पर offload करने के बाद, संभव होने पर FFN को split करके GPU पर offload किया जाता है

Performance evaluation और demo

  • RTX 4090 single GPU पर कई LLMs, जिनमें OPT-175B शामिल है, के साथ औसतन 13.20 tokens/s और अधिकतम 29.08 tokens/s हासिल किए
  • इस result को top-tier server-grade A100 GPU की तुलना में 18% कम बताया गया है
  • यह llama.cpp की तुलना में अधिकतम 11.69x तेज़ है और model accuracy बनाए रखने का दावा करता है
  • demo में single RTX 4090 24GB पर Falcon(ReLU)-40B-FP16 चलाकर llama.cpp की तुलना में 11x speedup दिखाया गया
    • PowerInfer और llama.cpp दोनों एक ही hardware पर चले और RTX 4090 के VRAM का पूरा उपयोग किया
  • अलग evaluation में RTX 4090 24GB और FP16 ReLU model, input length 64 की condition में Falcon 40B ने अधिकतम 11x, और Llama 2 70B ने अधिकतम 3x speedup दिखाया
  • RTX 2080Ti 11GB और INT4 ReLU model, input length 8 की condition में Falcon 40B ने अधिकतम 8x, और Llama 2 70B ने अधिकतम 3x speedup दिखाया

Supported models और platforms

Installation और execution flow

  • build dependencies हैं CMake 3.17 या उससे ऊपर, Python 3.8 या उससे ऊपर, pip 19.3 या उससे ऊपर
  • NVIDIA GPU build में -DLLAMA_CUBLAS=ON option इस्तेमाल होता है
  • AMD GPU build ROCm/HIP आधारित है और -DLLAMA_HIPBLAS=ON व AMDGPU_TARGETS specify करता है
  • CPU-only build भी possible है
  • basic inference command में main executable को model path, output token count, thread count और prompt देना होता है
  • GPU VRAM usage limit --vram-budget option से specify की जाती है
  • PowerInfer की serving, perplexity evaluation और batched generation llama.cpp जैसे commands support करते हैं, लेकिन -ngl argument PowerInfer में --vram-budget से replace होता है

Quantization और compatibility

  • PowerInfer INT4 Q4_0 model quantization को optimize करके support करता है
  • quantize executable से PowerInfer GGUF model को Q4_0 format में quantize किया जा सकता है
  • dense inference mode limited रूप से supported है और llama.cpp जैसे तरीके से इस्तेमाल किया जा सकता है
  • dense inference mode सभी models के लिए compatibility mode नहीं है
    • ReluLLaMA और ProSparse models में activation function बदला गया है
    • Bamboo model में model architecture बदला गया है
  • llama.cpp के model weights से भी inference compatibility के लिए चलाया जा सकता है, लेकिन performance improvement नहीं मिलता, ऐसा बताया गया है

Constraints और FAQ

  • currently supported models ReLU/ReGLU/Squared ReLU activation functions इस्तेमाल करने वाले models तक सीमित हैं
  • Mistral, original Llama, Qwen आदि फिलहाल supported नहीं हैं
  • अगर CUDA_ERROR_OUT_OF_MEMORY आए, तो --reset-gpu-index से GPU index फिर से बनाया जा सकता है
  • current implementation में model offloading उम्मीद जितनी accurate न हो सकती है, इसलिए --vram-budget value थोड़ी कम की जा सकती है या --disable-gpu-index से FFN offloading बंद किया जा सकता है
  • current ReLU models, खासकर 70B models, में performance metrics में गिरावट इसलिए बताई गई है क्योंकि सामान्य LLM training के लिए जरूरी लगभग 2T tokens के बजाय सिर्फ 5B tokens से fine-tuning की गई थी

Recent updates और plans

  • 5 जनवरी 2026 को Tiiny AI Pocket Lab जारी किया गया, और बताया गया कि यह GPT-OSS-120B int4 को locally 20 tokens/s पर चलाता है
  • 27 जुलाई 2025 को SmallThinker-21BA3B-Instruct और SmallThinker-4BA0.6B-Instruct जारी किए गए
  • 11 जून 2024 को smartphones के लिए optimized inference framework PowerInfer-2 introduce किया गया, और बताया गया कि यह TurboSparse-Mixtral-47B पर 11.68 tokens/s हासिल करता है
  • उसी दिन Turbo Sparse जारी किया गया; बताया गया कि यह Mistral और Mixtral models को लगभग 90% sparse बनाता है और Mixtral-class models में केवल 4B parameters activate करता है
  • completed items में PowerInfer core code release, Llama-2 और Falcon-40B support, Bamboo-7B support, Windows support, perplexity evaluation code release, और FFN online splitting support शामिल हैं
  • remaining items में text-generation-webui support, Mac के लिए Metal support, OPT model code release, predictor training code release, और Multi-GPU support शामिल हैं

Papers और आधार projects

  • अधिक detailed technical content PowerInfer paper में संकलित है
  • PowerInfer ggml की modifiable operator library और llama.cpp के execution runtime का उपयोग करता है
  • ReLU-based sparse model support में THUNLP का उल्लेख किया गया है
  • PowerInfer ने बताया कि यह Deja Vu research से प्रेरित है

संबंधित पढ़ाई

1 टिप्पणियां

 
GN⁺ 2023-12-21
Hacker News की राय

  • ज़्यादातर machine learning में hot/cold neuron जैसी कोई अवधारणा नहीं होती, इसलिए इसे समझने में समय लगा, और लगता है पेपर भी इसे सीधे परिभाषित नहीं करता
    ReLU में अगर output अक्सर 0 हो तो उसे “cold” माना जा सकता है, इसलिए बात समझ में आती है, लेकिन मूल LLaMA तो ReLU इस्तेमाल नहीं करता। GitHub दोबारा देखने पर पता चला कि यह तरीका वास्तव में सिर्फ ReLU model पर काम करता है, और sparsity पाने के लिए model को ReLU पर “fine-tune” करने वाला एक group है: https://huggingface.co/SparseLLM
    इसलिए यह इंटरनेट पर आसानी से मिलने वाले किसी भी model पर लागू नहीं होता, लेकिन प्रगति अपने आप में बड़ी लगती है। आगे चलकर यह बड़े models और कम आदर्श activation functions के बीच एक समझौते की दिशा में जा सकता है, और यह भी दिलचस्प है कि जब US·EU regulations FLOPs या parameter count को आधार बनाते हैं, तो sparsity की गणना कैसे की जाएगी
    आगे के research में LLaMA की SwiGLU जैसी मौजूदा activation functions को बनाए रखते हुए, quantization का उपयोग करके saturation region को hot/cold neuron के रूप में परिभाषित करने की दिशा संभव लगती है

    • जिज्ञासा है कि ऐसे regulations कब और कैसे आए। development करते समय FLOPs/parameter count regulations तक की चिंता करनी पड़े, यह काफ़ी अजीब लगता है
    • LLaMA compatibility का दावा करने वाले README में सिर्फ ReLU model के लिए वाला बड़ा caveat छोड़ देना काफ़ी गंभीर समस्या है
    • https://huggingface.co/SparseLLM/ReluFalcon-40B में भी “We utilize PowerInfer for inference” लिखा है

  • अगर इससे uncensored Mixtral चला सकें तो सच में बहुत अच्छा होगा। RTX 4090 पर 3-bit से ऊपर quantization भी संभव हो सकती है

    • uncensored LLM आम तौर पर “lobotomized” या aligned versions की तुलना में, कम से कम benchmarks में, बेहतर perform करते हैं; फिर इन्हें downvote क्यों मिलते हैं, यह समझ नहीं आता
    • demo में 24GB VRAM RTX 4090 पर बड़ा model चलाया गया है। Mixture of Experts में sparse activation लागू करना आसान नहीं हो सकता, लेकिन यह एक शानदार दिशा लगती है जो सिर्फ CPU पर चलाने या बहुत सस्ते GPU usage तक भी ले जा सकती है
      तकनीकी रूप से Mixtral में neural network-controlled sparse activation पहले से है, लेकिन Inception meme की तरह “और गहराई में जाना” पड़ेगा
    • dual GPU को शायद सामान्य consumer-grade setup माना जा सकता है, और उम्मीद है कि जल्द support मिलेगा। 4-bit में तो context space भी आराम से आ सकती है
      क्योंकि यह पूरा llama.cpp fork है, उम्मीद है कि किसी दिन upstream project में शामिल हो जाएगा
    • अच्छा लग रहा है: https://www.youtube.com/watch?v=q2KpPUOsBCs

  • चूँकि वे Mistral-7B पर काम कर रहे हैं, मेरी GPU-only Mistral implementation 5GB से थोड़ा ज़्यादा VRAM इस्तेमाल करती है: https://github.com/Const-me/Cgml
    यह ज़्यादातर consumer-grade GPU पर काफ़ी अच्छी चलती है, लेकिन अभी सिर्फ Windows support है

    • काफ़ी दिलचस्प लग रहा है। क्या यह Intel Core i7 laptop पर भी चलेगा?
    • ollama इस्तेमाल कर सकते हैं। यह llmcpp का उपयोग करता है और लगभग 4GB ही चाहिए

  • यह सच में शानदार है। llama.cpp लोकप्रिय है, लेकिन external GPU offloading का तरीका काफ़ी साधारण है, जिसमें prompt processing GPU पर होती है और model को बीच में बाँट दिया जाता है
    यह दिलचस्प है कि activation sparsity इतनी बड़ी है कि उसका व्यावहारिक उपयोग किया जा सकता है, जबकि पारंपरिक machine learning नज़रिये से memory access को बहुत random माना जाता है
    कभी ऐसा हो कि cold neurons को integrated GPU पर offload किया जा सके, तो अच्छा होगा। यह भी जिज्ञासा है कि वे Metal kernel पर विचार कर रहे हैं, क्योंकि मुझे लगा था performance advantage hybrid memory pool से आता है। अगर ऐसा नहीं है, तो शायद यह सिर्फ पुराने AMD Mac के लिए मददगार होगा, हालाँकि हो सकता है मैं कुछ मिस कर रहा हूँ

    • Apple Silicon और Metal के संदर्भ में, शायद विचार यह है कि cold neurons को CPU/Accelerate पर और hot neurons को GPU पर बाँटकर दोनों का उपयोग किया जाए
      अगर GPU और CPU के बीच copy नहीं करनी पड़ती और unified memory पहले से इस्तेमाल हो रही है, तो speedup छोटा हो सकता है, लेकिन अगर chip की ज़्यादा क्षमताओं का एक साथ उपयोग हो सके तो अच्छा होगा। thermal throttling से बचने के लिए शायद सिर्फ efficiency cores का उपयोग करना बेहतर होगा, और game mode भी शायद कुछ ऐसा ही करता होगा

  • इस implementation में model के कौन से हिस्से system memory में रखने हैं और कौन से GPU memory में, यह तय करने के लिए model के बारे में कुछ जानकारी चाहिए लगती है
    आदर्श रूप से क्या इसे अपने-आप calculate किया जा सकता है, या भविष्य के models ऐसे placement algorithm को automate करने के लिए interface देंगे, यह जानने की उत्सुकता है। अगर हर model architecture के हिसाब से algorithm को ढालना पड़े, तो इस project की maintenance काफ़ी मुश्किल हो जाएगी

    • मोटे तौर पर सही लगता है। original model के साथ “Predictor” weights को merge करने वाली script दी गई है, लेकिन GitHub के पहले page पर यह साफ़ नहीं दिखता कि वे weights बनते कैसे हैं
      10x speedup वाकई प्रभावशाली है। अगर यह दूसरे models पर भी दोहराया जा सके, तो inference optimization के लिए hot/cold neurons की पहचान model development का सामान्य हिस्सा बन सकती है

  • README से जो लोग खुद experiment नहीं करेंगे, उनके लिए अहम बात लगभग यही है। PowerInfer को Linux के x86-64 CPU(AVX2), Linux के x86-64 CPU और NVIDIA GPU, और macOS के Apple M chips पर test किया गया है
    हालाँकि कहा गया है कि Mac optimization नहीं की गई, इसलिए अभी performance gain बड़ा नहीं है। जल्द जो features जोड़े जाने वाले हैं उनमें Mistral-7B model और macOS के लिए Metal sparse inference backend शामिल हैं

    • download किए जा सकने वाले llama2 model और convert.py file का भी उल्लेख करना चाहिए

  • “इनपुट के पार लगातार सक्रिय रहने वाले कुछ hot neurons, और इनपुट के अनुसार बदलने वाले कई cold neurons” वाली distribution का उपयोग करके GPU-CPU hybrid inference engine डिज़ाइन करने वाला हिस्सा शानदार है
    इसमें hot neurons को तेज़ access के लिए पहले से GPU पर रखा जाता है, जबकि cold neurons की गणना CPU पर की जाती है, जिससे GPU memory की ज़रूरत और CPU-GPU data transfer दोनों काफ़ी कम हो जाते हैं

  • सब लोग llama.cpp से तुलना करते हैं क्योंकि वही आसान रास्ता है। सबको यह पता होना चाहिए कि llama.cpp धीमा है। इसकी तुलना exllamav2 या अन्य optimized implementations से करनी चाहिए

    • इस मामले में llama.cpp से तुलना करना सही है क्योंकि कोड सचमुच llama.cpp को modify करके बनाया गया है। यह सिर्फ ggml matrix computation library इस्तेमाल करने भर की बात नहीं है, बल्कि main.cpp और सामान्य llama.cpp कोड को ज्यों का त्यों इस्तेमाल करने वाला fork है, इसलिए सीधी तुलना संभव है
      https://github.com/ggerganov/llama.cpp/pull/4543 [Review] Merge PowerInfer with llama.cpp mainline #4543
      https://github.com/ggerganov/llama.cpp/discussions/4534#disc... यह भी एक व्याख्या है कि “11x speedup थोड़ा cherry-picking है, क्योंकि Falcon 40B के लिए llama.cpp GPU code अच्छी तरह optimized नहीं है”
    • exllama grammar constraints को support नहीं करता, इसलिए llama.cpp से बंधे रहना पड़ता है
      इसके अलावा exllama में consistency के लिहाज़ से side effects भी लगते हैं: https://www.reddit.com/r/LocalLLaMA/comments/17w57eu/llm_for...
    • क्या ExLlama सिर्फ GPU-only नहीं है? यह speedup GPU+CPU split use case के लिए है
    • अगर कोई ऐसी चीज़ recommend करनी हो जो और तेज हो और ऐप में package करके distribute भी की जा सके, तो क्या बेहतर होगा, यह जानना चाहूँगा

  • अगर arbitrary models के लिए sparse predictor files generate करना संभव हो जाए तो यह वाकई शानदार होगा। अभी तो लगता है कि यह सिर्फ उन 4 models पर लागू है जिन्हें उन्होंने handle किया है
    page और code को देखकर नहीं लगता कि उस step को करने वाला tool इसमें शामिल है। फिलहाल मैं थोड़ा इंतज़ार करने वाला हूँ, और अच्छा होगा अगर ये features आखिरकार वापस llama.cpp options के रूप में merge हो जाएँ। यह सिर्फ ggml matrix library इस्तेमाल करने की बात नहीं है, बल्कि सामान्य llama.cpp codebase पर आधारित है

  • सिर्फ “consumer-grade GPU” वाला phrase देखने पर लगता है कि यह कई models पर चल सकेगा, लेकिन ऐसे posts में अक्सर जैसा होता है, मैं सोच रहा हूँ कि क्या यह असल में RTX 4090-only है

    • ऐसा कुछ खास नहीं दिखता जो इसे सिर्फ 4090 तक सीमित करे। आम तौर पर अहम चीज़ VRAM होती है, इसलिए अगर 24GB चाहिए तो 3090 भी चल सकता है, और 12GB वाले दो cards भी एक option हैं
      यह technique खुद में एक सामान्य तरीका है जो छोटे GPUs पर बड़े models चलाने में मदद करती है, और CPU offloading performance को काफी बेहतर बनाती है। 4090 पर सबसे बड़े model को fp16 में चलाने के case के अलावा, 2080Ti पर उसी model को 4-bit quantization के साथ चलाने पर भी LLaMA के आधार पर लगभग 3x speedup दिखा
      इसलिए desktop पर 33B model नया default बन सकता है, और सिर्फ एक 3090 या 4090 के साथ भी 70B को real-time chat speed पर चलाना संभव होने की संभावना काफी बढ़ती दिखती है