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

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

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

अवलोकन

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

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

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

स्पष्ट चेन-ऑफ-थॉट — हर प्रतिक्रिया एक से शुरू होती है <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 डिस्क

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

Llama 3

16 GB

6 GB

5.5 GB

R1-Distill-Qwen-7B

Qwen 2.5

14 GB

5 GB

4.5 GB

R1-Distill-Qwen-1.5B

1.5B

Qwen 2.5

3 GB

2 GB

1.2 GB

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

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

अनुशंसित वेरिएंट

Clore पर GPU

त्वरित प्रयोग, एज परीक्षण

R1-Distill-Qwen-1.5B

कोई भी GPU

बजट तैनाती, तेज़ इन्फरेंस

R1-Distill-Qwen-7B

RTX 3090 (~$0.30–1/दिन)

सिंगल-GPU प्रोडक्शन का स्विट स्पॉट

R1-Distill-Qwen-14B Q4

RTX 4090 (~$0.50–2/दिन)

सबसे अच्छा गुणवत्ता-प्रति-डॉलर (अनुशंसित)

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 डिस्टिल

deepseek-ai/DeepSeek-R1-Distill-Llama-70B

Qwen-32B डिस्टिल

deepseek-ai/DeepSeek-R1-Distill-Qwen-32B

Qwen-14B डिस्टिल

deepseek-ai/DeepSeek-R1-Distill-Qwen-14B

Llama-8B डिस्टिल

deepseek-ai/DeepSeek-R1-Distill-Llama-8B

Qwen-7B डिस्टिल

deepseek-ai/DeepSeek-R1-Distill-Qwen-7B

Qwen-1.5B डिस्टिल

deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B

आवश्यकताएँ

घटक

न्यूनतम (7B Q4)

अनुशंसित (32B Q4)

GPU VRAM

6 GB

24 GB

सिस्टम RAM

16 GB

32 GB

डिस्क

10 GB

30 GB

CUDA

12.1+

12.4+

Docker

24.0+

25.0+

Ollama त्वरित प्रारंभ

Ollama स्वतः क्वांटाइज़ेशन, डाउनलोड और सर्विंग को संभालता है — चलने वाले 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": "Factor x^4 - 1 completely over the integers."}],
    "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": "Write a Python function to find the longest palindromic substring."}
    ],
    temperature=0.6,
    max_tokens=4096,
)
print(response.choices[0].message.content)

vLLM प्रोडक्शन सेटअप

vLLM बहु-उपयोगकर्ता सर्विंग के लिए निरंतर बैचिंग, PagedAttention, और प्रिफिक्स कैशिंग के साथ उच्चतम थ्रूपुट देता है।

सिंगल 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 एंडपॉइंट को क्वेरी करें

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": "Solve: find all primes p such that p^2 + 2 is also prime."}],
    "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 = "What is the sum of the first 100 positive integers?"
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 प्रतिक्रिया को सोचने और उत्तर हिस्सों में विभाजित करें."""
    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"Model reasoned for {result['thinking_tokens']} words")
print(f"Answer: {result['answer']}")

स्ट्रीमिंग के साथ `<think>` स्थिति ट्रैकिंग

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": "Derive the quadratic formula from 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("[Reasoning] ", end="", flush=True)
        continue
    if "</think>" in token:
        in_think = False
        print("\n[Answer] ", end="", flush=True)
        continue
    if not in_think:
        print(token, end="", flush=True)
print()

Clore.ai पर Docker तैनाती

Ollama Docker (सबसे सरल)

Docker इमेज: 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 इमेज: 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 पर तैनात करें:

खोलें clore.ai/marketplace
फ़िल्टर करें 2× GPU, कुल 48 GB+ VRAM (उदा. 2× RTX 4090 या A100 80 GB)
Docker इमेज को सेट करें vllm/vllm-openai:latest
पोर्ट मैप करें 8000 को HTTP के रूप में
ऊपर compose फ़ाइल से कमांड को स्टार्टअप कमांड में पेस्ट करें
स्वास्थ्य जांच पास होने के बाद HTTP एंडपॉइंट के माध्यम से कनेक्ट करें

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

प्रदर्शन ट्यूनिंग

टेेम्परेचर 0.6 तर्क कार्यों के लिए अनुशंसित डिफ़ॉल्ट है — DeepSeek के अपने पेपर्स इस मान का उपयोग करते हैं
सेट करें max_tokens उदारतापूर्वक — तर्क मॉडल लंबे उत्पन्न करते हैं <think> ब्लॉक्स; गैर-त्रिवेणी समस्याओं के लिए 4096+
प्रिफिक्स कैशिंग सक्षम करें (--enable-prefix-caching जब साझा सिस्टम प्रॉम्प्ट का उपयोग कर रहे हों तो vLLM में)
समानांतरता सीमित करें (--max-num-seqs 16) तर्क कार्यभार के लिए — हर अनुरोध मानक चैट की तुलना में अधिक कंप्यूट उपयोग करता है
Q4 क्वांटाइज़ेशन का उपयोग करें एकल 24 GB GPU पर न्यूनतम गुणवत्ता हानि के साथ 32B फिट करने के लिए (डिस्टिल पहले ही R1 के ज्ञान को संपीड़ित कर देता है)

संदर्भ लंबाई विचार

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

कार्य जटिलता

सामान्य सोचने की लंबाई

कुल संदर्भ आवश्यकता

सरल अंकगणित

~100 टोकन

~300 टोकन

कोड जनरेशन

~500–1000 टोकन

~2000 टोकन

प्रतियोगिता गणित (AIME)

~2000–4000 टोकन

~5000 टोकन

बहु-चरण अनुसंधान विश्लेषण

~4000–8000 टोकन

~10000 टोकन

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

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

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

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

# क्वांटाइज़ेशन का उपयोग करें
--quantization awq      # या gptq

मॉडल कोई भी उत्पन्न नहीं करता `<think>` ब्लॉक

कुछ सिस्टम प्रॉम्प्ट सोच को दबा देते हैं। "संक्षेप में रहें" या "अपना तर्क न समझाएँ" जैसी निर्देशों से बचें। एक न्यूनतम सिस्टम प्रॉम्प्ट का उपयोग करें या बिलकुल न रखें:

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

# खराब — सोच को दबा सकता है
messages = [
    {"role": "system", "content": "Be extremely brief. No explanations."},
    {"role": "user", "content": "..."}
]

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

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

temperature = 0.0   # निर्धारित — गणित/कोड के लिए सर्वश्रेष्ठ
temperature = 0.3   # हल्का परिवर्तन — विश्लेषण के लिए अच्छा

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

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

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

कुछ प्रदाताओं पर HuggingFace डाउनलोड धीमे हो सकते हैं। मॉडल को एक स्थायी वॉल्यूम में पहले से कैश करें:

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

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

अधिक पढ़ने के लिए

DeepSeek-R1 पेपर — Incentivizing Reasoning Capability in LLMs via Reinforcement Learning
DeepSeek-R1 GitHub — माडल कार्ड्स के साथ आधिकारिक रिपॉज़िटरी
DeepSeek-V3 गाइड — उसी लैब का गैर-तर्क-संबंधी सामान्य-उद्देश्य मॉडल
vLLM गाइड — व्यापक प्रोडक्शन सर्विंग सेटअप
Ollama गाइड — किसी भी मॉडल के लिए सरल स्थानीय तैनाती
Open WebUI गाइड — नेटिव के साथ चैट UI <think> टैग रेंडरिंग
Qwen 2.5 गाइड — अधिकांश R1 डिस्टिल्स द्वारा उपयोग की जाने वाली बेस आर्किटेक्चर

PreviousDeepSeek-V3 NextQwen2.5

Last updated 1 day ago

Was this helpful?

hashtagअवलोकन

hashtagप्रमुख विशेषताएँ

hashtagमॉडल वेरिएंट

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

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

hashtagआवश्यकताएँ

hashtagOllama त्वरित प्रारंभ

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

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

hashtagOpenAI-अनुकूल API का उपयोग करें

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

hashtagvLLM प्रोडक्शन सेटअप

hashtagसिंगल GPU — 7B / 14B

hashtagमल्टी-GPU — 32B (अनुशंसित)

hashtagमल्टी-GPU — 70B

hashtagvLLM एंडपॉइंट को क्वेरी करें

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

hashtagबेसिक जेनरेशन

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

hashtagस्ट्रीमिंग के साथ <think> स्थिति ट्रैकिंग

hashtagClore.ai पर Docker तैनाती

hashtagOllama Docker (सबसे सरल)

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

hashtagClore.ai तैनातियों के लिए टिप्स

hashtagसही GPU चुनना

hashtagप्रदर्शन ट्यूनिंग

hashtagसंदर्भ लंबाई विचार

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

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

hashtagमॉडल कोई भी उत्पन्न नहीं करता <think> ब्लॉक

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

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

hashtagClore इंस्टेंस पर डाउनलोड रुकता है

hashtagअधिक पढ़ने के लिए

अवलोकन

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

मॉडल वेरिएंट

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

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

आवश्यकताएँ

Ollama त्वरित प्रारंभ

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

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

OpenAI-अनुकूल API का उपयोग करें

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

vLLM प्रोडक्शन सेटअप

सिंगल GPU — 7B / 14B

मल्टी-GPU — 32B (अनुशंसित)

मल्टी-GPU — 70B

vLLM एंडपॉइंट को क्वेरी करें

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

बेसिक जेनरेशन

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

स्ट्रीमिंग के साथ `<think>` स्थिति ट्रैकिंग

Clore.ai पर Docker तैनाती

Ollama Docker (सबसे सरल)

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

Clore.ai तैनातियों के लिए टिप्स

सही GPU चुनना

प्रदर्शन ट्यूनिंग

संदर्भ लंबाई विचार

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

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

मॉडल कोई भी उत्पन्न नहीं करता `<think>` ब्लॉक

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

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

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

अधिक पढ़ने के लिए