TGI (टेक्स्ट जेनरेशन इन्फरेंस)

उत्पादन LLM सर्विंग के लिए HuggingFace Text Generation Inference (TGI) को Clore.ai GPUs पर चलाएं

Text Generation Inference (TGI) HuggingFace का प्रोडक्शन-ग्रेड LLM सर्विंग फ्रेमवर्क है, जो हाई-थ्रूपुट और लो-लेटेंसी इन्फरेंस के लिए डिज़ाइन किया गया है। यह बक्से से बाहर Flash Attention 2, निरंतर बैचिंग, PagedAttention, और टेन्सर पैरेललिज़्म का समर्थन करता है — जिससे यह CLORE.AI GPU सर्वरों पर बड़े भाषा मॉडल को स्केल पर तैनात करने के लिए प्रमुख समाधान बन जाता है।

सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं जिन्हें के माध्यम से किराये पर लिया जा सकता है CLORE.AI मार्केटप्लेस.

सर्वर आवश्यकताएँ

पैरामीटर	न्यूनतम	अनुशंसित
RAM	16 GB	32 GB+
VRAM	8 GB	24 GB+
डिस्क	50 GB	200 GB+
GPU	किसी भी NVIDIA (Flash Attention के लिए Ampere+)	A100, H100, RTX 4090

Flash Attention 2 के लिए Ampere आर्किटेक्चर या नया (RTX 3000+, A100, H100) आवश्यक है। पुराने GPUs के लिए, TGI स्वचालित रूप से मानक अटेंशन पर वापस चले जाएगा।

CLORE.AI पर त्वरित तैनाती

Docker इमेज: ghcr.io/huggingface/text-generation-inference:latest

पोर्ट्स: 22/tcp, 8080/http

पर्यावरण चर:

चर	उदाहरण	विवरण
MODEL_ID	mistralai/Mistral-7B-Instruct-v0.3	HuggingFace मॉडल आईडी
HF_TOKEN	hf_xxx...	HuggingFace टोकन (गेटेड मॉडलों के लिए)
NUM_SHARD	2	टेंसर पैरेललिज़्म के लिए GPUs की संख्या
MAX_INPUT_LENGTH	4096	अधिकतम इनपुट टोकन
MAX_TOTAL_TOKENS	8192	अधिकतम इनपुट + आउटपुट टोकन
QUANTIZE	bitsandbytes-nf4	क्वांटाइज़ेशन विधि

चरण-दर-चरण सेटअप

1. CLORE.AI पर एक GPU सर्वर किराए पर लें

जाएँ CLORE.AI मार्केटप्लेस और सर्वरों को फ़िल्टर करें:

• 7B मॉडलों के लिए VRAM ≥ 24 GB (फुल प्रिसिशन)

• 7B मॉडलों के लिए VRAM ≥ 12 GB (4-बिट क्वांटाइज़ेशन)

• 70B मॉडलों के लिए VRAM ≥ 80 GB (फुल प्रिसिशन, सिंगल GPU)

2. SSH के जरिए कनेक्ट करें

आपका ऑर्डर कन्फर्म होने के बाद, अपने CLORE.AI डैशबोर्ड से मिले SSH विवरणों का उपयोग करके अपने सर्वर से कनेक्ट करें:

ssh -p <PORT> root@<SERVER_IP>

या अपने CLORE.AI ऑर्डर पैनल से वेब टर्मिनल का उपयोग करें।

3. TGI Docker इमेज खींचें (Pull)

docker pull ghcr.io/huggingface/text-generation-inference:latest

4. किसी मॉडल के साथ TGI लॉन्च करें

बेसिक लॉन्च (Mistral 7B):

docker run -d \
  --name tgi \
  --gpus all \
  --shm-size 1g \
  -p 8080:80 \
  -v /root/models:/data \
  -e MODEL_ID=mistralai/Mistral-7B-Instruct-v0.3 \
  ghcr.io/huggingface/text-generation-inference:latest \
  --model-id mistralai/Mistral-7B-Instruct-v0.3 \
  --max-input-length 4096 \
  --max-total-tokens 8192

HuggingFace टोकन के साथ (Llama 3 जैसे गेटेड मॉडलों के लिए):

docker run -d \
  --name tgi \
  --gpus all \
  --shm-size 1g \
  -p 8080:80 \
  -v /root/models:/data \
  -e HUGGING_FACE_HUB_TOKEN=hf_your_token_here \
  ghcr.io/huggingface/text-generation-inference:latest \
  --model-id meta-llama/Meta-Llama-3-8B-Instruct \
  --max-input-length 8192 \
  --max-total-tokens 16384

4-बिट क्वांटाइज़ेशन के साथ (कम VRAM के लिए):

docker run -d \
  --name tgi \
  --gpus all \
  --shm-size 1g \
  -p 8080:80 \
  -v /root/models:/data \
  ghcr.io/huggingface/text-generation-inference:latest \
  --model-id mistralai/Mixtral-8x7B-Instruct-v0.1 \
  --quantize bitsandbytes-nf4 \
  --max-input-length 4096 \
  --max-total-tokens 8192

मल्टी-GPU टेन्सर पैरेललिज़्म (70B मॉडलों के लिए):

docker run -d \
  --name tgi \
  --gpus all \
  --shm-size 2g \
  -p 8080:80 \
  -v /root/models:/data \
  ghcr.io/huggingface/text-generation-inference:latest \
  --model-id meta-llama/Meta-Llama-3-70B-Instruct \
  --num-shard 2 \
  --max-input-length 8192 \
  --max-total-tokens 16384

5. सत्यापित करें कि सर्वर चल रहा है

# लॉग चेक करें
docker logs -f tgi

# "Connected" संदेश की प्रतीक्षा करें, फिर परीक्षण करें:
curl http://localhost:8080/health

अपेक्षित प्रतिक्रिया: {"status":"ok"}

6. CLORE.AI HTTP प्रॉक्सी के माध्यम से एक्सेस करें

अपने CLORE.AI ऑर्डर पैनल में, आप अपना http_pub पोर्ट 8080 के लिए URL देखेंगे। यह ब्राउज़र/API एक्सेस को SSH टनलिंग के बिना सक्षम करता है:

https://<order-id>.clore.ai/

---

उपयोग के उदाहरण

उदाहरण 1: बेसिक टेक्स्ट जनरेशन

curl http://localhost:8080/generate \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "inputs": "फ्रांस की राजधानी क्या है?",
    "parameters": {
      "max_new_tokens": 100,
      "temperature": 0.7
    }
  }'

उदाहरण 2: चैट कंप्लीशन्स (OpenAI-अनुकूल)

TGI OpenAI चैट कंप्लीशन्स API फ़ॉर्मेट का समर्थन करता है:

curl http://localhost:8080/v1/chat/completions \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "tgi",
    "messages": [
      {"role": "system", "content": "You are a helpful assistant."},
      {"role": "user", "content": "क्वांटम एंटैंगलमेंट को सरल शब्दों में समझाइए."}
    ],
    "max_tokens": 512,
    "temperature": 0.8,
    "stream": false
  }'

उदाहरण 3: स्ट्रीमिंग प्रतिक्रिया

curl http://localhost:8080/generate_stream \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "inputs": "फिबोनैचि संख्याओं की गणना करने के लिए एक Python फ़ंक्शन लिखें:",
    "parameters": {
      "max_new_tokens": 300,
      "temperature": 0.2
    }
  }' \
  --no-buffer

उदाहरण 4: Python क्लाइंट

from huggingface_hub import InferenceClient

# अपने CLORE.AI http_pub URL से बदलें
client = InferenceClient(model="http://localhost:8080")

# सरल जनरेशन
response = client.text_generation(
    "Translate to French: Hello, how are you?",
    max_new_tokens=100,
    temperature=0.7,
)
print(response)

# चैट
for token in client.chat_completion(
    messages=[{"role": "user", "content": "मशीन लर्निंग क्या है?"}],
    max_tokens=200,
    stream=True,
):
    print(token.choices[0].delta.content, end="", flush=True)

उदाहरण 5: बैच अनुरोध

import requests

BASE_URL = "http://localhost:8080"  # या आपका CLORE.AI http_pub URL

prompts = [
    "फ्रांसीसी क्रांति का 3 वाक्यों में सारांश दें.",
    "GPU कंप्यूटिंग के बारे में एक हाइकू लिखें.",
    "Rust के मुख्य लाभ C++ की तुलना में क्या हैं?",
]

results = []
for prompt in prompts:
    response = requests.post(
        f"{BASE_URL}/generate",
        json={"inputs": prompt, "parameters": {"max_new_tokens": 150}},
    )
    results.append(response.json()["generated_text"])

for prompt, result in zip(prompts, results):
    print(f"Prompt: {prompt}\nAnswer: {result}\n{'-'*50}")

---

कॉन्फ़िगरेशन

मुख्य CLI पैरामीटर्स

पैरामीटर	डिफ़ॉल्ट	विवरण
--model-id	अनिवार्य	HuggingFace मॉडल ID या स्थानीय पथ
--num-shard	1	GPU shards की संख्या (टेन्सर पैरेललिज़्म)
--max-concurrent-requests	128	अधिकतम समवर्ती अनुरोध
--max-input-length	1024	अधिकतम इनपुट टोकन लंबाई
--max-total-tokens	2048	अधिकतम इनपुट + आउटपुट टोकन
--max-batch-total-tokens	auto	प्रति बैच अधिकतम टोकन
--quantize	none	क्वांटाइज़ेशन: bitsandbytes-nf4, gptq, awq
--dtype	auto	float16, bfloat16
--trust-remote-code	false	कस्टम मॉडल कोड की अनुमति दें
--port	80	सर्वर पोर्ट

लोकल मॉडल का उपयोग करना

यदि आपके पास मॉडल लोकल रूप से डाउनलोड है:

docker run -d \
  --name tgi \
  --gpus all \
  --shm-size 1g \
  -p 8080:80 \
  -v /path/to/your/model:/model \
  ghcr.io/huggingface/text-generation-inference:latest \
  --model-id /model

AWQ क्वांटाइज़ेशन (NF4 की तुलना में तेज़)

docker run -d \
  --name tgi \
  --gpus all \
  --shm-size 1g \
  -p 8080:80 \
  -v /root/models:/data \
  ghcr.io/huggingface/text-generation-inference:latest \
  --model-id casperhansen/mistral-7b-instruct-v0.2-awq \
  --quantize awq

---

प्रदर्शन सुझाव

1. Flash Attention 2 सक्षम करें

Ampere+ GPUs (RTX 3000+, A100, H100) पर Flash Attention 2 स्वचालित रूप से सक्षम होता है। कोई अतिरिक्त कॉन्फ़िगरेशन आवश्यक नहीं।

2. अधिकतम बैच साइज ट्यून करें

उच्च-थ्रूपुट परिदृश्यों के लिए, बैच साइज बढ़ाएं:

--max-batch-total-tokens 32000 \
--max-waiting-tokens 20

3. Ampere+ GPUs पर bfloat16 का उपयोग करें

--dtype bfloat16

यह float16 की तुलना में संख्यात्मक रूप से अधिक स्थिर है और आधुनिक GPUs पर समान प्रदर्शन देता है।

4. मॉडल्स को पर्सिस्टेंट स्टोरेज पर पहले से डाउनलोड करें

# सर्वर पर, TGI शुरू करने से पहले पहले से डाउनलोड करें
pip install huggingface_hub
python -c "
from huggingface_hub import snapshot_download
snapshot_download('mistralai/Mistral-7B-Instruct-v0.3', local_dir='/root/models/mistral-7b')
"

फिर लोकल पथ को माउंट करें ताकि रिस्टार्ट पर पुनः डाउनलोड न करना पड़े।

5. GPU मेमोरी प्रबंधन

RTX 3090/4090 (24GB VRAM) के लिए:

# float16 में 7B मॉडल पूरी तरह फिट बैठता है
--max-total-tokens 8192

# 13B मॉडल को क्वांटाइज़ेशन की आवश्यकता है
--quantize bitsandbytes-nf4
--max-total-tokens 4096

6. स्पेकुलेटिव डीकोडिंग

छोटे मॉडलों के साथ ड्राफ्ट के रूप में तेज़ जनरेशन के लिए:

--speculate 4  # स्पेकुलेटिव टोकन्स की संख्या

---

समस्या निवारण

समस्या: "CUDA out of memory"

त्रुटि: CUDA मेमोरी खत्म हो गई। X GiB आवंटित करने का प्रयास किया गया

समाधान: कम करें --max-total-tokens या क्वांटाइज़ेशन सक्षम करें:

--quantize bitsandbytes-nf4
--max-total-tokens 4096

समस्या: मॉडल डाउनलोड धीमा है

समाधान: HuggingFace मिरर का उपयोग करें या पहले से डाउनलोड करें:

# मिरर सेट करें
-e HF_ENDPOINT=https://hf-mirror.com

समस्या: सर्वर http_pub के माध्यम से सुलभ नहीं

समाधान: सुनिश्चित करें कि पोर्ट 8080 सही ढंग से मैप किया गया है। TGI आंतरिक रूप से पोर्ट 80 पर सुनता है, लेकिन आप इसे बाहरी रूप से 8080 पर मैप करते हैं:

-p 8080:80  # होस्ट:कंटेनर

समस्या: "trust_remote_code आवश्यक है"

कुछ मॉडलों (जैसे Falcon, Phi) को कस्टम कोड की आवश्यकता होती है:

--trust-remote-code

समस्या: पहली प्रतिक्रिया धीमी है

पहला अनुरोध मॉडल को VRAM में लोड करने को ट्रिगर करता है। यह सामान्य है। बाद के अनुरोध तेज़ होंगे।

# लोडिंग प्रगति जांचें
docker logs -f tgi | grep -E "Connected|Error|Loading"

समस्या: कंटेनर तुरंत आउट हो जाता है

# त्रुटियों के लिए जांचें
docker logs tgi

# सामान्य समाधान: साझा मेमोरी बढ़ाएँ
--shm-size 2g

---

लिंक

• GitHub

• दस्तावेज़ीकरण

• Docker Hub / GHCR

• समर्थित मॉडल

• CLORE.AI मार्केटप्लेस

---

Clore.ai GPU सिफारिशें

उपयोग केस	सिफारिश की गई GPU	Clore.ai पर अनुमानित लागत
डेवलपमेंट/टेस्टिंग	RTX 3090 (24GB)	~$0.12/gpu/hr
प्रोडक्शन (7B–13B)	RTX 4090 (24GB)	~$0.70/gpu/hr
बड़े मॉडल (70B+)	A100 80GB / H100	~$1.20/gpu/hr

💡 इस गाइड के सभी उदाहरण तैनात किए जा सकते हैं Clore.ai GPU सर्वरों पर। उपलब्ध GPUs ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण रूट एक्सेस।