> 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 एक उच्च-प्रदर्शन इनफेरेंस इंजन है बड़े भाषा मॉडलों के लिए जो एक प्रमुख अंतर्दृष्टि का उपयोग करता है: **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) --- # 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.