# PowerInfer **सक्रियता लोकेलिटी का उपयोग करते हुए CPU/GPU हाइब्रिड LLM इनफेरेंस** — CPU और GPU के बीच बुद्धिमानी से गणना विभाजित करके एक ही उपभोक्ता GPU पर 70B पैरामीटर मॉडल चलाएँ। > 🌟 **8,000+ GitHub स्टार्स** | SJTU IPADS में विकसित | MIT लाइसेंस *** ## PowerInfer क्या है? PowerInfer एक उच्च-प्रदर्शन इनफेरेंस इंजन है बड़े भाषा मॉडलों के लिए जो एक प्रमुख अंतर्दृष्टि का उपयोग करता है: **LLMs में मजबूत सक्रियता लोकेलिटी दिखाई देती है** — न्यूरॉन्स का एक छोटा उपसमुच्चय ("हॉट न्यूरॉन्स") अधिकांश इनफेरेंस चरणों में लगातार सक्रिय रहता है, जबकि अधिकांश निष्क्रिय रहते हैं। PowerInfer इस गुण का उपयोग करता है ताकि: 1. **हॉट न्यूरॉन्स को GPU पर रखें** तेज़ गणना के लिए 2. **कोल्ड न्यूरॉन्स को CPU/RAM पर ऑफलोड करें** बिना महत्वपूर्ण गुणवत्ता हानि के 3. **गतिशील रूप से रूट करें** सक्रियता पैटर्न के आधार पर CPU और GPU के बीच गणना परिणाम: आप केवल के साथ 70B मॉडल चला सकते हैं **16GB VRAM** बजाय इसके कि सभी को GPU पर 140GB+ की आवश्यकता हो। ### मुख्य क्षमताएँ * **उपभोक्ता GPU समर्थन** — RTX 3090/4090 70B मॉडल चला सकते हैं * **न्यूरॉन-सचेत शेड्यूलिंग** — प्रिडिक्टर प्रत्येक इनफेरेंस के लिए CPU बनाम GPU रूटिंग निर्धारित करता है * **न्यूनतम गुणवत्ता ह्रास** — पूर्ण-प्रिसिजन गुणवत्ता का >95% बनाए रखता है * **llama.cpp अनुकूलता** — GGUF फॉर्मेट समर्थन * **NUMA-सचेत CPU ऑफलोडिंग** — उच्च कोर-काउंट CPUs के लिए अनुकूलित ### Clore.ai पर PowerInfer क्यों उपयोग करें? Clore.ai क्लाउड विकल्पों की तुलना में GPUs किराये पर बहुत कम लागत पर देता है। PowerInfer के साथ: * चलाएँ **Llama 2 70B** पर **एकल RTX 4090** (24GB VRAM) * मल्टी-GPU सेटअप की तुलना में GPU किराये की लागत घटाएँ * लंबी संदर्भ विंडो को ओवरफ़्लो के रूप में CPU RAM से प्रोसेस करें * ऐसे मॉडल चलाएँ जिन्हें पहले महंगे A100/H100 इंस्टेंस की आवश्यकता थी *** ## हार्डवेयर आवश्यकताएँ | मॉडल आकार | न्यूनतम VRAM | अनुशंसित RAM | प्रदर्शन | | --------- | ------------ | ------------ | ---------- | | 7B | 4GB | 16GB | उत्कृष्ट | | 13B | 6GB | 32GB | बहुत अच्छा | | 34B | 12GB | 64GB | अच्छा | | 70B | 16GB | 128GB | मध्यम | {% hint style="info" %} **CPU मायने रखता है:** PowerInfer कोल्ड न्यूरॉन्स को CPU पर ऑफलोड करता है। उच्च कोर-काउंट CPU (AMD EPYC, Intel Xeon) तेज़ मेमोरी बैंडविड्थ के साथ बड़े मॉडलों के लिए थ्रूपुट को काफी बढ़ाता है। {% endhint %} *** ## Clore.ai पर शीघ्र आरम्भ ### चरण 1: अपना सर्वर चुनें पर [clore.ai](https://clore.ai) मार्केटप्लेस में, फ़िल्टर करें: * **NVIDIA GPU** 16GB+ VRAM के साथ (RTX 3090, RTX 4090, A100) * **उच्च CPU कोर काउंट** (16+ कोर आदर्श) * **64GB+ RAM** 70B मॉडलों के लिए, 13B मॉडलों के लिए 32GB ### चरण 2: कस्टम Docker इमेज बनाएं PowerInfer को एक कस्टम Docker सेटअप की आवश्यकता है। इसका उपयोग करें `Dockerfile`: ```dockerfile FROM nvidia/cuda:12.1.0-devel-ubuntu22.04 # निर्भरता इंस्टॉल करें RUN apt-get update && apt-get install -y \ git \ cmake \ build-essential \ python3 \ python3-pip \ curl \ wget \ openssh-server \ && rm -rf /var/lib/apt/lists/* # SSH कॉन्फ़िगर करें RUN mkdir /var/run/sshd && \ echo 'root:powerinfer' | chpasswd && \ sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config # PowerInfer क्लोन और बिल्ड करें RUN git clone https://github.com/SJTU-IPADS/PowerInfer.git /app/PowerInfer WORKDIR /app/PowerInfer RUN mkdir build && cd build && \ cmake .. -DLLAMA_CUBLAS=ON && \ cmake --build . --config Release -j$(nproc) # सॉल्वर के लिए Python निर्भरताएँ इंस्टॉल करें RUN pip3 install torch numpy scipy EXPOSE 22 CMD ["/bin/bash", "-c", "service ssh start && tail -f /dev/null"] ``` Docker Hub पर बिल्ड और पुश करें या Clore.ai के साथ इनलाइन उपयोग करें: ```bash docker build -t yourname/powerinfer:latest . docker push yourname/powerinfer:latest ``` ### चरण 3: Clore.ai पर तैनात करें अपने Clore.ai ऑर्डर में सेट करें: * **Docker इमेज:** `yourname/powerinfer:latest` * **पोर्ट्स:** `22` (SSH) * **पर्यावरण:** `NVIDIA_VISIBLE_DEVICES=all` *** ## स्रोत से PowerInfer बनाना यदि आप कंटेनर के अंदर बनाना पसंद करते हैं: ```bash # अपने Clore.ai सर्वर में SSH करें ssh root@ -p # आवश्यकताएँ इंस्टॉल करें apt-get update && apt-get install -y git cmake build-essential python3 python3-pip # PowerInfer क्लोन करें git clone https://github.com/SJTU-IPADS/PowerInfer.git cd PowerInfer # CUDA समर्थन के साथ बिल्ड करें mkdir build && cd build cmake .. -DLLAMA_CUBLAS=ON -DCMAKE_BUILD_TYPE=Release cmake --build . --config Release -j$(nproc) echo "Build complete!" ls -la bin/ ``` ### बिल्ड सत्यापित करें ```bash ./build/bin/main --help # यह PowerInfer CLI हेल्प आउटपुट करना चाहिए ``` *** ## मॉडल प्राप्त करना ### GGUF मॉडल डाउनलोड करें PowerInfer GGUF फॉर्मेट का उपयोग करता है (उसी जैसा कि llama.cpp): ```bash # HuggingFace CLI इंस्टॉल करें pip3 install huggingface_hub # Llama 2 7B Q4 डाउनलोड करें (परीक्षण के लिए अनुशंसित) huggingface-cli download TheBloke/Llama-2-7B-Chat-GGUF \ llama-2-7b-chat.Q4_K_M.gguf \ --local-dir ./models # Llama 2 70B Q4 डाउनलोड करें (16GB+ VRAM की आवश्यकता होती है) huggingface-cli download TheBloke/Llama-2-70B-Chat-GGUF \ llama-2-70b-chat.Q4_K_M.gguf \ --local-dir ./models ``` ### न्यूरॉन प्रिडिक्टर जेनरेट करें (PowerInfer के लिए आवश्यक) PowerInfer को प्रत्येक मॉडल के लिए एक न्यूरॉन सक्रियता प्रिडिक्टर की आवश्यकता होती है। यह llama.cpp से प्रमुख अंतर है: ```bash # Python सॉल्वर निर्भरताएँ इंस्टॉल करें pip3 install torch numpy scipy # अपने मॉडल के लिए प्रिडिक्टर जेनरेट करें python3 PowerInfer/solver/solve.py \ --model ./models/llama-2-7b-chat.Q4_K_M.gguf \ --output ./predictors/llama-2-7b-chat \ --target-gpu-layers 20 \ --gpu-memory-gb 16 # यह ./predictors/ में प्रिडिक्टर फ़ाइलें बनाता है ls ./predictors/llama-2-7b-chat/ ``` {% hint style="warning" %} **प्रिडिक्टर जेनरेशन समय:** न्यूरॉन प्रिडिक्टर बनाना मॉडल के आकार के आधार पर 30–60 मिनट ले सकता है। यह एक बार किया जाने वाला ऑपरेशन है — प्रिडिक्टर बाद के रन में पुन: उपयोग किया जाता है। {% endhint %} *** ## इनफेरेंस चलाना ### बेसिक इनफेरेंस (प्रिडिक्टर के बिना) प्रिडिक्टर जेनरेशन के बिना परीक्षण के लिए (मानक GPU/CPU विभाजन): ```bash ./build/bin/main \ -m ./models/llama-2-7b-chat.Q4_K_M.gguf \ --gpu-layers 20 \ -p "Tell me about quantum computing" \ -n 256 ``` ### PowerInfer मोड (प्रिडिक्टर के साथ) न्यूरॉन-सचेत रूटिंग के साथ पूर्ण PowerInfer मोड: ```bash ./build/bin/main \ -m ./models/llama-2-7b-chat.Q4_K_M.gguf \ --predictor-path ./predictors/llama-2-7b-chat \ --gpu-layers 20 \ --n-gpu-layers 20 \ -p "What is the meaning of life?" \ -n 512 \ --ctx-size 4096 ``` ### इंटरैक्टिव चैट मोड ```bash ./build/bin/main \ -m ./models/llama-2-7b-chat.Q4_K_M.gguf \ --predictor-path ./predictors/llama-2-7b-chat \ --gpu-layers 20 \ -i \ --ctx-size 4096 \ --temp 0.7 \ --top-p 0.9 \ --repeat-penalty 1.1 \ --color ``` ### सर्वर मोड (OpenAI-अनुकूल API) ```bash ./build/bin/server \ -m ./models/llama-2-7b-chat.Q4_K_M.gguf \ --predictor-path ./predictors/llama-2-7b-chat \ --gpu-layers 20 \ --host 0.0.0.0 \ --port 8080 \ --ctx-size 4096 ``` *** ## GPU लेयर स्प्लिट का अनुकूलन The `--gpu-layers` पैरामीटर निर्धारित करता है कि कितनी ट्रांसफॉर्मर लेयर्स को GPU पर रखा जाए। इसे अपने VRAM के आधार पर ट्यून करें: ```bash # उपलब्ध VRAM जाँचें nvidia-smi --query-gpu=memory.free,memory.total --format=csv # Q4 मॉडलों के लिए अंगुली का नियम: # 7B: ~0.13GB प्रति लेयर → 24GB कार्ड = ~184 लेयर्स (सभी) # 13B: ~0.18GB प्रति लेयर → 24GB कार्ड = ~133 लेयर्स # 70B: ~0.23GB प्रति लेयर → 24GB कार्ड = ~104 लेयर्स (80 कुल में से) ``` **लेयर आवंटन मार्गदर्शिका:** | GPU VRAM | 7B मॉडल | 13B मॉडल | 34B मॉडल | 70B मॉडल | | -------- | -------- | --------- | --------- | --------- | | 8GB | सभी (32) | 20 लेयर्स | 10 लेयर्स | 4 लेयर्स | | 16GB | सभी (32) | सभी (40) | 25 लेयर्स | 10 लेयर्स | | 24GB | सभी (32) | सभी (40) | सभी (60) | 20 लेयर्स | | 48GB | सभी (32) | सभी (40) | सभी (60) | सभी (80) | *** ## प्रदर्शन बेंचमार्क्स ### थ्रूपुट तुलना (Llama 2 70B, RTX 3090) | इंजन | GPU लेयर्स | टोकन/सेकंड | | -------------------- | ---------------------- | ------------ | | llama.cpp (केवल GPU) | 20/80 | \~4 t/s | | llama.cpp (केवल CPU) | 0/80 | \~1 t/s | | **PowerInfer** | **20/80 + प्रिडिक्टर** | **\~12 t/s** | {% hint style="success" %} **3x स्पीडअप** PowerInfer की न्यूरॉन-सचेत शेड्यूलिंग के साथ उपभोक्ता GPUs पर बड़े मॉडल इनफेरेंस के लिए मानक llama.cpp की तुलना में यह सामान्य है। {% endhint %} *** ## एक सेवा के रूप में चलाना स्थायी API सर्विंग के लिए systemd सेवा बनाएं: ```bash cat > /etc/systemd/system/powerinfer.service << 'EOF' [Unit] Description=PowerInfer LLM Server After=network.target [Service] Type=simple WorkingDirectory=/app/PowerInfer ExecStart=/app/PowerInfer/build/bin/server \ -m /models/llama-2-13b-chat.Q4_K_M.gguf \ --predictor-path /predictors/llama-2-13b-chat \ --gpu-layers 30 \ --host 0.0.0.0 \ --port 8080 \ --ctx-size 4096 Restart=always RestartSec=5 [Install] WantedBy=multi-user.target EOF systemctl daemon-reload systemctl enable powerinfer systemctl start powerinfer systemctl status powerinfer ``` *** ## API उपयोग एक बार सर्वर चलने पर, किसी भी OpenAI-अनुकूल क्लाइंट का उपयोग करें: ```python from openai import OpenAI client = OpenAI( base_url="http://:/v1", api_key="none" ) response = client.chat.completions.create( model="local-model", messages=[ {"role": "user", "content": "Explain neural networks simply"} ], max_tokens=256 ) print(response.choices[0].message.content) ``` *** ## समस्या निवारण ### CUDA मेमोरी ख़त्म हो गई ```bash # GPU लेयर्स कम करें ./build/bin/main -m model.gguf --gpu-layers 10 # 20 से घटाएँ # देखें कौन VRAM उपयोग कर रहा है nvidia-smi # GPU मेमोरी साफ़ करें sudo fuser -v /dev/nvidia* # प्रक्रियाएँ देखें ``` ### धीमा CPU इनफेरेंस ```bash # CPU थ्रेडिंग ऑप्टिमाइज़ेशन सक्षम करें ./build/bin/main -m model.gguf --threads $(nproc) --gpu-layers 20 # NUMA टोपोलॉजी जाँचें numactl --hardware # GPU के निकटतम NUMA नोड पर पिन करें numactl --cpunodebind=0 --membind=0 ./build/bin/main -m model.gguf ``` ### बिल्ड विफल होता है ```bash # सुनिश्चित करें कि CUDA टूलकिट इंस्टॉल है nvcc --version # CMake संस्करण जाँचें (3.14+ आवश्यक) cmake --version # क्लीन बिल्ड rm -rf build && mkdir build cd build && cmake .. -DLLAMA_CUBLAS=ON -DCUDA_TOOLKIT_ROOT_DIR=/usr/local/cuda ``` {% hint style="danger" %} **सामान्य समस्या:** यदि `cmake` CUDA नहीं पा सकता, सेट करें `CUDA_HOME` पर्यावरण चर: `export CUDA_HOME=/usr/local/cuda` cmake चलाने से पहले। {% endhint %} *** ## Clore.ai GPU सिफारिशें PowerInfer का CPU/GPU हाइब्रिड डिज़ाइन बड़े मॉडलों को चलाने की अर्थव्यवस्था बदल देता है। हाई-VRAM GPUs और तेज़ CPUs वाले Clore.ai सर्वर आदर्श हैं। | GPU | VRAM | Clore.ai कीमत | अधिकतम मॉडल (Q4) | थ्रूपुट (Llama 2 70B Q4) | | --------- | ----- | ------------- | --------------------------- | ------------------------ | | RTX 3090 | 24 GB | \~$0.12/घंटा | 70B (64GB+ RAM के साथ) | \~8–12 tok/s | | RTX 4090 | 24 GB | \~$0.70/घंटा | 70B (तेज़ CPU ऑफलोड के साथ) | \~12–18 tok/s | | A100 40GB | 40 GB | \~$1.20/घंटा | 70B (न्यूनतम ऑफलोड) | \~35–45 tok/s | | A100 80GB | 80 GB | \~$2.00/घंटा | 70B पूर्ण प्रिसिजन | \~50–60 tok/s | {% hint style="info" %} **PowerInfer का स्वीट स्पॉट:** RTX 3090 लगभग \~$0.12/घंटा पर Llama 2 70B Q4 चलाना बजट-संज्ञानी उपयोगकर्ताओं के लिए एक बड़ा विकास है। आप A100 किराये की लागत से 10–12× कम में 70B मॉडल प्राप्त करते हैं। थ्रूपुट कम है (\~10 tok/s), लेकिन शोध या कम-ट्रैफ़िक इनफेरेंस के लिए यह अद्वितीय मूल्य है। {% endhint %} **GPU जितना महत्वपूर्ण है उतना ही CPU भी मायने रखता है:** PowerInfer "कोल्ड" न्यूरॉन्स को CPU पर ऑफलोड करता है। AMD EPYC या Intel Xeon CPUs (कई कोर, उच्च मेमोरी बैंडविड्थ) वाले Clore.ai सर्वर सिंगल-सॉकेट उपभोक्ता CPUs की तुलना में काफी बेहतर प्रदर्शन देंगे। बड़े मॉडल कार्य के लिए किराये पर लेने से पहले सर्वर स्पेसिफ़िकेशन जाँचें। **मेमोरी बैंडविड्थ बॉटलनेक:** 70B मॉडलों के लिए, कोल्ड न्यूरॉन गणना के दौरान CPU RAM बैंडविड्थ सीमित कारक होती है। DDR5 ECC RAM या HBM-समकक्ष आर्किटेक्चर वाले सर्वर बेहतर थ्रूपुट दिखाएंगे। *** ## संसाधन * 🐙 **GitHub:** [github.com/SJTU-IPADS/PowerInfer](https://github.com/SJTU-IPADS/PowerInfer) * 📄 **रिसर्च पेपर:** [PowerInfer: Consumer-grade GPU के साथ तेज़ बड़े भाषा मॉडल सर्विंग](https://arxiv.org/abs/2312.12456) * 🤗 **GGUF मॉडल्स:** [huggingface.co/TheBloke](https://huggingface.co/TheBloke) * 🧩 **SJTU IPADS लैब:** [ipads.se.sjtu.edu.cn](https://ipads.se.sjtu.edu.cn)