> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-hi/language-models/powerinfer.md). # PowerInfer **एक्टिवेशन लोकैलिटी का लाभ उठाने वाली CPU/GPU हाइब्रिड LLM इन्फेरेंस** — गणना को CPU और GPU के बीच बुद्धिमानी से विभाजित करके एक ही उपभोक्ता GPU पर 70B पैरामीटर मॉडल चलाएँ। > 🌟 **8,000+ GitHub स्टार्स** | SJTU IPADS में विकसित | MIT लाइसेंस *** ## PowerInfer क्या है? PowerInfer बड़े भाषा मॉडलों के लिए एक उच्च-प्रदर्शन इन्फेरेंस इंजन है जो एक प्रमुख अंतर्दृष्टि का लाभ उठाता है: **LLM में मजबूत एक्टिवेशन लोकैलिटी होती है** — न्यूरॉनों का एक छोटा उपसमूह ("हॉट न्यूरॉन") अधिकांश इन्फेरेंस चरणों में लगातार सक्रिय रहता है, जबकि अधिकांश निष्क्रिय रहते हैं। 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 ऑफ़लोडिंग** — उच्च कोर-गिनती वाले CPU के लिए अनुकूलित ### Clore.ai पर PowerInfer का उपयोग क्यों करें? Clore.ai क्लाउड विकल्पों की तुलना में कहीं कम लागत पर GPU किराए पर देता है। 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.8.1-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 image:** `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) "बिल्ड पूर्ण!" 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 "मुझे क्वांटम कंप्यूटिंग के बारे में बताइए" \\ -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 "जीवन का अर्थ क्या है?" \\ -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 लेयर विभाजन का अनुकूलन यह `--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 गति वृद्धि** उपभोक्ता GPUs पर बड़े मॉडल इन्फेरेंस के लिए मानक llama.cpp की तुलना में PowerInfer की न्यूरॉन-सचेत शेड्यूलिंग के साथ यह सामान्य है। {% endhint %} *** ## सेवा के रूप में चलाना स्थायी API सर्विंग के लिए systemd सेवा बनाएँ: ```bash cat > /etc/systemd/system/powerinfer.service << 'EOF' [Unit] PowerInfer LLM सर्वर 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 हमेशा पुनः प्रारंभ करें पुनः प्रारंभ अंतराल 5 सेकंड [Install] 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": "न्यूरल नेटवर्क को सरलता से समझाइए"} ], 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 GPU और तेज़ CPU वाले Clore.ai सर्वर आदर्श हैं। | GPU | VRAM | Clore.ai मूल्य | अधिकतम मॉडल (Q4) | थ्रूपुट (Llama 2 70B Q4) | | --------- | ----- | ----------------------------------------- | ---------------------- | ------------------------ | | RTX 3090 | 24 GB | $0.07–0.21/hr | 70B (64GB+ RAM के साथ) | \~8–12 tok/s | | RTX 4090 | 24 GB | $0.14–0.42/hr | 70B (तेज़ CPU ऑफ़लोड) | \~12–18 tok/s | | A100 40GB | 40 GB | [bare metal](https://clore.ai/bare-metal) | 70B (न्यूनतम ऑफ़लोड) | \~35–45 tok/s | | A100 80GB | 80 GB | [bare metal](https://clore.ai/bare-metal) | 70B पूर्ण सटीकता | \~50–60 tok/s | {% hint style="info" %} **PowerInfer का सर्वोत्तम बिंदु:** $0.07–0.21/घंटा पर RTX 3090, जो Llama 2 70B Q4 चला रहा हो, बजट-सचेत उपयोगकर्ताओं के लिए एक बड़ी सफलता है। आपको A100 किराये की लागत से 10–12x कम में 70B मॉडल मिलता है। थ्रूपुट कम है (\~10 tok/s), लेकिन शोध या कम-ट्रैफ़िक इन्फेरेंस के लिए यह बेजोड़ मूल्य है। {% endhint %} **CPU, GPU जितना ही महत्वपूर्ण है:** PowerInfer "कोल्ड" न्यूरॉन को CPU पर ऑफ़लोड करता है। AMD EPYC या Intel Xeon CPU (अनेक कोर, उच्च मेमोरी बैंडविड्थ) वाले Clore.ai सर्वर, एकल-सॉकेट उपभोक्ता CPU की तुलना में काफी बेहतर प्रदर्शन करेंगे। बड़े मॉडल कार्य के लिए किराए पर लेने से पहले सर्वर स्पेक्स जाँचें। **मेमोरी बैंडविड्थ बाधा:** 70B मॉडलों के लिए, कोल्ड न्यूरॉन गणना के दौरान CPU RAM बैंडविड्थ सीमित कारक होती है। DDR5 ECC RAM या HBM-समीप आर्किटेक्चर वाले सर्वर बेहतर थ्रूपुट देंगे। *** ## संसाधन * 🐙 **GitHub:** [github.com/SJTU-IPADS/PowerInfer](https://github.com/SJTU-IPADS/PowerInfer) * 📄 **शोध पत्र:** [PowerInfer: उपभोक्ता-ग्रेड 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) --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter: ``` GET https://docs.clore.ai/guides/guides_v2-hi/language-models/powerinfer.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.