Llama 3.3 70B

Clore.ai GPUs पर Meta का Llama 3.3 70B मॉडल चलाएँ

नया संस्करण उपलब्ध है! Meta द्वारा जारी Llama 4 अप्रैल 2025 में MoE आर्किटेक्चर के साथ — Scout (17B active, RTX 4090 पर फिट हो जाता है) VRAM के बहुत कम हिस्से में समान गुणवत्ता देता है। अपग्रेड करने पर विचार करें।

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

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

Llama 3.3 क्यों?

• सर्वश्रेष्ठ 70B मॉडल - Llama 3.1 405B के प्रदर्शन के बराबर, लागत के बहुत कम हिस्से में

• बहुभाषी - मूल रूप से 8 भाषाओं का समर्थन

• 128K संदर्भ - लंबे दस्तावेज़ों का प्रसंस्करण

• ओपन वेट्स - व्यावसायिक उपयोग के लिए निःशुल्क

मॉडल अवलोकन

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

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

Benchmark	Llama 3.3 70B	Llama 3.1 405B	GPT-4o
MMLU	86.0	87.3	88.7
HumanEval	88.4	89.0	90.2
MATH	77.0	73.8	76.6
बहुभाषी	91.1	91.6	-

GPU आवश्यकताएँ

Clore.ai marketplace पर multi-GPU 80GB-class rigs सूचीबद्ध नहीं हैं। आज सूचीबद्ध सबसे बड़े boxes 4× RTX PRO 6000 Blackwell (प्रत्येक 96GB, कुल 380GB) और 8–11× RTX 5090 (प्रत्येक 32GB) हैं। A100 / H200 / B200 क्षमता bare metal के रूप में अनुरोध पर बेची जाती है। देखें GPU मूल्य और उपलब्धता किसी deployment का आकार तय करने से पहले।

सेटअप	VRAM	प्रदर्शन	लागत
Q4 परिमाणित	40GB	अच्छा	A100 40GB (bare metal)
Q8 परिमाणित	70GB	बेहतर	A100 80GB (bare metal)
FP16 पूर्ण	140GB	सर्वोत्तम	2x A100 80GB (bare metal)

अनुशंसित: सर्वोत्तम मूल्य/प्रदर्शन के लिए Q4 परिमाणीकरण के साथ A100 40GB।

CLORE.AI पर त्वरित परिनियोजन

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

Docker इमेज:

ollama/ollama

पोर्ट:

22/tcp
11434/http

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

ollama pull llama3.3
ollama run llama3.3

vLLM का उपयोग (प्रोडक्शन)

Docker इमेज:

vllm/vllm-openai:latest

पोर्ट:

22/tcp
8000/http

कमांड:

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 (परीक्षण के लिए अनुशंसित)

# 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 उपयोग:

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

विधि 2: vLLM (प्रोडक्शन)

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-संगत):

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": "आप एक सहायक सहायक हैं."},
        {"role": "user", "content": "फ़िबोनाची संख्याओं की गणना करने के लिए एक Python फ़ंक्शन लिखें"}
    ],
    temperature=0.7,
    max_tokens=1024
)

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

विधि 3: Transformers + bitsandbytes

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 हाइब्रिड)

# क्लोन करें और बिल्ड करें
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

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

कोड जनरेशन

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

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

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

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

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

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

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

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

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

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

# मेमोरी अनुकूलन के साथ 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

गति अनुकूलन

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

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

# कई अनुरोधों को कुशलता से संसाधित करें
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 अपनी श्रेणी में, विशेषकर कोडिंग और तर्क कार्यों के लिए, सर्वोत्तम समग्र प्रदर्शन प्रदान करता है।

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

मेमोरी समाप्त

# 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 पहुँच

# 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 गाइड - प्रोडक्शन परिनियोजन

• Ollama गाइड - आसान स्थानीय सेटअप

• मल्टी-GPU सेटअप - बड़े मॉडलों तक स्केल करें

• API एकीकरण - एप्लिकेशन बनाएं