SGLang

उच्च-प्रदर्शन LLM सर्विंग के लिए RadixAttention के साथ SGLang को Clore.ai GPUs पर तैनात करें

SGLang (Structured Generation Language) एक उच्च-प्रदर्शन LLM सर्विंग फ्रेमवर्क है जिसे LMSYS टीम ने विकसित किया है, जो Vicuna और Chatbot Arena पर अपने काम के लिए जानी जाती है। इसमें KV कैश साझा करने के लिए RadixAttention, कुशल MoE (Mixture of Experts) समर्थन, और OpenAI-संगत API शामिल है — जो इसे CLORE.AI GPU सर्वरों पर उपलब्ध सबसे तेज़ ओपन-सोर्स इनफरेंस इंजनों में से एक बनाता है।

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

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

पैरामीटर	न्यूनतम	अनुशंसित
रैम	16 GB	32 GB+
वीरैम (VRAM)	8 GB	24 GB+
डिस्क	50 GB	200 GB+
GPU	NVIDIA Turing+ (RTX 2000+)	A100, H100, RTX 4090

SGLang Ampere+ GPUs पर FlashInfer सक्षम होने पर सर्वश्रेष्ठ प्रदर्शन प्राप्त करता है। Mixtral या DeepSeek जैसे MoE मॉडल के लिए मल्टी-GPU सेटअप की सिफारिश की जाती है।

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

Docker इमेज: lmsysorg/sglang:latest

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

पर्यावरण चर:

वेरिएबल	उदाहरण	विवरण
HF_TOKEN	hf_xxx...	गेटेड मॉडलों के लिए HuggingFace टोकन
CUDA_VISIBLE_DEVICES	0,1	उपयोग करने के लिए GPUs

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

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

पर जाएँ CLORE.AI मार्केटप्लेस और एक सर्वर चुनें:

• 7B मॉडल: न्यूनतम 16 GB VRAM (RTX 4080, A10)

• 13B मॉडल: 24 GB VRAM (RTX 3090, RTX 4090, A5000)

• 70B मॉडल: 80 GB+ VRAM (A100 80GB) या मल्टी-GPU

• MoE मॉडल (Mixtral 8x7B): 48 GB VRAM या 2× 24 GB

2. अपने सर्वर में SSH करें

ssh -p <PORT> root@<SERVER_IP>

3. SGLang Docker इमेज खींचें

docker pull lmsysorg/sglang:latest

4. SGLang सर्वर लॉन्च करें

बेसिक लॉन्च (Llama 3.1 8B):

docker run -d \
  --name sglang \
  --gpus all \
  --shm-size 16g \
  --ipc host \
  -p 30000:30000 \
  -v /root/models:/root/.cache/huggingface \
  lmsysorg/sglang:latest \
  python3 -m sglang.launch_server \
    --model-path meta-llama/Meta-Llama-3.1-8B-Instruct \
    --host 0.0.0.0 \
    --port 30000

HuggingFace टोकन के साथ:

docker run -d \
  --name sglang \
  --gpus all \
  --shm-size 16g \
  --ipc host \
  -p 30000:30000 \
  -v /root/models:/root/.cache/huggingface \
  -e HF_TOKEN=hf_your_token_here \
  lmsysorg/sglang:latest \
  python3 -m sglang.launch_server \
    --model-path meta-llama/Meta-Llama-3.1-8B-Instruct \
    --host 0.0.0.0 \
    --port 30000 \
    --dtype bfloat16

Qwen2.5 72B मल्टी-GPU पर:

docker run -d \
  --name sglang \
  --gpus all \
  --shm-size 32g \
  --ipc host \
  -p 30000:30000 \
  -v /root/models:/root/.cache/huggingface \
  lmsysorg/sglang:latest \
  python3 -m sglang.launch_server \
    --model-path Qwen/Qwen2.5-72B-Instruct \
    --host 0.0.0.0 \
    --port 30000 \
    --tp 2 \
    --dtype bfloat16

DeepSeek-V2 (MoE मॉडल):

docker run -d \
  --name sglang \
  --gpus all \
  --shm-size 32g \
  --ipc host \
  -p 30000:30000 \
  -v /root/models:/root/.cache/huggingface \
  lmsysorg/sglang:latest \
  python3 -m sglang.launch_server \
    --model-path deepseek-ai/DeepSeek-V2-Lite-Chat \
    --host 0.0.0.0 \
    --port 30000 \
    --trust-remote-code \
    --tp 1

5. सर्वर स्वास्थ्य जाँचें

# लॉग देखें
docker logs -f sglang

# हेल्थ चेक (मॉडल लोड होने में ~2-3 मिनट प्रतीक्षा करें)
curl http://localhost:30000/health

# मॉडल जानकारी प्राप्त करें
curl http://localhost:30000/get_model_info

6. CLORE.AI प्रॉक्सी के माध्यम से बाहरी पहुँच

आपके CLORE.AI डैशबोर्ड में एक प्रदान किया गया है http_pub पोर्ट 30000 के लिए URL:

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

किसी भी OpenAI-संगत क्लाइंट में इसका उपयोग अपने बेस URL के रूप में करें।

---

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

उदाहरण 1: OpenAI-संगत चैट पूर्णताएँ

curl http://localhost:30000/v1/chat/completions \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "meta-llama/Meta-Llama-3.1-8B-Instruct",
    "messages": [
      {"role": "system", "content": "You are a helpful coding assistant."},
      {"role": "user", "content": "Write a quicksort implementation in Python."}
    ],
    "max_tokens": 512,
    "temperature": 0.2
  }'

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

curl http://localhost:30000/v1/chat/completions \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "meta-llama/Meta-Llama-3.1-8B-Instruct",
    "messages": [
      {"role": "user", "content": "Explain how transformer attention works."}
    ],
    "max_tokens": 800,
    "stream": true
  }' \
  --no-buffer

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

from openai import OpenAI

# अपने CLORE.AI SGLang सर्वर की ओर संकेत करें
client = OpenAI(
    base_url="http://localhost:30000/v1",
    api_key="none",  # SGLang डिफ़ॉल्ट रूप से प्रमाणीकरण की आवश्यकता नहीं है
)

response = client.chat.completions.create(
    model="meta-llama/Meta-Llama-3.1-8B-Instruct",
    messages=[
        {"role": "system", "content": "You are a data science expert."},
        {"role": "user", "content": "What is gradient boosting?"},
    ],
    max_tokens=400,
    temperature=0.7,
)

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

उदाहरण 4: SGLang नेटिव API के साथ बैच इनफेरेंस

SGLang का नेटिव API अतिरिक्त नियंत्रण प्रदान करता है:

import requests

# पूर्णताएँ जनरेट करें
response = requests.post(
    "http://localhost:30000/generate",
    json={
        "text": "The future of AI is",
        "sampling_params": {
            "max_new_tokens": 200,
            "temperature": 0.8,
            "top_p": 0.95,
        },
    },
)
print(response.json()["text"])

उदाहरण 5: प्रतिबंधित JSON आउटपुट

SGLang संरचित आउटपुट जेनरेशन का समर्थन करता है:

import requests

schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string"},
        "age": {"type": "integer"},
        "city": {"type": "string"},
    },
    "required": ["name", "age", "city"],
}

response = requests.post(
    "http://localhost:30000/generate",
    json={
        "text": "Extract information: John Smith, 35 years old, lives in New York.",
        "sampling_params": {
            "max_new_tokens": 100,
            "temperature": 0.0,
        },
        "json_schema": schema,
    },
)
print(response.json()["text"])
# आउटपुट: {"name": "John Smith", "age": 35, "city": "New York"}

---

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

मुख्य लॉन्च पैरामीटर

पैरामीटर	डिफ़ॉल्ट	विवरण
--model-path	अनिवार्य	HuggingFace मॉडल ID या स्थानीय पथ
--host	127.0.0.1	हॉस्ट बाइंड करें (बाहरी के लिए उपयोग करें 0.0.0.0 के लिए बाहरी)
--port	30000	सर्वर पोर्ट
--tp	1	टेंसर पैरेललिज्म डिग्री (GPU की संख्या)
--dp	1	डेटा पैरेललिज्म डिग्री
--dtype	auto	float16, bfloat16, float32
--mem-fraction-static	0.88	KV कैश के लिए VRAM का भाग
--max-prefill-tokens	auto	एक प्रिफिल स्टेप में अधिकतम टोकन
--context-length	मॉडल अधिकतम	अधिकतम संदर्भ लंबाई ओवरराइड करें
--trust-remote-code	false	कस्टम मॉडल कोड की अनुमति दें
--quantization	none	awq, gptq, fp8
--load-format	auto	auto, pt, safetensors
--tokenizer-path	मॉडल के समान	कस्टम टोकनाइज़र पथ

क्वांटाइज़ेशन विकल्प

AWQ (गति के लिए अनुशंसित):

python3 -m sglang.launch_server \
  --model-path casperhansen/mistral-7b-instruct-v0.2-awq \
  --quantization awq \
  --host 0.0.0.0 \
  --port 30000

FP8 (H100/A100 के लिए):

python3 -m sglang.launch_server \
  --model-path meta-llama/Meta-Llama-3.1-8B-Instruct \
  --quantization fp8 \
  --host 0.0.0.0 \
  --port 30000

---

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

1. RadixAttention — मुख्य लाभ

SGLang का RadixAttention स्वचालित रूप से साझा प्रॉम्प्ट प्रीफिक्स के लिए KV कैश का पुन: उपयोग करता है। यह विशेष रूप से शक्तिशाली है:

• लंबे सिस्टम प्रॉम्प्ट वाले चैटबॉट्स के लिए

• दोहराए गए संदर्भ वाले RAG एप्लिकेशन्स के लिए

• एक ही प्रीफिक्स साझा करने वाले बैच API कॉल्स के लिए

अतिरिक्त कोई कॉन्फ़िगरेशन आवश्यक नहीं — यह हमेशा सक्षम रहता है।

2. KV कैश आकार बढ़ाएँ

--mem-fraction-static 0.90  # KV कैश के लिए VRAM का 90% उपयोग करें

बहुत अधिक न करें — मॉडल वज़न के लिए स्थान छोड़ें।

3. लंबे संदर्भों के लिए चंकीड प्रिफिल

--chunked-prefill-size 4096  # लंबे प्रॉम्प्ट्स को चंक्स में प्रोसेस करें

4. FlashInfer बैकएंड सक्षम करें

यदि उपलब्ध हो (Ampere+ GPUs), तो SGLang स्वचालित रूप से FlashInfer का उपयोग करता है:

--attention-backend flashinfer

5. मल्टी-GPU टेंसर पैरेललिज्म

उन मॉडलों के लिए जो एक ही GPU पर फिट नहीं होते:

--tp 4  # 4 GPUs उपयोग करें

प्रत्येक GPU के पास मॉडल के एक शार्ड के लिए पर्याप्त VRAM होना चाहिए।

6. थ्रूपुट बनाम लेटेंसी के लिए ट्यून करें

कम विलंबता (एकल उपयोगकर्ता):

--max-running-requests 4

उच्च थ्रूपुट (कई उपयोगकर्ता):

--max-running-requests 64 \
--schedule-policy lpm  # Longest Prefix Match शेड्यूलिंग

---

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

समस्या: "torch.cuda.OutOfMemoryError"

torch.cuda.OutOfMemoryError: CUDA आउट ऑफ मेमोरी

समाधान: मेमोरी फ़्रैक्शन घटाएँ या क्वांटाइज़ेशन का उपयोग करें:

--mem-fraction-static 0.80
# या
--quantization awq

समस्या: सर्वर शुरू नहीं हो रहा (लोडिंग पर अटक जाता है)

# CUDA उपलब्धता जाँचें
docker exec -it sglang nvidia-smi

# मॉडल डाउनलोड प्रगति जाँचें
docker logs -f sglang 2>&1 | tail -50

समस्या: "trust_remote_code required"

लॉन्च कमांड में जोड़ें --trust-remote-code उन मॉडलों के लिए जिनकी कस्टम आर्किटेक्चर हैं (DeepSeek, Falcon, आदि)।

समस्या: MoE मॉडलों पर धीमी जनरेशन

MoE मॉडल (Mixtral, DeepSeek) मेमोरी-बैंडविड्थ बंधित होते हैं। सुनिश्चित करें कि आप इस्तेमाल कर रहे हैं:

--dtype bfloat16  # MoE के लिए float16 से बेहतर
--tp 2            # उपलब्ध हो तो GPUs में विभाजित करें

समस्या: संदर्भ लंबाई त्रुटियाँ

# संदर्भ लंबाई ओवरराइड करें
--context-length 32768

समस्या: पोर्ट 30000 सुलभ नहीं है

सुनिश्चित करें कि पोर्ट आपके CLORE.AI ऑर्डर कॉन्फ़िगरेशन में एक्सपोज़ किया गया है। अपने ऑर्डर डैशबोर्ड में http_pub URL जाँचें, localhost नहीं।

---

लिंक

• GitHub

• डॉक्यूमेंटेशन

• Docker Hub

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

• 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 ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण रूट एक्सेस।