# TGI (Text Generation Inference)

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

{% hint style="success" %}
सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं जिन्हें के माध्यम से किराये पर लिया जा सकता है [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace).
{% endhint %}

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

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

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

## 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 मार्केटप्लेस](https://clore.ai/marketplace) और सर्वरों को फ़िल्टर करें:

* 7B मॉडलों के लिए VRAM ≥ 24 GB (फुल प्रिसिशन)
* 7B मॉडलों के लिए VRAM ≥ 12 GB (4-बिट क्वांटाइज़ेशन)
* 70B मॉडलों के लिए VRAM ≥ 80 GB (फुल प्रिसिशन, सिंगल GPU)

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

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

```bash
ssh -p <PORT> root@<SERVER_IP>
```

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

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

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

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

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

```bash
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 जैसे गेटेड मॉडलों के लिए):**

```bash
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 के लिए):**

```bash
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 मॉडलों के लिए):**

```bash
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. सत्यापित करें कि सर्वर चल रहा है

```bash
# लॉग चेक करें
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: बेसिक टेक्स्ट जनरेशन

```bash
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 फ़ॉर्मेट का समर्थन करता है:

```bash
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: स्ट्रीमिंग प्रतिक्रिया

```bash
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 क्लाइंट

```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: बैच अनुरोध

```python
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       | सर्वर पोर्ट                                      |

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

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

```bash
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 की तुलना में तेज़)

```bash
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. अधिकतम बैच साइज ट्यून करें

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

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

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

```bash
--dtype bfloat16
```

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

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

```bash
# सर्वर पर, 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) के लिए:

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

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

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

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

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

***

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

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

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

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

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

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

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

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

### समस्या: सर्वर http\_pub के माध्यम से सुलभ नहीं

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

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

### समस्या: "trust\_remote\_code आवश्यक है"

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

```bash
--trust-remote-code
```

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

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

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

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

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

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

***

## लिंक

* [GitHub](https://github.com/huggingface/text-generation-inference)
* [दस्तावेज़ीकरण](https://huggingface.co/docs/text-generation-inference)
* [Docker Hub / GHCR](https://github.com/huggingface/text-generation-inference/pkgs/container/text-generation-inference)
* [समर्थित मॉडल](https://huggingface.co/docs/text-generation-inference/supported_models)
* [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace)

***

## 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](https://clore.ai/marketplace) GPU सर्वरों पर। उपलब्ध GPUs ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण रूट एक्सेस।