DeepSeek V3 & R1: MLA Architecture, DeepSeekMoE, and the Reasoning Revolution

2. Shared Experts — Preventing Knowledge Collapse:

DeepSeek separates two expert types:

• Shared experts (~2): always activated, learn universal foundational knowledge
• Routed experts (Top-6 of 254): context-activated, hyper-specialized

This prevents "Knowledge Collapse" — where routed experts redundantly learn similar things instead of specializing.

The combined MLA + DeepSeekMoE result:

• 685B total parameters, only ~37B active per forward pass
• Inference cost equivalent to a 37B dense model
• Quality of a 685B model

FP8 Training — How $5.5M Became Possible

DeepSeek V3 is among the first large models trained entirely with FP8 mixed precision:

• FP16: current standard, 2 bytes/weight
• FP8: 1 byte/weight → 50% reduction in memory and bandwidth
• Custom FP8 gradient communication framework

MLA + MoE + FP8 on H800 cluster = training cost that's achievable at mid-size company scale.

Part 2: DeepSeek R1 — The Reasoning Revolution

Why R1 Is Different

Before R1, every reasoning model (including OpenAI's o1) shared a common approach: supervised fine-tuning (SFT) on human-written chain-of-thought data. This is expensive, slow to annotate, and doesn't scale.

DeepSeek R1 used pure Reinforcement Learning:

R1 Training Pipeline:
1. Cold Start: light training from V3 with some Long-CoT demonstrations
2. RL Stage 1: GRPO with reward = correctness + format compliance
3. Rejection Sampling: filter for high-quality reasoning traces
4. RL Stage 2: Combined SFT + RL for alignment

GRPO (Group Relative Policy Optimization): Instead of a separate critic model, GRPO evaluates response quality by comparing within a group of responses to the same prompt. Correct responses get positive reward, incorrect get negative. The model learns to reason naturally.

Emergent Reasoning Behaviors

Through RL training, R1 developed behaviors never explicitly programmed:

• Self-reflection: "Wait, I made an error in step 3..."
• Backtracking: returning to try different approaches when stuck
• Verification: checking its own final answers
• Exploration: testing multiple approaches before committing

This is why R1's reasoning chains can run thousands of tokens but arrive at correct answers.

R1 vs o1 — Real Benchmarks

R1 wins on math and competitive coding. o1 edges ahead on scientific reasoning. More importantly: R1 is open-weight and free — o1 costs $15/1M output tokens.

Part 3: Self-Hosting R1 — The Practical Guide

Pick the Right Variant for Your Hardware

Best bang for buck for most builders: R1-Distill-Qwen-14B on 1× RTX 4090, or R1-Distill-Qwen-32B at Q4 for better accuracy.

Deploy with Ollama (Development)

# Install Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Run R1 14B (auto-downloads and quantizes)
ollama run deepseek-r1:14b

# Or 32B for better accuracy
ollama run deepseek-r1:32b

# Expose OpenAI-compatible API
OLLAMA_HOST=0.0.0.0 ollama serve
# API available at: http://localhost:11434/v1

Custom Modelfile for reasoning optimization:

FROM deepseek-r1:14b
PARAMETER num_ctx 32768
PARAMETER temperature 0.6
SYSTEM "You are an expert problem solver. Think through problems step by step."

ollama create deepseek-r1-reasoning -f Modelfile

Deploy with vLLM (Production)

pip install vllm

# Serve R1-Distill-32B with AWQ quantization
python -m vllm.entrypoints.openai.api_server \
  --model deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
  --tensor-parallel-size 2 \
  --quantization awq \
  --max-model-len 32768 \
  --gpu-memory-utilization 0.92 \
  --served-model-name deepseek-r1

# Test it
curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-r1",
    "messages": [{"role": "user", "content": "Prove that √2 is irrational."}],
    "temperature": 0.6,
    "max_tokens": 8192
  }'

Part 4: Prompt Engineering for R1

Triggering Deep Reasoning

R1 uses <think> tags to wrap its reasoning chain. To get the best results:

from openai import OpenAI

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

response = client.chat.completions.create(
    model="deepseek-r1",
    messages=[
        {
            "role": "system",
            "content": "You are an expert problem solver. Always think carefully before answering."
        },
        {
            "role": "user",
            "content": """
            A SaaS startup has 100 users. Monthly:
            - 15% of users churn
            - New users acquired = current_users × 0.25
            
            After 6 months, how many users? Show work.
            """
        }
    ],
    temperature=0.6,
    max_tokens=8192  # R1 needs tokens to reason
)

Parse Thinking vs Final Answer

def parse_r1_response(content: str) -> dict:
    if "<think>" in content and "</think>" in content:
        think_start = content.index("<think>") + len("<think>")
        think_end = content.index("</think>")
        return {
            "thinking": content[think_start:think_end].strip(),
            "answer": content[think_end + len("</think>"):].strip()
        }
    return {"thinking": "", "answer": content}

result = parse_r1_response(response.choices[0].message.content)
print("Answer:", result["answer"])
# Optionally show reasoning for debugging

When to Use R1 vs V3

Production Tips

# 1. Always stream — CoT chains are long
response = client.chat.completions.create(
    model="deepseek-r1", messages=messages, stream=True
)

# 2. Temperature guide:
# Math/Logic: 0.0–0.3 (deterministic)
# Coding: 0.3–0.6
# Creative reasoning: 0.6–1.0

# 3. Budget control — limit thinking tokens
# Set max_tokens = answer_budget + reasoning_budget
# Typical: 2048 (answer) + 6144 (reasoning) = 8192

Conclusion

DeepSeek isn't just "cheap GPT-4" — it's proof that architectural innovation can beat raw scale. MLA solves the KV cache bottleneck. DeepSeekMoE maximizes expert utilization. FP8 training cuts compute cost. Combined, they built a frontier-class model at startup-accessible cost.

R1 is even more significant: this is the first time pure RL (no human-labeled CoT required) produced a world-class reasoning model. This isn't a fluke — it's the blueprint for the next generation of reasoning models.

Your next steps:

1. Run R1-Distill-14B via Ollama today — works on a single RTX 4090
2. Benchmark it on a real problem from your project
3. Compare reasoning quality against GPT-4o on the same task

Next up: Meta Llama 3.3 70B — why it's the real enterprise workhorse, and how to go production-ready in 30 minutes.