
DeepSeek V3 đại diện cho một bước tiến đáng kể trong kiến trúc mô hình ngôn ngữ lớn (LLM), tích hợp các thành phần mới lạ giải quyết những thách thức mở rộng quy mô quan trọng về bộ nhớ, hiệu quả tính toán và độ ổn định khi huấn luyện. Tài liệu này phân tích chi tiết những đột phá cốt lõi: Multi-Head Latent Attention (MLA), hệ thống chuyên gia DeepSeekMoE và việc triển khai mạnh mẽ huấn luyện hỗn hợp độ chính xác FP8.
Compare token costs, prompt caching discounts & context margins
Model monthly token economics across Gemini 2.5 Flash, DeepSeek R1/V3, Claude 3.5 Sonnet, and GPT-4o with prompt caching discounts, token counter, and markdown export.
Việc bộ nhớ KV cache tăng theo cấp số nhân với độ dài chuỗi trong Multi-Head Attention (MHA) tiêu chuẩn là một nút thắt cổ chai chính đối với các LLM có ngữ cảnh dài. DeepSeek V3 giới thiệu Multi-Head Latent Attention (MLA) để giảm thiểu điều này bằng cách thực hiện nén chung hạng thấp của khóa và giá trị.
Trong MHA tiêu chuẩn, đối với truy vấn Q, khóa K và giá trị V, đầu ra attention là:
\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)VKV cache lưu trữ K và V cho tất cả các token trước đó. Đối với độ dài chuỗi L, kích thước batch B, số lượng head H và chiều head d_k, kích thước KV cache là 2 * B * L * H * d_k.
MLA giới thiệu một phép chiếu không gian tiềm ẩn. Thay vì lưu trữ trực tiếp K và V, DeepSeek V3 chiếu chúng vào một không gian tiềm ẩn có chiều thấp hơn. Gọi K_p và V_p là các khóa và giá trị được chiếu, và K_u và V_u là các khóa và giá trị không được chiếu (hoặc gốc). Ý tưởng cốt lõi là học một xấp xỉ hạng thấp của các cặp KV.
Phép chiếu có thể được hình dung là:
K_p = K W_K^P \quad \text{and} \quad V_p = V W_V^Ptrong đó W_K^P và W_V^P là các ma trận chiếu ánh xạ d_k đến một chiều tiềm ẩn nhỏ hơn nhiều d_l. KV cache sau đó lưu trữ K_p và V_p. Trong quá trình suy luận, Q được sử dụng để chú ý đến các biểu diễn nén này. Đầu ra sau đó được chiếu ngược lại hoặc được sử dụng theo cách kết hợp.
Một công thức chính xác hơn liên quan đến một ma trận tiềm ẩn đã học L có hình dạng lần lượt là (d_l, d_k) và (d_l, d_v). Cơ chế attention sau đó hoạt động trên các biểu diễn nén này. Điểm mấu chốt là thông tin cần thiết cho attention có thể được tóm tắt hiệu quả trong một không gian con có chiều thấp hơn.
DeepSeek V3 đạt được mức giảm 93% dung lượng bộ nhớ KV cache so với MHA tiêu chuẩn. Đây không phải là một phép lấy mẫu giảm đơn giản; đó là một phép nén đã học giữ lại thông tin quan trọng cho việc tính toán attention. Mức giảm này đạt được bằng cách đặt d_l nhỏ hơn đáng kể so với d_k. Ví dụ, nếu d_k = 128 và d_l = 8, hệ số giảm là 128/8 = 16, dẫn đến tiết kiệm bộ nhớ đáng kể.
import torch
import torch.nn as nn
import torch.nn.functional as F
class MultiHeadLatentAttention(nn.Module):
def __init__(self, embed_dim: int, num_heads: int, latent_dim: int, dropout: float = 0.0):
super().__init__()
self.embed_dim = embed_dim
self.num_heads = num_heads
self.head_dim = embed_dim // num_heads
self.latent_dim = latent_dim # d_l, significantly smaller than self.head_dim
if self.head_dim % 8 != 0:
raise ValueError(f"head_dim ({self.head_dim}) must be divisible by 8")
if latent_dim >= self.head_dim:
raise ValueError(f"latent_dim ({latent_dim}) must be smaller than head_dim ({self.head_dim}) for compression")
self.q_proj = nn.Linear(embed_dim, embed_dim, bias=False)
self.k_proj = nn.Linear(embed_dim, embed_dim, bias=False)
self.v_proj = nn.Linear(embed_dim, embed_dim, bias=False)
self.out_proj = nn.Linear(embed_dim, embed_dim, bias=False)
# Latent projection matrices for K and V
# These project from head_dim to latent_dim
self.k_latent_proj = nn.Linear(self.head_dim, self.latent_dim, bias=False)
self.v_latent_proj = nn.Linear(self.head_dim, self.latent_dim, bias=False)
# Latent reconstruction matrices for K and V (optional, or used for hybrid)
# These project from latent_dim back to head_dim
self.k_reconstruct_proj = nn.Linear(self.latent_dim, self.head_dim, bias=False)
self.v_reconstruct_proj = nn.Linear(self.latent_dim, self.head_dim, bias=False)
self.dropout = nn.Dropout(dropout)
def _shape(self, tensor: torch.Tensor, seq_len: int, bsz: int):
return tensor.view(bsz, seq_len, self.num_heads, self.head_dim).transpose(1, 2).contiguous()
def forward(
self,
hidden_states: torch.Tensor,
attention_mask: torch.Tensor = None,
past_key_value: tuple[torch.Tensor, torch.Tensor] = None,
output_attentions: bool = False,
use_cache: bool = False,
) -> tuple[torch.Tensor, tuple[torch.Tensor, torch.Tensor]]:
bsz, q_len, _ = hidden_states.size()
query_states = self.q_proj(hidden_states)
key_states = self.k_proj(hidden_states)
value_states = self.v_proj(hidden_states)
query_states = self._shape(query_states, q_len, bsz) # (bsz, num_heads, q_len, head_dim)
key_states = self._shape(key_states, q_len, bsz) # (bsz, num_heads, q_len, head_dim)
value_states = self._shape(value_states, q_len, bsz) # (bsz, num_heads, q_len, head_dim)
# Project K and V to latent space for caching
# (bsz, num_heads, q_len, head_dim) -> (bsz, num_heads, q_len, latent_dim)
latent_key_states = self.k_latent_proj(key_states)
latent_value_states = self.v_latent_proj(value_states)
if past_key_value is not None:
# past_key_value stores latent_key_states and latent_value_states
latent_key_states = torch.cat([past_key_value[0], latent_key_states], dim=2)
latent_value_states = torch.cat([past_key_value[1], latent_value_states], dim=2)
if use_cache:
# Store compressed latent states
present_key_value = (latent_key_states, latent_value_states)
else:
present_key_value = None
# Reconstruct K and V from latent space for attention computation
# (bsz, num_heads, seq_len, latent_dim) -> (bsz, num_heads, seq_len, head_dim)
reconstructed_key_states = self.k_reconstruct_proj(latent_key_states)
reconstructed_value_states = self.v_reconstruct_proj(latent_value_states)
# Standard attention computation with reconstructed K and V
attn_weights = torch.matmul(query_states, reconstructed_key_states.transpose(2, 3)) / (self.head_dim**0.5)
if attention_mask is not None:
attn_weights = attn_weights + attention_mask
attn_weights = F.softmax(attn_weights, dim=-1)
attn_weights = self.dropout(attn_weights)
attn_output = torch.matmul(attn_weights, reconstructed_value_states)
attn_output = attn_output.transpose(1, 2).contiguous().view(bsz, q_len, self.embed_dim)
attn_output = self.out_proj(attn_output)
if output_attentions:
return attn_output, present_key_value, attn_weights
return attn_output, present_key_value
# Example usage:
# embed_dim = 1024
# num_heads = 16
# latent_dim = 64 # significantly smaller than head_dim = 1024/16 = 64. Let's make it 8.
# mla_layer = MultiHeadLatentAttention(embed_dim=1024, num_heads=16, latent_dim=8)
#
# # Simulate input
# batch_size = 2
# seq_len = 128
# hidden_states = torch.randn(batch_size, seq_len, embed_dim)
#
# # First pass (no past_key_value)
# output, past_kv = mla_layer(hidden_states, use_cache=True)
# print(f"Output shape: {output.shape}")
# print(f"Past KV latent key shape: {past_kv[0].shape}") # (bsz, num_heads, seq_len, latent_dim)
# print(f"Past KV latent value shape: {past_kv[1].shape}") # (bsz, num_heads, seq_len, latent_dim)
#
# # Subsequent pass (with past_key_value)
# next_token_hidden_state = torch.randn(batch_size, 1, embed_dim)
# next_output, next_past_kv = mla_layer(next_token_hidden_state, past_key_value=past_kv, use_cache=True)
# print(f"Next output shape: {next_output.shape}")
# print(f"Next Past KV latent key shape: {next_past_kv[0].shape}") # (bsz, num_heads, seq_len+1, latent_dim)
Phác thảo triển khai này minh họa ý tưởng cốt lõi: latent_key_states và latent_value_states được lưu trữ trong KV cache, có latent_dim thay vì head_dim. Trong quá trình tính toán attention, chúng được tái tạo lại thành head_dim bằng cách sử dụng k_reconstruct_proj và v_reconstruct_proj. Việc triển khai DeepSeek V3 thực tế có thể liên quan đến các phép chiếu đã học phức tạp hơn và có thể là một cơ chế attention lai, nhưng nguyên tắc lưu trữ không gian tiềm ẩn hạng thấp vẫn được giữ nguyên.
DeepSeek V3 sử dụng kiến trúc Mixture-of-Experts (MoE), DeepSeekMoE, giúp tăng cường đáng kể dung lượng mô hình mà không làm tăng tỷ lệ chi phí tính toán trong quá trình suy luận. Một đổi mới quan trọng là phân đoạn chuyên gia chi tiết và cơ chế cân bằng tải mới lạ.
DeepSeekMoE sử dụng một lớp MoE thưa thớt, trong đó mỗi token được định tuyến đến một số ít chuyên gia (ví dụ: 2 trong số 64). Không giống như các thiết lập MoE truyền thống thường định tuyến đến một số lượng chuyên gia cố định, DeepSeekMoE giới thiệu một cách tiếp cận năng động và chi tiết hơn.
Kiến trúc bao gồm:
Cách tiếp cận lai này kết hợp lợi ích của các mô hình dày đặc (thông qua các chuyên gia chia sẻ) với khả năng mở rộng của MoE thưa thớt (thông qua các chuyên gia được định tuyến).
Một thách thức phổ biến trong huấn luyện MoE là sự mất cân bằng chuyên gia, trong đó một vài chuyên gia trở nên chiếm ưu thế, dẫn đến việc sử dụng kém hiệu quả các chuyên gia khác. Các giải pháp truyền thống liên quan đến các thuật ngữ auxiliary loss để khuyến khích sử dụng chuyên gia cân bằng. DeepSeek V3 giới thiệu một cơ chế cân bằng tải không cần auxiliary loss.
Ý tưởng cốt lõi là điều chỉnh động các xác suất định tuyến hoặc lựa chọn chuyên gia dựa trên tải chuyên gia theo thời gian thực trong quá trình huấn luyện. Điều này có thể đạt được bằng cách:
Cơ chế chính xác trong DeepSeek V3 là độc quyền nhưng được mô tả là "không cần auxiliary loss", ngụ ý một cơ chế nội tại trong việc định tuyến hoặc quản lý dung lượng. Điều này đơn giản hóa mục tiêu huấn luyện và tránh điều chỉnh siêu tham số cho trọng số auxiliary loss.
Mô hình kích hoạt thưa thớt của DeepSeekMoE rất có lợi cho thông lượng suy luận, đặc biệt trên các bộ tăng tốc như NVIDIA H100/H800. Các GPU này vượt trội trong xử lý song song và có băng thông bộ nhớ cao.
Thiết kế này cho phép DeepSeek V3 đạt được thông lượng suy luận cao, làm cho nó trở nên thực tế để triển khai trong thế giới thực mặc dù tổng số tham số khổng lồ của nó.
DeepSeek V3 tận dụng huấn luyện hỗn hợp độ chính xác FP8 để tăng tốc huấn luyện và giảm dung lượng bộ nhớ mà không ảnh hưởng đến chất lượng mô hình. Điều này rất quan trọng để huấn luyện các mô hình với hàng nghìn tỷ tham số.
GPU NVIDIA H100 hỗ trợ hai định dạng FP8:
DeepSeek V3 có thể sử dụng E4M3 cho trọng số và kích hoạt, và E5M2 cho gradient, hoặc lựa chọn động dựa trên đặc điểm tensor.
Huấn luyện với FP8 đặt ra những thách thức do giảm phạm vi số và độ chính xác, có thể dẫn đến:
DeepSeek V3 giải quyết những vấn đề này thông qua:
Dynamic Scaling (Loss Scaling): Loss được nhân lên một hệ số lớn trước khi tính toán gradient. Điều này di chuyển các giá trị gradient nhỏ vào một phạm vi có thể biểu diễn cho FP8. Sau khi tính toán gradient trong FP8, chúng được chia lại trước khi cập nhật trọng số chính FP32.
scaled_loss = loss * scale_factor.scaled_loss đối với trọng số FP16/FP8.unscaled_gradients = scaled_gradients / scale_factor.unscaled_gradients.scale_factor động: tăng nếu không có tràn, giảm nếu phát hiện tràn.Per-Tensor/Per-Axis Quantization: Thay vì một hệ số scaling toàn cục, DeepSeek V3 có thể sử dụng lượng tử hóa chi tiết hơn.
Trạng thái tối ưu hóa mạnh mẽ: Duy trì trạng thái tối ưu hóa (ví dụ: các moment thứ nhất và thứ hai của Adam) trong FP32 là rất quan trọng. Cập nhật các trạng thái này bằng gradient FP8 và sau đó chuyển lại sang FP8 để cập nhật trọng số có thể dẫn đến sự mất ổn định. DeepSeek V3 đảm bảo rằng các trạng thái này được giữ ở độ chính xác cao hơn (FP32 hoặc BFloat16) để duy trì độ ổn định huấn luyện lâu dài.
Triển khai Kernel cẩn thận: Các kernel CUDA tùy chỉnh là rất cần thiết cho các hoạt động FP8 hiệu quả và ổn định, bao gồm các phép nhân ma trận và giảm độ chính xác hỗn hợp. Các kernel này xử lý việc chuyển đổi, scaling và tích lũy với chi phí tối thiểu và độ ổn định số tối đa.
Đây là một biểu diễn khái niệm, vì huấn luyện FP8 thực tế liên quan đến việc tích hợp sâu với các framework như torch.cuda.amp của PyTorch và Transformer Engine của NVIDIA.
import torch
import torch.nn as nn
from torch.cuda.amp import GradScaler, autocast
import os
# Assume a simple model for demonstration
class SimpleModel(nn.Module):
def __init__(self, input_dim, output_dim):
super().__init__()
self.linear1 = nn.Linear(input_dim, 512)
self.relu = nn.ReLU()
self.linear2 = nn.Linear(512, output_dim)
def forward(self, x):
return self.linear2(self.relu(self.linear1(x)))
# Configuration for FP8 (conceptual, actual implementation uses Transformer Engine)
# In a real DeepSeek V3 setup, this would be managed by a specialized library
# like NVIDIA's Transformer Engine which handles FP8 conversions and kernels.
# For demonstration, we'll use autocast with bfloat16 as a proxy for mixed precision.
# True FP8 requires specific hardware support and libraries.
def train_with_fp8_mixed_precision(model: nn.Module, data_loader, epochs: int = 1):
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-4)
criterion = nn.CrossEntropyLoss()
# Initialize GradScaler for automatic loss scaling
# For FP8, this scaler would be more sophisticated, potentially
# integrated with Transformer Engine's FP8 management.
scaler = GradScaler()
print(f"Training on device: {device}")
for epoch in range(epochs):
model.train()
total_loss = 0
for batch_idx, (inputs, targets) in enumerate(data_loader):
inputs, targets = inputs.to(device), targets.to(device)
optimizer.zero_grad()
# Autocast enables mixed precision. For FP8, this would involve
# specific FP8 types and kernels from Transformer Engine.
# Here, we use bfloat16 as a common mixed-precision type.
with autocast(dtype=torch.bfloat16): # Or torch.float8_e4m3fn, etc. if supported
outputs = model(inputs)
loss = criterion(outputs, targets)
# Scales loss to prevent numerical underflow in FP16/FP8 gradients
scaler.scale(loss).backward()
# Unscales gradients and calls optimizer.step()
# If gradients are NaN or Inf, skips the step.
scaler.step(optimizer)
# Updates the scale for next iteration
scaler.update()
total_loss += loss.item()
if batch_idx % 100 == 0:
print(f"Epoch {epoch+1}, Batch {batch_idx}, Loss: {loss.item():.4f}")
print(f"Epoch {epoch+1} finished. Average Loss: {total_loss / len(data_loader):.4f}")
# Dummy data loader for demonstration
class DummyDataset(torch.utils.data.Dataset):
def __init__(self, num_samples, input_dim, output_dim):
self.num_samples = num_samples
self.input_dim = input_dim
self.output_dim = output_dim
self.data = torch.randn(num_samples, input_dim)
self.labels = torch.randint(0, output_dim, (num_samples,))
def __len__(self):
return self.num_samples
def __getitem__(self, idx):
return self.data[idx], self.labels[idx]
if __name__ == "__main__':
if not torch.cuda.is_available():
print("CUDA not available. Skipping FP8 training demonstration.")
else:
input_dim = 768
output_dim = 100
num_samples = 10000
batch_size = 32
model = SimpleModel(input_dim, output_dim)
dataset = DummyDataset(num_samples, input_dim, output_dim)
data_loader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=True)
print("Starting FP8 mixed precision training simulation...")
train_with_fp8_mixed_precision(model, data_loader, epochs=2)
print("FP8 mixed precision training simulation complete.")
| Tính năng | MHA tiêu chuẩn | DeepSeek V3 MLA | MoE tiêu chuẩn | DeepSeek V3 DeepSeekMoE | Độ chính xác hỗn hợp FP16/BF16 | DeepSeek V3 Độ chính xác hỗn hợp FP8 |
|---|---|---|---|---|---|---|
| Bộ nhớ KV Cache | O(L * H * d_k) | O(L * H * d_l) (d_l << d_k) | N/A (lớp FFN) | N/A (lớp FFN) | Cao hơn | Thấp nhất |
| Giảm KV Cache | 0% | ~93% | N/A | N/A | N/A | N/A |
| Cơ chế Attention | Trực tiếp Q K^T V | Q (K_reconstructed)^T V_reconstructed | N/A | N/A | N/A | N/A |
| Cấu trúc chuyên gia | N/A (FFN dày đặc) | N/A | Tất cả các chuyên gia được định tuyến, thường là số lượng cố định | Chuyên gia chia sẻ + được định tuyến, chi tiết | N/A | N/A |
| Cân bằng tải | N/A | N/A | Thường yêu cầu auxiliary loss | Không cần auxiliary loss, điều chỉnh động | N/A | N/A |
| Bộ nhớ huấn luyện | Cao | Cao (MLA không giảm nhiều bộ nhớ huấn luyện) | Cao (tất cả các chuyên gia được tải) | Thấp hơn (kích hoạt thưa thớt) | Giảm từ FP32 | Giảm đáng kể từ FP16/BF16 |
| Tốc độ huấn luyện | Cơ bản | Tương tự MHA (MLA thêm một số phép toán) | Chậm hơn do auxiliary loss, chi phí định tuyến | Nhanh hơn do định tuyến hiệu quả, không có aux loss | Nhanh hơn FP32 | Nhanh nhất |
| Độ ổn định số | Cao (FP32) | Cao (FP32/BF16 cho các phép toán cốt lõi) | Trung bình (aux loss có thể khó) | Cao (mục tiêu đơn giản hơn) | Tốt với GradScaler | Yêu cầu các kỹ thuật tiên tiến (scaling động, per-tensor/axis) |
| Yêu cầu phần cứng | GPU tiêu chuẩn | GPU tiêu chuẩn, hưởng lợi từ băng thông bộ nhớ cao | GPU tiêu chuẩn, hưởng lợi từ VRAM cao | H100/H800 để đạt thông lượng tối ưu | GPU tiêu chuẩn | H100/H800 để hỗ trợ FP8 gốc |
Lỗi/Phân kỳ KV Cache của MLA:
W_K^P, W_V^P hoặc ma trận tái tạo W_K^R, W_V^R không đủ biểu cảm hoặc được huấn luyện kém.Mất cân bằng chuyên gia của DeepSeekMoE (ngay cả khi không có auxiliary loss):
Mất ổn định/NaNs trong huấn luyện FP8:
NaN hoặc Inf trong quá trình huấn luyện FP8, hoặc mô hình không hội tụ. Điều này thường do tràn/tràn dưới số hoặc mất độ chính xác trong gradient.GradScaler trong PyTorch AMP (hoặc tương đương trong Transformer Engine) điều chỉnh động hệ số scale. Nếu NaN xuất hiện, hệ số scale có thể quá thấp, dẫn đến tràn dưới, hoặc quá cao, dẫn đến tràn.
scaler.get_scale(): Quan sát hành vi của nó. Nếu nó liên tục giảm, điều đó cho thấy tràn thường xuyên. Nếu nó bị kẹt ở một giá trị rất thấp, điều đó cho thấy tràn dưới.init_scale ban đầu cho GradScaler.exp_avg, exp_avg_sq của Adam) được duy trì trong FP32 hoặc BF16. Nếu chúng vô tình được chuyển sang FP8, huấn luyện có thể sẽ thất bại.MLA đạt được mức giảm 93% KV cache mà không làm suy giảm hiệu suất đáng kể như thế nào?
MLA đạt được điều này bằng cách học các ma trận chiếu hạng thấp nén các vector khóa và giá trị chiều cao thành một không gian tiềm ẩn nhỏ hơn nhiều (d_l << d_k). Giả định cốt lõi là thông tin cần thiết cho việc tính toán attention có thể được tóm tắt hiệu quả trong biểu diễn chiều thấp hơn này. Việc "tái tạo" trong quá trình tính toán attention cũng được học, đảm bảo rằng các mẫu quan trọng cho sự tương đồng truy vấn-khóa và tổng hợp giá trị được bảo toàn. Con số 93% ngụ ý tỷ lệ nén rất mạnh, có thể đạt được thông qua huấn luyện rộng rãi và thiết kế kiến trúc cẩn thận của các lớp chiếu/tái tạo.
Những đánh đổi của cân bằng tải không cần auxiliary loss của DeepSeekMoE so với các phương pháp truyền thống là gì? Lợi ích chính là đơn giản hóa mục tiêu huấn luyện và không gian siêu tham số. Các auxiliary loss truyền thống (ví dụ: router z-loss, expert capacity loss) giới thiệu các siêu tham số bổ sung cần được điều chỉnh cẩn thận và đôi khi có thể xung đột với mục tiêu mô hình hóa ngôn ngữ chính. Cơ chế nội tại của DeepSeekMoE nhằm mục đích đạt được sự cân bằng mà không cần các thuật ngữ loss rõ ràng, có khả năng dẫn đến huấn luyện ổn định và dễ dàng hơn. Đánh đổi có thể là kiểm soát ít rõ ràng hơn đối với việc sử dụng chuyên gia, và các cơ chế ngầm có thể khó gỡ lỗi hơn nếu xảy ra mất cân bằng. Tuy nhiên, nếu được thiết kế tốt, nó có thể mạnh mẽ hơn.
Độ chính xác hỗn hợp FP8 của DeepSeek V3 có thể được sử dụng trên các GPU khác ngoài NVIDIA H100/H800 không? Hỗ trợ FP8 gốc (E4M3, E5M2) là một tính năng phần cứng của kiến trúc NVIDIA Hopper (H100/H800) và mới hơn. Mặc dù bạn có thể mô phỏng các hoạt động FP8 trên các GPU cũ hơn (ví dụ: A100, V100) bằng cách chuyển đổi tensor thủ công, bạn sẽ không nhận được lợi ích tăng tốc phần cứng của Tensor Cores được thiết kế cho FP8. Chạy DeepSeek V3 với độ chính xác hỗn hợp FP8 đầy đủ để huấn luyện hoặc suy luận sẽ yêu cầu H100/H800 hoặc phần cứng tương đương có hỗ trợ FP8 gốc để đạt được hiệu suất và lợi ích bộ nhớ được quảng cáo. Trên các GPU cũ hơn, bạn thường sẽ chuyển về độ chính xác hỗn hợp BF16 hoặc FP16.
DeepSeekMoE xử lý vấn đề "khởi động nguội" cho các chuyên gia như thế nào, đặc biệt với phân đoạn chi tiết? Vấn đề "khởi động nguội" đề cập đến việc các chuyên gia mới hoặc kém được sử dụng không nhận đủ token để học hiệu quả. DeepSeekMoE giải quyết vấn đề này thông qua sự kết hợp giữa "chuyên gia chia sẻ" và "chuyên gia được định tuyến". Các chuyên gia chia sẻ cung cấp một tính toán cơ bản cho tất cả các token, đảm bảo rằng ngay cả khi các chuyên gia được định tuyến ban đầu không cân bằng, mô hình vẫn hoạt động hợp lý. Đối với các chuyên gia được định tuyến, cơ chế cân bằng tải không cần auxiliary loss ngầm khuyến khích khám phá và sử dụng các chuyên gia ít được sử dụng hơn theo thời gian. Trong các giai đoạn huấn luyện ban đầu, các kỹ thuật như nhiệt độ bộ định tuyến cao hơn hoặc phân phối định tuyến ban đầu đồng đều hơn cũng có thể giúp đảm bảo tất cả các chuyên gia nhận được một số lưu lượng ban đầu.
Tác động của MLA đến độ trễ suy luận là gì, đặc biệt đối với các ngữ cảnh rất dài? MLA giảm đáng kể dung lượng bộ nhớ KV cache, điều này rất quan trọng đối với các ngữ cảnh dài. Điều này trực tiếp ảnh hưởng đến độ trễ bằng cách:
Một nhóm đang triển khai LLM dựa trên DeepSeek V3 cho một ứng dụng AI đàm thoại thời gian thực, nơi việc giảm thiểu độ trễ inference và tối đa hóa context window là rất quan trọng. Họ đang cân nhắc điều chỉnh tham số `latent_dim` trong module Multi-Head Latent Attention (MLA). Đánh đổi sản xuất đáng kể nhất mà họ phải đối mặt khi tăng `latent_dim` là gì?
Làm sạch log AI CLI, tạo biểu thức cron, giải mã JWT và tính quyền chmod offline.

Hướng dẫn toàn diện về tinh chỉnh DeepSeek R1 với Unsloth & LoRA: các mô hình suy luận tiết kiệm bộ nhớ với kiến trúc cấp độ sản xuất và ví dụ mã.
Đọc tiếp
Hướng dẫn toàn diện phân tích chuyên sâu vLLM PagedAttention: phân mảnh bộ nhớ KV Cache, prefill theo khối và prefix caching với kiến trúc cấp độ sản xuất và các ví dụ mã.
Đọc tiếp
Hướng dẫn toàn diện về deepseek-r1 và các mô hình suy luận chưng cất: triển khai vLLM cục bộ, lượng tử hóa và kiến trúc với các ví dụ về kiến trúc và mã nguồn cấp độ sản xuất.
Đọc tiếp