DeepSeek-R1 & Các Mô Hình Suy Luận Chưng Cất: Triển Khai vLLM Cục Bộ, Lượng Tử Hóa & Kiến Trúc

DeepSeek-R1 đại diện cho một bước tiến đáng kể trong các Mô hình Ngôn ngữ Lớn (LLM) có khả năng suy luận, đặc biệt thông qua việc sử dụng sáng tạo học tăng cường từ phản hồi của con người (RLHF) và tự chơi với trọng tâm vào các dấu vết suy luận. Bài viết này phân tích các nền tảng kiến trúc của DeepSeek-R1 và các biến thể chắt lọc của nó, cung cấp hướng dẫn thực tế để triển khai cục bộ, các chiến lược lượng tử hóa và tối ưu hóa hiệu suất bằng cách sử dụng vLLM và TensorRT-LLM.

Kiến trúc DeepSeek-R1 và Dấu vết suy luận

Đổi mới cốt lõi của DeepSeek-R1 nằm ở phương pháp đào tạo của nó, nhấn mạnh việc tạo và tinh chỉnh các bước suy luận rõ ràng. Không giống như các mô hình học suy luận một cách ngầm định, DeepSeek-R1 được đào tạo để tạo ra các quy trình tư duy có cấu trúc, thường được gói gọn trong các khối <think>, trước khi đưa ra câu trả lời cuối cùng. Cách tiếp cận này được lấy cảm hứng từ lời nhắc Chain-of-Thought (CoT) nhưng được tích hợp trực tiếp vào mục tiêu đào tạo của mô hình.

Quá trình đào tạo bao gồm:

1. Thu thập dữ liệu khởi động lạnh: Các dấu vết suy luận ban đầu được tạo ra bởi một mô hình giáo viên mạnh mẽ (ví dụ: GPT-4) hoặc người chú thích. Các dấu vết này hướng dẫn mô hình phân tách các vấn đề phức tạp thành các bước có thể quản lý được.
2. Học tăng cường với tự chơi: Mô hình tự tạo ra các dấu vết suy luận và câu trả lời của riêng mình. Một mô hình phần thưởng, được đào tạo dựa trên sở thích của con người về chất lượng và độ chính xác của suy luận, đánh giá các đầu ra này. Mô hình chính sách sau đó được cập nhật bằng cách sử dụng Tối ưu hóa chính sách gần đúng (PPO) hoặc các thuật toán RL tương tự để tối đa hóa các phần thưởng này.
3. Cấu trúc dấu vết suy luận: Mô hình được đào tạo rõ ràng để phát ra các token như <think> và </think> để phân định quá trình suy luận nội bộ của nó. Điều này làm cho việc ra quyết định của mô hình minh bạch và dễ gỡ lỗi hơn.

Xem xét một tương tác DeepSeek-R1:

User: What is the capital of France, and what is its population?
Assistant: <think>
1. Identify the capital of France.
2. Find the current population of Paris.
3. Combine the information.
</think>
The capital of France is Paris. Its population is approximately 2.1 million (as of 2023).

Cấu trúc suy luận rõ ràng này rất quan trọng đối với các tác vụ phức tạp như giải quyết vấn đề toán học, tạo mã và suy luận logic, nơi các bước trung gian cũng quan trọng như câu trả lời cuối cùng.

Các biến thể chắt lọc của DeepSeek-R1, thường dựa trên kiến trúc Llama hoặc Qwen, tận dụng khả năng suy luận này bằng cách chắt lọc kiến thức từ mô hình DeepSeek-R1 lớn hơn thành các mô hình nhỏ hơn, hiệu quả hơn. Việc chắt lọc này thường bao gồm:

• Chắt lọc kiến thức: Đào tạo một mô hình học sinh nhỏ hơn để bắt chước các đầu ra (logits, trạng thái ẩn hoặc dấu vết suy luận) của mô hình giáo viên lớn hơn.
• Căn chỉnh sở thích: Sử dụng mô hình phần thưởng từ quá trình đào tạo DeepSeek-R1 để tinh chỉnh mô hình chắt lọc, đảm bảo nó phù hợp với sở thích của con người về suy luận và tính hữu ích.

Chiến lược lượng tử hóa: FP8 so với AWQ

Triển khai LLM lớn cục bộ đòi hỏi lượng tử hóa mạnh mẽ để phù hợp với các ràng buộc bộ nhớ GPU và cải thiện thông lượng suy luận. Chúng tôi tập trung vào FP8 (Float8) và AWQ (Activation-aware Weight Quantization) do sự cân bằng giữa hiệu suất và độ chính xác của chúng.

Lượng tử hóa FP8

Lượng tử hóa FP8, đặc biệt là sử dụng định dạng E4M3 (4 bit số mũ, 3 bit mantissa) hoặc E5M2 (5 bit số mũ, 2 bit mantissa), mang lại khả năng tiết kiệm bộ nhớ đáng kể (giảm 8 lần so với FP64, 4 lần so với FP32, 2 lần so với FP16/BF16). Kiến trúc Hopper của NVIDIA và các GPU mới hơn cung cấp khả năng tăng tốc lõi tensor FP8 gốc, làm cho nó cực kỳ hiệu quả.

Quá trình này thường bao gồm:

1. Hiệu chuẩn: Phân tích một tập dữ liệu đại diện để xác định các yếu tố tỷ lệ tối ưu cho trọng số và kích hoạt.
2. Lượng tử hóa: Chuyển đổi trọng số và kích hoạt FP16/BF16 sang FP8 bằng cách sử dụng các yếu tố tỷ lệ đã dẫn xuất.
3. Giải lượng tử hóa (tức thì): Trong quá trình suy luận, các giá trị FP8 được giải lượng tử hóa trở lại FP16/BF16 để tính toán, sau đó được lượng tử hóa lại thành FP8 để lưu trữ.

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# Example: Loading a model with FP8 (requires specific libraries like NVIDIA's TransformerEngine or custom implementations)
# This is a conceptual example as direct FP8 loading via transformers is often through specific backend integrations.
# For actual FP8, you'd typically use TensorRT-LLM or a custom FP8-enabled inference engine.

model_id = "deepseek-ai/deepseek-llm-7b-base" # Or a distilled variant
tokenizer = AutoTokenizer.from_pretrained(model_id)

# Placeholder for FP8 loading logic. In practice, this would involve
# converting the model to FP8 format using tools like `huggingface-cli convert`
# or TensorRT-LLM's build process.
# For demonstration, we'll show a standard load, but note FP8 requires specific hardware/software.
try:
    # This would typically fail without a specific FP8 implementation or TRT-LLM
    # model = AutoModelForCausalLM.from_pretrained(model_id, torch_dtype=torch.float8_e4m3fn)
    print("Direct FP8 loading via transformers is not standard. Use TensorRT-LLM or similar.")
except Exception as e:
    print(f"Error loading with torch.float8_e4m3fn directly: {e}")

# A more realistic scenario for FP8 would be via TensorRT-LLM:
# (See TensorRT-LLM section below for full example)

Lượng tử hóa AWQ

AWQ là một phương pháp lượng tử hóa sau đào tạo (PTQ) tập trung vào việc lượng tử hóa trọng số trong khi giữ các kích hoạt ở FP16/BF16. Nó nhận thấy rằng không phải tất cả các trọng số đều quan trọng như nhau đối với hiệu suất mô hình; một số trọng số, đặc biệt là những trọng số được nhân với các kích hoạt lớn, nhạy cảm hơn với lỗi lượng tử hóa. AWQ chọn lọc lượng tử hóa trọng số dựa trên độ lớn kích hoạt của chúng.

Ý tưởng cốt lõi:

1. Lượng tử hóa trọng số dựa trên độ nổi bật: Xác định các trọng số nổi bật (những trọng số mà khi được lượng tử hóa, gây ra lỗi lớn nhất do độ lớn kích hoạt lớn).
2. Điều chỉnh theo kênh: Áp dụng các yếu tố tỷ lệ theo kênh cho trọng số để giảm thiểu lỗi lượng tử hóa.
3. Lượng tử hóa: Lượng tử hóa trọng số thành số nguyên 4 bit (hoặc 3 bit).

AWQ thường đạt được độ chính xác tốt hơn so với lượng tử hóa INT4 đơn giản với dữ liệu hiệu chuẩn tối thiểu. Nó được hỗ trợ tốt bởi các công cụ suy luận như vLLM.

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# Example: Loading a model with AWQ using vLLM's integration
# This requires the model to be pre-quantized or vLLM to perform on-the-fly quantization.
# For vLLM, you typically specify `quantization="awq"` during engine initialization.

# To prepare a model for AWQ, you might use AutoGPTQ or similar libraries.
# Example using AutoGPTQ for AWQ (conceptual, as vLLM handles the inference part):
# from accelerate import Accelerator
# from auto_gptq import AutoGPTQForCausalLM, BaseQuantizeConfig

# model_id = "deepseek-ai/deepseek-llm-7b-base"
# quant_config = BaseQuantizeConfig(
#     bits=4,
#     group_size=128,
#     desc_act=False, # For AWQ, often False
#     quant_method="awq"
# )
#
# model = AutoGPTQForCausalLM.from_pretrained(model_id, quantize_config=quant_config)
# model.quantize(tokenizer.train_dataloader) # Requires a calibration dataset
# model.save_quantized("deepseek-llm-7b-awq")

# For vLLM, you just point to the AWQ-quantized model directory or specify the quantization method.

So sánh lượng tử hóa

Triển khai vLLM cục bộ

vLLM là một thư viện mã nguồn mở để suy luận LLM nhanh, tận dụng PagedAttention để quản lý bộ nhớ cache KV một cách hiệu quả. Nó cải thiện đáng kể thông lượng so với các triển khai đơn giản, đặc biệt đối với suy luận theo lô.

Cài đặt

# Ensure you have a compatible CUDA toolkit installed
pip install vllm

Triển khai với vLLM

Để triển khai DeepSeek-R1 hoặc biến thể chắt lọc của nó với vLLM, bạn có thể sử dụng API Python của nó hoặc khởi chạy một máy chủ.

Ví dụ API Python

from vllm import LLM, SamplingParams

# Model ID from Hugging Face Hub. Replace with your specific DeepSeek-R1 variant.
# For AWQ, ensure the model is either pre-quantized or vLLM supports on-the-fly AWQ for it.
model_id = "deepseek-ai/deepseek-llm-7b-base" # Example, use a distilled/quantized version for production

# Initialize the LLM engine
# For AWQ, you'd typically specify quantization="awq" if the model supports it or is pre-quantized.
# For FP8, you'd need TensorRT-LLM integration or a custom vLLM build.
llm = LLM(
    model=model_id,
    tensor_parallel_size=1, # Number of GPUs to use for tensor parallelism
    dtype="auto",           # Automatically detect dtype (e.g., bfloat16, float16)
    gpu_memory_utilization=0.9, # Max GPU memory to use
    quantization="awq"      # Specify AWQ quantization if using an AWQ model
)

# Define sampling parameters
sampling_params = SamplingParams(
    temperature=0.7,
    top_p=0.95,
    max_tokens=256,
    stop=["<|im_end|>", "User:"] # Example stop tokens for chat models
)

# Generate prompts
prompts = [
    "User: Explain the concept of PagedAttention in vLLM. Assistant:",
    "User: What are the key differences between FP8 and AWQ quantization? Assistant:"
]

# Generate outputs
outputs = llm.generate(prompts, sampling_params)

# Print the outputs
for i, output in enumerate(outputs):
    prompt = output.prompt
    generated_text = output.outputs[0].text
    print(f"Prompt: {prompt!r}, Generated text: {generated_text!r}")
    print("-" * 80)

Triển khai máy chủ vLLM

Đối với một điểm cuối API sẵn sàng sản xuất:

# Start the vLLM API server
# Replace deepseek-ai/deepseek-llm-7b-base with your model path or HF ID.
# --quantization awq for AWQ models.
# --dtype bfloat16 for bfloat16 inference.
python -m vllm.entrypoints.api_server \
    --model deepseek-ai/deepseek-llm-7b-base \
    --tensor-parallel-size 1 \
    --gpu-memory-utilization 0.9 \
    --port 8000 \
    --host 0.0.0.0 \
    --quantization awq # Use this if your model is AWQ quantized

Sau đó, tương tác với nó bằng curl hoặc một máy khách Python:

import requests
import json

api_url = "http://localhost:8000/generate"
headers = {"Content-Type": "application/json"}

payload = {
    "prompt": "User: Explain the concept of PagedAttention in vLLM. Assistant:",
    "sampling_params": {
        "temperature": 0.7,
        "top_p": 0.95,
        "max_tokens": 256,
        "stop": ["<|im_end|>", "User:"]
    }
}

response = requests.post(api_url, headers=headers, data=json.dumps(payload))
print(json.dumps(response.json(), indent=2))

Triển khai TensorRT-LLM cho FP8

Để đạt hiệu suất tối đa, đặc biệt với lượng tử hóa FP8 trên GPU NVIDIA, TensorRT-LLM là giải pháp ưu tiên. Nó biên dịch các biểu đồ LLM thành các công cụ TensorRT được tối ưu hóa cao.

Điều kiện tiên quyết

• GPU NVIDIA (Hopper hoặc mới hơn để tăng tốc FP8 gốc)
• Bộ công cụ CUDA
• TensorRT-LLM đã được cài đặt (thường từ nguồn hoặc các container được xây dựng sẵn)

Quy trình làm việc

1. Chuyển đổi mô hình Hugging Face sang định dạng TensorRT-LLM: Bước này liên quan đến việc chuyển đổi trọng số và kiến trúc của mô hình sang định dạng mà TensorRT-LLM có thể hiểu và tối ưu hóa.

   bashCopy

   # Example for Llama-based models (DeepSeek-R1 distilled variants)
   # Ensure you have the TensorRT-LLM environment set up.
   # This script is usually part of the TensorRT-LLM examples.
   
   # Clone TensorRT-LLM if you haven't
   # git clone https://github.com/NVIDIA/TensorRT-LLM.git
   # cd TensorRT-LLM
   # pip install -e .
   
   # Navigate to the examples directory
   # cd examples/llama
   
   # Convert the Hugging Face model.
   # Replace deepseek-ai/deepseek-llm-7b-base with your model.
   # --dtype float8 for FP8 quantization.
   # --output_dir specifies where the TensorRT-LLM engine will be saved.
   python convert_checkpoint.py \
       --model_dir deepseek-ai/deepseek-llm-7b-base \
       --output_dir ./tllm_deepseek_7b_fp8 \
       --dtype float8 \
       --tp_size 1 # Tensor parallelism size
   

2. Xây dựng công cụ TensorRT-LLM: Bước này biên dịch mô hình đã chuyển đổi thành một công cụ TensorRT được tối ưu hóa.

   bashCopy

   # Navigate to the TensorRT-LLM root directory
   # cd TensorRT-LLM
   
   # Build the engine
   # Replace the path to your converted model.
   # --max_batch_size, --max_input_len, --max_output_len are crucial for performance tuning.
   # --dtype float8 for FP8.
   # --workers for parallel compilation.
   trtllm-build --checkpoint_dir ./tllm_deepseek_7b_fp8 \
                --output_dir ./tllm_deepseek_7b_fp8_engine \
                --gemm_plugin float8 \
                --max_batch_size 8 \
                --max_input_len 512 \
                --max_output_len 256 \
                --workers 1 \
                --dtype float8
   

3. Chạy suy luận với TensorRT-LLM: Sử dụng công cụ đã xây dựng để suy luận.

   pythonCopy

   import tensorrt_llm
   from tensorrt_llm.runtime import ModelRunner
   import torch
   
   # Load the tokenizer
   from transformers import AutoTokenizer
   tokenizer = AutoTokenizer.from_pretrained("deepseek-ai/deepseek-llm-7b-base")
   
   # Initialize the TensorRT-LLM runner
   # Specify the engine directory and max_batch_size used during build.
   runner = ModelRunner(
       engine_dir='./tllm_deepseek_7b_fp8_engine',
       lora_dir=None, # If using LoRA adapters
       rank=0,
       max_batch_size=8,
       max_input_len=512,
       max_output_len=256,
       dtype='float8' # Must match the engine's dtype
   )
   
   prompts = [
       "User: Explain the concept of PagedAttention in vLLM. Assistant:",
       "User: What are the key differences between FP8 and AWQ quantization? Assistant:"
   ]
   
   # Tokenize prompts
   input_ids = [tokenizer.encode(p, return_tensors="pt").cuda() for p in prompts]
   
   # Generate outputs
   # The `generate` method takes a list of input_ids tensors.
   # It returns a list of output_ids tensors.
   output_ids = runner.generate(
       input_ids,
       max_new_tokens=256,
       temperature=0.7,
       top_p=0.95,
       stop_words_list=[tokenizer.encode("<|im_end|>", add_special_tokens=False),
                        tokenizer.encode("User:", add_special_tokens=False)]
   )
   
   # Decode and print
   for i, output in enumerate(output_ids):
       generated_text = tokenizer.decode(output[0], skip_special_tokens=True)
       print(f"Prompt: {prompts[i]!r}, Generated text: {generated_text!r}")
       print("-" * 80)
   

Các vấn đề và khắc phục sự cố trong sản xuất

1. Hết bộ nhớ GPU (CUDA out of memory):

   • Nguyên nhân: Kích thước mô hình, kích thước lô, max_model_len (vLLM), hoặc max_input_len/max_output_len (TensorRT-LLM) vượt quá VRAM khả dụng.
   • Khắc phục:
     • Giảm tensor_parallel_size (nếu sử dụng nhiều GPU, đảm bảo nó được cấu hình đúng).
     • Giảm gpu_memory_utilization trong vLLM (ví dụ: xuống 0.85).
     • Giảm max_batch_size.
     • Giảm max_model_len (vLLM) hoặc max_input_len/max_output_len (TensorRT-LLM).
     • Sử dụng lượng tử hóa mạnh mẽ hơn (ví dụ: AWQ 4-bit thay vì FP16, hoặc FP8 nếu phần cứng hỗ trợ).
     • Chuyển sang một mô hình chắt lọc nhỏ hơn.
     • Nâng cấp phần cứng GPU.

2. Thông lượng thấp/Độ trễ cao:

   • Nguyên nhân: Phân lô không tối ưu, tắc nghẽn truyền dữ liệu CPU-GPU, kiến trúc mô hình không hiệu quả hoặc thiếu tăng tốc phần cứng.
   • Khắc phục:
     • Tăng max_batch_size (đến giới hạn bộ nhớ) để tận dụng song song GPU.
     • Đảm bảo tensor_parallel_size được cấu hình đúng cho các thiết lập đa GPU.
     • Xác minh dtype (ví dụ: bfloat16 hoặc float16) được sử dụng, không phải float32.
     • Đối với FP8, xác nhận bạn đang sử dụng TensorRT-LLM trên GPU Hopper/Blackwell.
     • Kiểm tra các tắc nghẽn CPU (ví dụ: tốc độ mã hóa token).
     • Hồ sơ với nvprof hoặc NVIDIA Nsight Systems để xác định các tắc nghẽn.

3. Giảm chất lượng đầu ra mô hình sau lượng tử hóa:

   • Nguyên nhân: Lượng tử hóa mạnh mẽ (ví dụ: INT4 không có hiệu chuẩn thích hợp) có thể dẫn đến mất độ chính xác.
   • Khắc phục:
     • Sử dụng các phương pháp lượng tử hóa đã được thiết lập tốt như AWQ hoặc FP8 với hiệu chuẩn thích hợp.
     • Đánh giá mô hình trên một tập hợp xác thực đại diện sau lượng tử hóa.
     • Nếu sử dụng AWQ, đảm bảo tập dữ liệu hiệu chuẩn đa dạng và đại diện cho các đầu vào dự kiến.
     • Cân nhắc lượng tử hóa ít mạnh mẽ hơn một chút (ví dụ: 8-bit thay vì 4-bit nếu độ chính xác là rất quan trọng).

4. Lỗi xây dựng công cụ TensorRT-LLM:

   • Nguyên nhân: Đối số convert_checkpoint.py không chính xác, kiến trúc mô hình không tương thích hoặc các vấn đề về môi trường.
   • Khắc phục:
     • Kiểm tra kỹ các đối số model_dir, dtype và tp_size.
     • Đảm bảo mô hình Hugging Face tương thích với các tập lệnh chuyển đổi của TensorRT-LLM (ví dụ: Llama, Falcon, v.v.).
     • Xác minh cài đặt TensorRT-LLM và môi trường CUDA.
     • Kiểm tra tài liệu TensorRT-LLM để biết các yêu cầu chuyển đổi mô hình cụ thể.
     • Tăng độ chi tiết trong quá trình xây dựng (--log_level verbose) để có thông báo lỗi chi tiết hơn.

5. vLLM stop_tokens không hoạt động như mong đợi:

   • Nguyên nhân: ID token không chính xác cho các chuỗi dừng, hoặc mô hình tạo ra các token là một phần của chuỗi dừng nhưng không phải là chuỗi đầy đủ.
   • Khắc phục:
     • Đảm bảo các token stop được mã hóa token đúng cách. Ví dụ, stop=["<|im_end|>", "User:"] phải là stop_token_ids=[tokenizer.encode("<|im_end|>", add_special_tokens=False), tokenizer.encode("User:", add_special_tokens=False)] nếu sử dụng các ID token thô. Đối số SamplingParams stop của vLLM xử lý khớp chuỗi, nhưng đối với các ID token cụ thể, stop_token_ids mạnh mẽ hơn.
     • Kiểm tra với các chuỗi dừng đơn giản, không rõ ràng trước.
     • Lưu ý rằng các mô hình có thể tạo ra các chuỗi dừng một phần.

Các câu hỏi thường gặp

Q1: Tôi có thể chạy các mô hình DeepSeek-R1 trên các GPU cấp người tiêu dùng (ví dụ: RTX 3090, 4090) không?

A1: Có, đặc biệt là các biến thể chắt lọc và lượng tử hóa. Một RTX 3090 (24GB VRAM) hoặc 4090 (24GB VRAM) có thể chạy thoải mái các mô hình 7B-13B tham số được lượng tử hóa thành 4-bit (AWQ) hoặc thậm chí một số mô hình 7B trong FP16/BF16 với vLLM. Đối với các mô hình lớn hơn hoặc FP8, cần nhiều GPU hoặc nhiều VRAM hơn. TensorRT-LLM với FP8 chủ yếu dành cho Hopper/Blackwell, nhưng các công cụ FP16/BF16 có thể chạy trên các card tiêu dùng.

Q2: Tác động hiệu suất của việc sử dụng các khối <think> trong DeepSeek-R1 là gì?

A2: Việc tạo rõ ràng các khối <think> làm tăng tổng số token được tạo ra, điều này ảnh hưởng trực tiếp đến độ trễ suy luận. Tuy nhiên, chi phí này thường được biện minh bằng chất lượng suy luận được cải thiện và giảm ảo giác. Quá trình đào tạo của mô hình đảm bảo các khối này ngắn gọn và phù hợp. Đối với các ứng dụng nhạy cảm về độ trễ, bạn có thể xử lý hậu kỳ để loại bỏ các khối này trước khi trình bày cho người dùng, hoặc tinh chỉnh một mô hình chắt lọc để tạo ra suy luận nhỏ gọn hơn.

Q3: Làm cách nào để chọn giữa vLLM và TensorRT-LLM để triển khai cục bộ?

A3:

• vLLM: Tuyệt vời về tính dễ sử dụng, hỗ trợ mô hình rộng (mô hình Hugging Face) và phân lô hiệu quả (PagedAttention). Đây là một điểm khởi đầu tuyệt vời cho hầu hết các triển khai cục bộ và hỗ trợ tốt lượng tử hóa AWQ.
• TensorRT-LLM: Cung cấp hiệu suất tối đa và độ trễ thấp nhất, đặc biệt với FP8 trên GPU Hopper/Blackwell của NVIDIA. Nó yêu cầu thiết lập phức tạp hơn (chuyển đổi mô hình, biên dịch công cụ) và được kết nối chặt chẽ hơn với phần cứng NVIDIA. Chọn TensorRT-LLM khi hiệu suất cao nhất tuyệt đối và độ trễ tối thiểu là tối quan trọng, và bạn có phần cứng tương thích.

Q4: Có thể tinh chỉnh một mô hình DeepSeek-R1 đã chắt lọc cục bộ không?

A4: Có, việc tinh chỉnh các mô hình chắt lọc nhỏ hơn (ví dụ: 7B) là khả thi trên các GPU tiêu dùng với đủ VRAM (24GB+). Các kỹ thuật như LoRA (Low-Rank Adaptation) hoặc QLoRA (Quantized LoRA) rất được khuyến nghị để giảm dung lượng bộ nhớ. Bạn sẽ cần một tập dữ liệu phù hợp với tác vụ cụ thể của mình và một framework như Hugging Face transformers hoặc peft.

Q5: Ý nghĩa của tensor_parallel_size trong vLLM và TensorRT-LLM là gì?

A5: tensor_parallel_size chỉ định số lượng GPU để phân phối các lớp hoặc tensor của mô hình.

• Lợi ích: Cho phép chạy các mô hình lớn hơn mà không thể vừa trên một GPU, có khả năng tăng thông lượng bằng cách song song hóa các phép tính.
• Hạn chế: Gây ra chi phí giao tiếp giữa các GPU, đôi khi có thể làm mất đi lợi ích hiệu suất nếu không được cấu hình tối ưu hoặc nếu kết nối chậm. Đối với các triển khai cục bộ, hãy đảm bảo các GPU của bạn được kết nối qua NVLink để đạt hiệu suất tốt nhất với song song tensor. Nếu bạn có một GPU duy nhất, hãy đặt tensor_parallel_size=1.