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	मध्यम

CPU मायने रखता है: PowerInfer कोल्ड न्यूरॉन्स को CPU पर ऑफलोड करता है। उच्च कोर-काउंट CPU (AMD EPYC, Intel Xeon) तेज़ मेमोरी बैंडविड्थ के साथ बड़े मॉडलों के लिए थ्रूपुट को काफी बढ़ाता है।

---

Clore.ai पर शीघ्र आरम्भ

चरण 1: अपना सर्वर चुनें

पर clore.ai मार्केटप्लेस में, फ़िल्टर करें:

• NVIDIA GPU 16GB+ VRAM के साथ (RTX 3090, RTX 4090, A100)

• उच्च CPU कोर काउंट (16+ कोर आदर्श)

• 64GB+ RAM 70B मॉडलों के लिए, 13B मॉडलों के लिए 32GB

चरण 2: कस्टम Docker इमेज बनाएं

PowerInfer को एक कस्टम Docker सेटअप की आवश्यकता है। इसका उपयोग करें 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 के साथ इनलाइन उपयोग करें:

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 बनाना

यदि आप कंटेनर के अंदर बनाना पसंद करते हैं:

# अपने Clore.ai सर्वर में SSH करें
ssh root@<clore-node-ip> -p <ssh-port>

# आवश्यकताएँ इंस्टॉल करें
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/

बिल्ड सत्यापित करें

./build/bin/main --help
# यह PowerInfer CLI हेल्प आउटपुट करना चाहिए

---

मॉडल प्राप्त करना

GGUF मॉडल डाउनलोड करें

PowerInfer GGUF फॉर्मेट का उपयोग करता है (उसी जैसा कि llama.cpp):

# 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 से प्रमुख अंतर है:

# 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/

प्रिडिक्टर जेनरेशन समय: न्यूरॉन प्रिडिक्टर बनाना मॉडल के आकार के आधार पर 30–60 मिनट ले सकता है। यह एक बार किया जाने वाला ऑपरेशन है — प्रिडिक्टर बाद के रन में पुन: उपयोग किया जाता है।

---

इनफेरेंस चलाना

बेसिक इनफेरेंस (प्रिडिक्टर के बिना)

प्रिडिक्टर जेनरेशन के बिना परीक्षण के लिए (मानक GPU/CPU विभाजन):

./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 मोड:

./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

इंटरैक्टिव चैट मोड

./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)

./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 के आधार पर ट्यून करें:

# उपलब्ध 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

3x स्पीडअप PowerInfer की न्यूरॉन-सचेत शेड्यूलिंग के साथ उपभोक्ता GPUs पर बड़े मॉडल इनफेरेंस के लिए मानक llama.cpp की तुलना में यह सामान्य है।

---

एक सेवा के रूप में चलाना

स्थायी API सर्विंग के लिए systemd सेवा बनाएं:

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-अनुकूल क्लाइंट का उपयोग करें:

from openai import OpenAI

client = OpenAI(
    base_url="http://<clore-node-ip>:<port>/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 मेमोरी ख़त्म हो गई

# GPU लेयर्स कम करें
./build/bin/main -m model.gguf --gpu-layers 10  # 20 से घटाएँ

# देखें कौन VRAM उपयोग कर रहा है
nvidia-smi

# GPU मेमोरी साफ़ करें
sudo fuser -v /dev/nvidia*  # प्रक्रियाएँ देखें

धीमा CPU इनफेरेंस

# 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

बिल्ड विफल होता है

# सुनिश्चित करें कि 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

सामान्य समस्या: यदि cmake CUDA नहीं पा सकता, सेट करें CUDA_HOME पर्यावरण चर: export CUDA_HOME=/usr/local/cuda cmake चलाने से पहले।

---

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

PowerInfer का स्वीट स्पॉट: RTX 3090 लगभग ~$0.12/घंटा पर Llama 2 70B Q4 चलाना बजट-संज्ञानी उपयोगकर्ताओं के लिए एक बड़ा विकास है। आप A100 किराये की लागत से 10–12× कम में 70B मॉडल प्राप्त करते हैं। थ्रूपुट कम है (~10 tok/s), लेकिन शोध या कम-ट्रैफ़िक इनफेरेंस के लिए यह अद्वितीय मूल्य है।

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

• 📄 रिसर्च पेपर: PowerInfer: Consumer-grade GPU के साथ तेज़ बड़े भाषा मॉडल सर्विंग

• 🤗 GGUF मॉडल्स: huggingface.co/TheBloke

• 🧩 SJTU IPADS लैब: ipads.se.sjtu.edu.cn