DeepSeek-R1 रीजनिंग मॉडल

Clore.ai GPUs पर DeepSeek-R1 ओपन-सोर्स रीजनिंग मॉडल चलाएँ

सभी उदाहरण GPU सर्वरों पर चलते हैं, जिन्हें के माध्यम से किराये पर लिया गया है CLORE.AI मार्केटप्लेस. RTX 4090 इंस्टेंस $0.14–0.42/घंटा से शुरू होते हैं।

अवलोकन

DeepSeek-R1 एक 671B-पैरामीटर वाला ओपन-वेट रीजनिंग मॉडल है, जिसे जनवरी 2025 में DeepSeek द्वारा के तहत जारी किया गया था Apache 2.0 लाइसेंस। यह पहला ओपन मॉडल है जो गणित, कोडिंग और वैज्ञानिक बेंचमार्क्स में OpenAI o1 की बराबरी करता है — जबकि अपनी पूरी चेन-ऑफ-थॉट को स्पष्ट <think> टैग्स के माध्यम से उजागर करता है।

पूरा मॉडल उपयोग करता है Mixture-of-Experts (MoE) प्रति टोकन 37B सक्रिय पैरामीटर के साथ, जिससे भारी पैरामीटर संख्या के बावजूद इन्फरेंस व्यावहारिक हो जाता है। अधिकांश प्रैक्टिशनरों के लिए, डिस्टिल्ड वेरिएंट्स (1.5B → 70B) अधिक व्यावहारिक हैं: वे ज्ञान-आसवन (knowledge distillation) के माध्यम से Qwen-2.5 और Llama-3 बेस आर्किटेक्चर में R1 के रीजनिंग पैटर्न को विरासत में लेते हैं और सामान्य GPU पर चलते हैं।

मुख्य विशेषताएँ

• स्पष्ट चेन-ऑफ-थॉट — हर उत्तर एक <think> ब्लॉक से शुरू होता है जहाँ मॉडल अंतिम उत्तर देने से पहले तर्क करता है, वापस जाँचता है, और स्वयं-सुधार करता है

• रीइन्फोर्समेंट-लर्निंग से प्रशिक्षित — रीजनिंग क्षमता हाथ से लिखे गए चेन-ऑफ-थॉट डेटा के बजाय RL रिवॉर्ड सिग्नल्स से उभरती है

• छह डिस्टिल्ड वेरिएंट्स — 1.5B, 7B, 8B, 14B, 32B, 70B पैरामीटर मॉडल्स, जिन्हें पूर्ण 671B से Qwen और Llama आर्किटेक्चर में डिस्टिल किया गया है

• Apache 2.0 लाइसेंस — पूरी तरह व्यावसायिक, कोई रॉयल्टी नहीं, कोई उपयोग-प्रतिबंध नहीं

• व्यापक फ्रेमवर्क समर्थन — Ollama, vLLM, llama.cpp, SGLang, Transformers, TGI सभी बिना किसी अतिरिक्त सेटअप के काम करते हैं

• AIME 2024 Pass@1: 79.8% — प्रतियोगिता गणित में OpenAI o1 के बराबर

• Codeforces 2029 Elo — प्रतिस्पर्धी प्रोग्रामिंग में o1 के 1891 से बेहतर

मॉडल वेरिएंट

वैरिएंट	पैरामीटर	आर्किटेक्चर	FP16 VRAM	Q4 VRAM	Q4 Disk
DeepSeek-R1 (पूर्ण MoE)	671B (37B सक्रिय)	DeepSeek MoE	~1.3 TB	~350 GB	~340 GB
R1-Distill-Llama-70B	70B	Llama 3	140 GB	40 GB	42 GB
R1-Distill-Qwen-32B	32B	Qwen 2.5	64 GB	22 GB	20 GB
R1-Distill-Qwen-14B	14B	Qwen 2.5	28 GB	10 GB	9 GB
R1-Distill-Llama-8B	8B	Llama 3	16 GB	6 GB	5.5 GB
R1-Distill-Qwen-7B	7B	Qwen 2.5	14 GB	5 GB	4.5 GB
R1-Distill-Qwen-1.5B	1.5B	Qwen 2.5	3 GB	2 जीबी	1.2 GB

वेरिएंट चुनना

उपयोग-प्रकरण	अनुशंसित वेरिएंट	Clore पर GPU
त्वरित प्रयोग, एज टेस्टिंग	R1-Distill-Qwen-1.5B	कोई भी GPU
बजट डिप्लॉयमेंट, तेज इन्फरेंस	R1-Distill-Qwen-7B	RTX 3090 ($0.07–0.21/घंटा)
एकल-GPU प्रोडक्शन का आदर्श विकल्प	R1-Distill-Qwen-14B Q4	RTX 4090 ($0.14–0.42/घंटा)
कीमत के मुकाबले सर्वोत्तम गुणवत्ता (अनुशंसित)	R1-Distill-Qwen-32B Q4	RTX 4090 24 GB या A100 40 GB
अधिकतम डिस्टिल्ड गुणवत्ता	R1-Distill-Llama-70B	2× A100 80 GB
अनुसंधान, पूर्ण-निष्ठा रीजनिंग	DeepSeek-R1 671B	8× H100 क्लस्टर

HuggingFace रिपॉज़िटरीज़

वैरिएंट	रिपॉज़िटरी
पूर्ण R1	deepseek-ai/DeepSeek-R1
Llama-70B distill	deepseek-ai/DeepSeek-R1-Distill-Llama-70B
Qwen-32B distill	deepseek-ai/DeepSeek-R1-Distill-Qwen-32B
Qwen-14B distill	deepseek-ai/DeepSeek-R1-Distill-Qwen-14B
Llama-8B distill	deepseek-ai/DeepSeek-R1-Distill-Llama-8B
Qwen-7B distill	deepseek-ai/DeepSeek-R1-Distill-Qwen-7B
Qwen-1.5B distill	deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B

आवश्यकताएँ

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 का आकार तय करने से पहले।

घटक	न्यूनतम (7B Q4)	अनुशंसित (32B Q4)
GPU VRAM	6 GB	24 GB
System RAM	16 GB	32 GB
डिस्क	10 GB	30 GB
CUDA	12.8+	12.8+
Docker	24.0+	25.0+

Ollama क्विक स्टार्ट

Ollama quantization, डाउनलोडिंग, और सर्विंग को अपने-आप संभालता है — चल रहे DeepSeek-R1 तक पहुँचने का सबसे तेज़ रास्ता।

इंस्टॉल करें और चलाएँ

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

# पुल करें और चलाएँ (अपना वेरिएंट चुनें):
ollama run deepseek-r1:1.5b    # एज / टेस्टिंग
ollama run deepseek-r1:7b      # बजट — किसी भी 8 GB+ GPU पर फिट
ollama run deepseek-r1:14b     # RTX 4090 का आदर्श विकल्प
ollama run deepseek-r1:32b     # A100 / 2× RTX 4090
ollama run deepseek-r1:70b     # 2× A100 80 GB

उदाहरणात्मक इंटरैक्टिव सत्र

>>> सिद्ध करें कि √2 अपरिमेय है।

<think>
मैं विरोधाभास द्वारा प्रमाण का उपयोग करूँगा।
मान लें कि √2 परिमेय है, इसलिए √2 = p/q जहाँ p,q पूर्णांक हैं और gcd(p,q) = 1।
तब 2 = p²/q², जिससे p² = 2q² मिलता है।
इसका अर्थ है कि p² सम है, इसलिए p भी सम होना चाहिए। p = 2k लिखें।
स्थानापन्न करें: (2k)² = 2q² → 4k² = 2q² → q² = 2k²।
तो q² भी सम है, जिसका अर्थ है q सम है।
लेकिन यदि p और q दोनों सम हैं, तो gcd(p,q) ≥ 2, जो हमारी धारणा के विरुद्ध है।
</think>

**सिद्धि कि √2 अपरिमेय है (विरोधाभास द्वारा):**

मान लें √2 = p/q न्यूनतम रूप में है (gcd(p,q) = 1)। वर्ग करने पर p² = 2q² मिलता है।
चूँकि p² सम है, p सम है — p = 2k लिखें। तब 4k² = 2q², इसलिए q² = 2k²,
जिसका अर्थ है q भी सम है। यह gcd(p,q) = 1 के विरुद्ध है। ∎

OpenAI-संगत API का उपयोग करें

# Ollama को सर्वर के रूप में शुरू करें (यदि पहले से नहीं चल रहा है)
ollama serve &

# curl के माध्यम से क्वेरी करें
curl -s http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-r1:32b",
    "messages": [{"role": "user", "content": "पूर्णांकों पर x^4 - 1 का पूर्ण गुणनखंड करें।"}],
    "temperature": 0.6
  }' | python3 -m json.tool

Python क्लाइंट (OpenAI SDK के माध्यम से)

from openai import OpenAI

client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")

response = client.chat.completions.create(
    model="deepseek-r1:32b",
    messages=[
        {"role": "user", "content": "सबसे लंबा palindromic substring खोजने के लिए एक Python फ़ंक्शन लिखें।"}
    ],
    temperature=0.6,
    max_tokens=4096,
)
print(response.choices[0].message.content)

vLLM उत्पादन सेटअप

vLLM निरंतर batching, PagedAttention, और prefix caching के साथ multi-user serving के लिए उच्चतम throughput प्रदान करता है।

एकल GPU — 7B / 14B

pip install vllm

# किसी भी 16 GB+ GPU पर 7B
vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-7B \
    --host 0.0.0.0 --port 8000 \
    --max-model-len 16384

# RTX 4090 (24 GB) पर 14B
vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-14B \
    --host 0.0.0.0 --port 8000 \
    --max-model-len 16384 \
    --gpu-memory-utilization 0.92

बहु-GPU — 32B (अनुशंसित)

vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
    --host 0.0.0.0 --port 8000 \
    --tensor-parallel-size 2 \\
    --max-model-len 32768 \\
    --gpu-memory-utilization 0.90 \
    --enable-prefix-caching

सुझाव: 32B Q4 GPTQ या AWQ चेकपॉइंट एकल RTX 4090 (24 GB) पर फिट बैठता है:

vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
    --quantization awq --host 0.0.0.0 --port 8000 \
    --max-model-len 16384

बहु-GPU — 70B

vllm serve deepseek-ai/DeepSeek-R1-Distill-Llama-70B \
    --host 0.0.0.0 --port 8000 \
    --tensor-parallel-size 4 \
    --max-model-len 32768 \\
    --gpu-memory-utilization 0.90

vLLM endpoint को क्वेरी करें

curl -s http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
    "messages": [{"role": "user", "content": "हल करें: ऐसे सभी अभाज्य p खोजें कि p^2 + 2 भी अभाज्य हो।"}],
    "temperature": 0.6,
    "max_tokens": 4096
  }'

Transformers / Python (साथ में <think> टैग पार्सिंग)

जब आपको जनरेशन पर सूक्ष्म नियंत्रण चाहिए या R1 को Python पाइपलाइन में एकीकृत करना हो, तब HuggingFace Transformers का उपयोग करें।

बुनियादी जनरेशन

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch, re

MODEL = "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B"

tokenizer = AutoTokenizer.from_pretrained(MODEL, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    MODEL,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True,
)

prompt = "पहले 100 धनात्मक पूर्णांकों का योग क्या है?"
messages = [{"role": "user", "content": prompt}]
input_text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tokenizer(input_text, return_tensors="pt").to(model.device)

with torch.no_grad():
    output = model.generate(
        **inputs,
        max_new_tokens=2048,
        temperature=0.6,
        do_sample=True,
    )

full_response = tokenizer.decode(output[0][inputs["input_ids"].shape[-1]:], skip_special_tokens=True)
print(full_response)

पार्सिंग <think> टैग्स

def parse_r1_response(text: str) -> dict:
    """DeepSeek-R1 response को सोचने और उत्तर भागों में विभाजित करें।"""
    think_match = re.search(r"<think>(.*?)</think>", text, re.DOTALL)
    thinking = think_match.group(1).strip() if think_match else ""
    answer = re.sub(r"<think>.*?</think>", "", text, flags=re.DOTALL).strip()
    return {
        "thinking": thinking,
        "answer": answer,
        "thinking_tokens": len(thinking.split()),
    }

result = parse_r1_response(full_response)
print(f"मॉडल ने {result['thinking_tokens']} शब्दों तक तर्क किया")
print(f"उत्तर: {result['answer']}")

साथ में स्ट्रीमिंग <think> state tracking

from openai import OpenAI

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

stream = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
    messages=[{"role": "user", "content": "ax² + bx + c = 0 से द्विघात सूत्र व्युत्पन्न करें।"}],
    stream=True,
    max_tokens=4096,
    temperature=0.6,
)

in_think = False
for chunk in stream:
    token = chunk.choices[0].delta.content or ""
    if "<think>" in token:
        in_think = True
        print("[तर्क] ", end="", flush=True)
        continue
    if "</think>" in token:
        in_think = False
        print("\n[उत्तर] ", end="", flush=True)
        continue
    if not in_think:
        print(token, end="", flush=True)
print()

Clore.ai पर Docker डिप्लॉयमेंट

Ollama Docker (सबसे सरल)

Docker image: ollama/ollama पोर्ट: 22/tcp, 11434/http

# Clore इंस्टेंस पर
docker run -d --gpus all \
    -v ollama_data:/root/.ollama \\
    -p 11434:11434 \
    --name deepseek-r1 \
    ollama/ollama

# मॉडल को पुल करें और सर्व करें
docker exec deepseek-r1 ollama pull deepseek-r1:32b

vLLM Docker (प्रोडक्शन)

Docker image: vllm/vllm-openai:latest पोर्ट: 22/tcp, 8000/http

# docker-compose.yml
version: "3.8"
services:
  deepseek-r1:
    image: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    volumes:
      - hf_cache:/root/.cache/huggingface
    environment:
      - HUGGING_FACE_HUB_TOKEN=${HF_TOKEN:-}
    command: >
      --model deepseek-ai/DeepSeek-R1-Distill-Qwen-32B
      --host 0.0.0.0 --port 8000
      --tensor-parallel-size 2
      --max-model-len 32768
      --gpu-memory-utilization 0.90
      --enable-prefix-caching
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 300s
volumes:
  hf_cache:

Clore.ai पर डिप्लॉय करें:

1. खोलें clore.ai/marketplace

2. के अनुसार फ़िल्टर करें 2× GPU, कुल 48 GB+ VRAM (उदा. 2× RTX 4090 या A100 80 GB)

3. Docker image को सेट करें vllm/vllm-openai:latest

4. पोर्ट मैप करें 8000 को HTTP के रूप में

5. ऊपर दिए गए compose फ़ाइल से कमांड को startup command में पेस्ट करें

6. health check पास हो जाने के बाद HTTP endpoint के माध्यम से कनेक्ट करें

Clore.ai डिप्लॉयमेंट के लिए सुझाव

सही GPU चुनना

बजट	GPU	दैनिक लागत	सर्वोत्तम वेरिएंट
न्यूनतम	RTX 3090 (24 GB)	$0.30 – 1.00	R1-Distill-Qwen-7B या 14B Q4
मानक	RTX 4090 (24 GB)	$0.50 – 2.00	R1-Distill-Qwen-14B FP16 या 32B Q4
प्रोडक्शन	A100 80 GB	$3 – 8	R1-Distill-Qwen-32B FP16
उच्च गुणवत्ता	2× A100 80 GB	$6 – 16	R1-Distill-Llama-70B FP16

प्रदर्शन अनुकूलन

• Temperature 0.6 रीजनिंग कार्यों के लिए अनुशंसित डिफ़ॉल्ट है — DeepSeek के अपने पेपर्स इसी मान का उपयोग करते हैं

• सेट करें max_tokens उदारता से — रीजनिंग मॉडल लंबे <think> ब्लॉक उत्पन्न करते हैं; गैर-तुच्छ समस्याओं के लिए 4096+

• prefix caching सक्षम करें (--enable-prefix-caching vLLM में) जब साझा सिस्टम प्रॉम्प्ट का उपयोग कर रहे हों

• concurrency सीमित करें (--max-num-seqs 16) रीजनिंग workloads के लिए — प्रत्येक अनुरोध मानक चैट से अधिक compute उपयोग करता है

• Q4 quantization का उपयोग करें ताकि 32B को एकल 24 GB GPU पर न्यूनतम गुणवत्ता हानि के साथ फिट किया जा सके (distill पहले से ही R1 के ज्ञान को संपीड़ित करता है)

context length संबंधी विचार

रीजनिंग मॉडल मानक चैट मॉडल्स की तुलना में अधिक context उपयोग करते हैं क्योंकि <think> ब्लॉक:

कार्य जटिलता	सामान्य सोच की लंबाई	आवश्यक कुल context
सरल अंकगणित	~100 tokens	~300 tokens
कोड जनरेशन	~500–1000 tokens	~2000 tokens
प्रतियोगिता गणित (AIME)	~2000–4000 tokens	~5000 tokens
बहु-चरणीय शोध विश्लेषण	~4000–8000 tokens	~10000 tokens

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

मेमोरी से बाहर (OOM)

# संदर्भ लंबाई घटाएँ
--max-model-len 8192    # 32768 के बजाय

# समवर्ती sequences सीमित करें
--max-num-seqs 8

# quantization का उपयोग करें
--quantization awq      # या gptq

मॉडल कोई <think> ब्लॉक

कुछ system prompts सोचने की प्रक्रिया को दबा देते हैं। "be concise" या "don't explain your reasoning." जैसी निर्देशों से बचें। एक न्यूनतम system prompt या बिल्कुल न इस्तेमाल करें:

# अच्छा — तर्क को संरक्षित करता है
messages = [{"role": "user", "content": "..."}]

# खराब — सोचने की प्रक्रिया को दबा सकता है
messages = [
    {"role": "system", "content": "बहुत संक्षिप्त रहें। कोई व्याख्या नहीं।"},
    {"role": "user", "content": "..."}
]

दोहरावदार या लूपिंग <think> आउटपुट

तर्क श्रृंखला में यादृच्छिकता कम करने के लिए temperature घटाएँ:

temperature = 0.0   # निर्धारक — गणित/कोड के लिए सर्वोत्तम
temperature = 0.3   # थोड़ी भिन्नता — विश्लेषण के लिए अच्छा

धीमा पहला टोकन (उच्च TTFT)

यह अपेक्षित है — मॉडल <think> दृश्यमान उत्तर से पहले tokens उत्पन्न करता है। जहाँ latency-संवेदनशील अनुप्रयोगों में रीजनिंग की आवश्यकता नहीं है, वहाँ DeepSeek-V3 का उपयोग करें।

Clore इंस्टेंस पर डाउनलोड अटक जाता है

कुछ providers पर HuggingFace downloads धीमे हो सकते हैं। मॉडल को persistent volume में पहले से cache करें:

# एक बार volume में डाउनलोड करें
huggingface-cli download deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
    --local-dir /data/models/deepseek-r1-32b

# vLLM को स्थानीय path पर इंगित करें
vllm serve /data/models/deepseek-r1-32b --host 0.0.0.0 --port 8000

अधिक पढ़ें

• DeepSeek-R1 पेपर — रीइन्फोर्समेंट लर्निंग के माध्यम से LLMs में तर्क क्षमता को प्रोत्साहित करना

• DeepSeek-R1 GitHub — model cards वाला आधिकारिक repository

• DeepSeek-V3 गाइड — उसी प्रयोगशाला का non-reasoning सामान्य-उद्देश्य मॉडल

• vLLM गाइड — व्यापक production serving सेटअप

• Ollama गाइड — किसी भी मॉडल के लिए सरल स्थानीय डिप्लॉयमेंट

• Open WebUI गाइड — native <think> टैग रेंडरिंग वाला चैट UI

• Qwen 2.5 गाइड — अधिकांश R1 distills द्वारा उपयोग की जाने वाली बेस आर्किटेक्चर