# Llama 3.3 70B

{% hint style="info" %}
**नवीनतम संस्करण उपलब्ध!** मेटा ने जारी किया [**लामा 4**](/guides/guides_v2-hi/language-models/llama4.md) अप्रैल 2025 में MoE आर्किटेक्चर के साथ — Scout (17B सक्रिय, RTX 4090 पर फिट होता है) समान गुणवत्ता बहुत कम VRAM पर देता है। अपग्रेड करने पर विचार करें।
{% endhint %}

CLORE.AI GPUs पर मेटा का नवीनतम और सबसे कुशल 70B मॉडल।

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

## क्यों Llama 3.3?

* **सबसे अच्छा 70B मॉडल** - लागत के एक हिस्से पर Llama 3.1 405B के प्रदर्शन के बराबर
* **बहुभाषी** - मूल रूप से 8 भाषाओं का समर्थन करता है
* **128K संदर्भ** - लंबी दस्तावेज़ प्रसंस्करण
* **ओपन वेट्स** - वाणिज्यिक उपयोग के लिए मुफ्त

## मॉडल अवलोकन

| विशेषता        | मान                            |
| -------------- | ------------------------------ |
| पैरामीटर       | 70B                            |
| संदर्भ लंबाई   | 128K टोकन                      |
| प्रशिक्षण डेटा | 15T+ टोकन                      |
| भाषाएँ         | EN, DE, FR, IT, PT, HI, ES, TH |
| लाइसेंस        | Llama 3.3 सामुदायिक लाइसेंस    |

### अन्य मॉडलों के मुकाबले प्रदर्शन

| बेंचमार्क | Llama 3.3 70B | Llama 3.1 405B | GPT-4o |
| --------- | ------------- | -------------- | ------ |
| MMLU      | 86.0          | 87.3           | 88.7   |
| HumanEval | 88.4          | 89.0           | 90.2   |
| गणित      | 77.0          | 73.8           | 76.6   |
| बहुभाषी   | 91.1          | 91.6           | -      |

## GPU आवश्यकताएँ

| सेटअप           | VRAM  | प्रदर्शन  | लागत                        |
| --------------- | ----- | --------- | --------------------------- |
| Q4 क्वांटाइज़्ड | 40GB  | अच्छा     | A100 40GB (\~$0.17/घंटा)    |
| Q8 क्वांटाइज़्ड | 70GB  | बेहतर     | A100 80GB (\~$0.25/घंटा)    |
| FP16 पूर्ण      | 140GB | सर्वोत्तम | 2x A100 80GB (\~$0.50/घंटा) |

**सिफारिश:** सर्वोत्तम कीमत/प्रदर्शन के लिए Q4 क्वांटाइज़ेशन के साथ A100 40GB।

## CLORE.AI पर त्वरित डिप्लॉय

### Ollama का उपयोग करना (सबसे आसान)

**Docker इमेज:**

```
ollama/ollama
```

**पोर्ट:**

```
22/tcp
11434/http
```

**तैनाती के बाद:**

```bash
ollama pull llama3.3
ollama run llama3.3
```

### vLLM का उपयोग करना (उत्पादन)

**Docker इमेज:**

```
vllm/vllm-openai:latest
```

**पोर्ट:**

```
22/tcp
8000/http
```

**कमांड:**

```bash
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.3-70B-Instruct \
    --tensor-parallel-size 1 \
    --max-model-len 32768 \
    --host 0.0.0.0
```

## अपनी सेवा तक पहुँचना

डिप्लॉयमेंट के बाद, अपना खोजें `http_pub` URL में **मेरे ऑर्डर**:

1. जाएँ **मेरे ऑर्डर** पृष्ठ
2. अपने ऑर्डर पर क्लिक करें
3. खोजें `http_pub` URL (उदा., `abc123.clorecloud.net`)

उपयोग करें `https://YOUR_HTTP_PUB_URL` की बजाय `localhost` नीचे दिए उदाहरणों में।

## स्थापना विधियाँ

### विधि 1: Ollama (परीक्षण के लिए अनुशंसित)

```bash
# Ollama इंस्टॉल करें
curl -fsSL https://ollama.com/install.sh | sh

# Llama 3.3 खींचें (स्वतः Q4 संस्करण डाउनलोड होता है)
ollama pull llama3.3

# इंटरैक्टिव रूप से चलाएँ
ollama run llama3.3

# या API पर सर्व करें
ollama serve
```

**API उपयोग:**

```bash
curl http://localhost:11434/api/generate -d '{
  "model": "llama3.3",
  "prompt": "क्वांटम कंप्यूटिंग को सरल शब्दों में समझाइए"
}'
```

### विधि 2: vLLM (उत्पादन)

```bash
pip install vllm

# सिंगल GPU (AWQ क्वांटाइज़ेशन के साथ A100 40GB)
python -m vllm.entrypoints.openai.api_server \
    --model casperhansen/llama-3.3-70b-instruct-awq \
    --quantization awq \
    --max-model-len 16384 \
    --host 0.0.0.0

# मल्टी-GPU (पूर्ण प्रिसीजन के लिए 2x A100)
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.3-70B-Instruct \
    --tensor-parallel-size 2 \
    --max-model-len 32768 \
    --host 0.0.0.0
```

**API उपयोग (OpenAI-अनुकूल):**

```python
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="dummy")

response = client.chat.completions.create(
    model="meta-llama/Llama-3.3-70B-Instruct",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Python फ़ंक्शन लिखें जो फ़िबोनाच्ची संख्याएँ गणना करे"}
    ],
    temperature=0.7,
    max_tokens=1024
)

print(response.choices[0].message.content)
```

### विधि 3: Transformers + bitsandbytes

```python
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig

# 4-बिट क्वांटाइज़ेशन कॉन्फ़िग
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16
)

model_id = "meta-llama/Llama-3.3-70B-Instruct"

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    quantization_config=bnb_config,
    device_map="auto"
)

# जनरेट करें
messages = [
    {"role": "system", "content": "आप एक सहायक कोडिंग असिस्टेंट हैं."},
    {"role": "user", "content": "BeautifulSoup का उपयोग करके एक Python वेब स्क्रेपर लिखें"}
]

input_ids = tokenizer.apply_chat_template(
    messages,
    return_tensors="pt"
).to("cuda")

outputs = model.generate(
    input_ids,
    max_new_tokens=512,
    temperature=0.7,
    do_sample=True
)

print(tokenizer.decode(outputs[0], skip_special_tokens=True))
```

### विधि 4: llama.cpp (CPU+GPU हाइब्रिड)

```bash
# क्लोन और बिल्ड करें
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
make LLAMA_CUDA=1

# GGUF मॉडल डाउनलोड करें
wget https://huggingface.co/bartowski/Llama-3.3-70B-Instruct-GGUF/resolve/main/Llama-3.3-70B-Instruct-Q4_K_M.gguf

# सर्वर चलाएँ
./llama-server \
    -m Llama-3.3-70B-Instruct-Q4_K_M.gguf \
    -c 8192 \
    -ngl 80 \
    --host 0.0.0.0 \
    --port 8080
```

## बेंचमार्क्स

### थ्रूपुट (टोकन/सेकंड)

| GPU          | Q4    | Q8    | FP16  |
| ------------ | ----- | ----- | ----- |
| A100 40GB    | 25-30 | -     | -     |
| A100 80GB    | 35-40 | 25-30 | -     |
| 2x A100 80GB | 50-60 | 40-45 | 30-35 |
| H100 80GB    | 60-70 | 45-50 | 35-40 |

### पहले टोकन तक का समय (TTFT)

| GPU          | Q4       | FP16     |
| ------------ | -------- | -------- |
| A100 40GB    | 0.8-1.2s | -        |
| A100 80GB    | 0.6-0.9s | -        |
| 2x A100 80GB | 0.4-0.6s | 0.8-1.0s |

### संदर्भ लंबाई बनाम VRAM

| संदर्भ | Q4 VRAM | Q8 VRAM |
| ------ | ------- | ------- |
| 4K     | 38GB    | 72GB    |
| 8K     | 40GB    | 75GB    |
| 16K    | 44GB    | 80GB    |
| 32K    | 52GB    | 90GB    |
| 64K    | 68GB    | 110GB   |
| 128K   | 100GB   | 150GB   |

## उपयोग के मामले

### कोड जेनरेशन

```python
messages = [
    {"role": "system", "content": "आप एक विशेषज्ञ प्रोग्रामर हैं। साफ़, कुशल, और अच्छी तरह से दस्तावेज़ित कोड लिखें."},
    {"role": "user", "content": "JWT टोकन का उपयोग करके उपयोगकर्ता प्रमाणीकरण के साथ FastAPI में एक REST API बनाएं"}
]
```

### दस्तावेज़ विश्लेषण (लंबा संदर्भ)

```python
# लंबा दस्तावेज़ लोड करें
with open("large_document.txt") as f:
    document = f.read()

messages = [
    {"role": "system", "content": "आप एक दस्तावेज़ विश्लेषक हैं। विस्तृत, सटीक विश्लेषण प्रदान करें."},
    {"role": "user", "content": f"इस दस्तावेज़ का विश्लेषण करें और मुख्य बिंदुओं के साथ एक सारांश दें:\n\n{document}"}
]
```

### बहुभाषी कार्य

```python
messages = [
    {"role": "system", "content": "आप एक बहुभाषी सहायक हैं."},
    {"role": "user", "content": "इसे जर्मन, फ्रेंच, और स्पेनिश में अनुवाद करें: 'The quick brown fox jumps over the lazy dog'"}
]
```

### तर्क और विश्लेषण

```python
messages = [
    {"role": "system", "content": "कदम-दर-कदम सोचें। अपना तर्क दिखाएं."},
    {"role": "user", "content": "एक ट्रेन स्टेशन A से सुबह 9:00 बजे 60 मील/घंटा की गति से निकलती है। दूसरी ट्रेन स्टेशन B (300 मील दूर) से सुबह 10:00 बजे स्टेशन A की ओर 90 मील/घंटा की गति से निकलती है। वे कब और कहाँ मिलते हैं?"}
]
```

## अनुकूलन सुझाव

### मेमोरी अनुकूलन

```python
# vLLM मेमोरी अनुकूलन के साथ
python -m vllm.entrypoints.openai.api_server \
    --model casperhansen/llama-3.3-70b-instruct-awq \
    --quantization awq \
    --gpu-memory-utilization 0.95 \
    --max-model-len 8192
```

### गति अनुकूलन

```python
# Flash Attention सक्षम करें
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.3-70B-Instruct \
    --tensor-parallel-size 2 \
    --enable-prefix-caching
```

### बैच प्रोसेसिंग

```python
# एक साथ कई अनुरोध कुशलतापूर्वक प्रोसेस करें
responses = client.chat.completions.create(
    model="meta-llama/Llama-3.3-70B-Instruct",
    messages=messages,
    n=4,  # 4 प्रतिक्रियाएँ उत्पन्न करें
    temperature=0.8
)
```

## अन्य मॉडलों के साथ तुलना

| फ़ीचर   | Llama 3.3 70B | Llama 3.1 70B | Qwen 2.5 72B | Mixtral 8x22B |
| ------- | ------------- | ------------- | ------------ | ------------- |
| MMLU    | 86.0          | 83.6          | 85.3         | 77.8          |
| कोडिंग  | 88.4          | 80.5          | 85.4         | 75.5          |
| गणित    | 77.0          | 68.0          | 80.0         | 60.0          |
| संदर्भ  | 128K          | 128K          | 128K         | 64K           |
| भाषाएँ  | 8             | 8             | 29           | 8             |
| लाइसेंस | खोलें         | खोलें         | खोलें        | खोलें         |

**निष्कर्ष:** Llama 3.3 70B अपने वर्ग में सर्वश्रेष्ठ समग्र प्रदर्शन प्रदान करता है, विशेष रूप से कोडिंग और तर्क कौशल के कार्यों के लिए।

## समस्याओं का निवारण

### आउट ऑफ़ मेमोरी

```bash
# AWQ क्वांटाइज़ेशन का उपयोग करें (सबसे मेमोरी कुशल)
--model casperhansen/llama-3.3-70b-instruct-awq --quantization awq

# संदर्भ लंबाई घटाएं
--max-model-len 8192

# टेन्सर पैरेललिज्म का उपयोग करें
--tensor-parallel-size 2
```

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

* पहला अनुरोध मॉडल को GPU पर लोड करता है - 30-60 सेकंड प्रतीक्षा करें
* उपयोग करें `--enable-prefix-caching` तेज़ बाद के अनुरोधों के लिए
* डमी अनुरोध से प्री-वॉर्म करें

### Hugging Face पहुँच

```bash
# HF में लॉगिन करें (गेटेड मॉडल के लिए आवश्यक)
huggingface-cli login

# या पर्यावरण वेरिएबल सेट करें
export HUGGING_FACE_HUB_TOKEN=hf_xxxxx
```

## लागत अनुमान

| सेटअप    | GPU            | $/घंटा  | टोकन/$ |
| -------- | -------------- | ------- | ------ |
| बजट      | A100 40GB (Q4) | \~$0.17 | \~530K |
| संतुलित  | A100 80GB (Q4) | \~$0.25 | \~500K |
| प्रदर्शन | 2x A100 80GB   | \~$0.50 | \~360K |
| अधिकतम   | H100 80GB      | \~$0.50 | \~500K |

## अगले कदम

* [vLLM गाइड](/guides/guides_v2-hi/language-models/vllm.md) - प्रोडक्शन परिनियोजन
* [Ollama गाइड](/guides/guides_v2-hi/language-models/ollama.md) - आसान लोकल सेटअप
* [मल्टी-GPU सेटअप](/guides/guides_v2-hi/advanced/multi-gpu-setup.md) - बड़े मॉडलों तक स्केल करें
* [API एकीकरण](/guides/guides_v2-hi/advanced/api-integration.md) - एप्लीकेशंस बनाएं


---

# Agent Instructions: 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:

```
GET https://docs.clore.ai/guides/guides_v2-hi/language-models/llama33.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.