Llama 3.3 70B

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

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

CLORE.AI GPUs पर मेटा का नवीनतम और सबसे कुशल 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 सामुदायिक लाइसेंस

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

बेंचमार्क	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

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

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": "You are a helpful assistant."},
        {"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 एकीकरण - एप्लीकेशंस बनाएं