{/* Trang này được tạo tự động từ SKILL.md của kỹ năng bởi website/scripts/generate-skill-docs.py. Chỉnh sửa nguồn SKILL.md, không phải trang này. */}

Hugging Face tăng tốc

API đào tạo phân tán đơn giản nhất. 4 dòng để thêm hỗ trợ phân tán cho bất kỳ tập lệnh PyTorch nào. API hợp nhất cho DeepSpeed/FSDP/Megatron/DDP. Vị trí thiết bị tự động, độ chính xác hỗn hợp (FP16/BF16/FP8). Cấu hình tương tác, lệnh khởi chạy duy nhất. Tiêu chuẩn hệ sinh thái HuggingFace.

Siêu dữ liệu kỹ năng

Nguồn	Tùy chọn — cài đặt với
`Hermes skills install official/mlops/accelerate
`
Đường dẫn

optional-skills/mlops/accelerate ` | | Phiên bản |

1.0.0 ` | | Tác giả | Nghiên cứu dàn nhạc | | Giấy phép | MIT | | Phụ thuộc |

accelerate

, `torch

, transformers | | Nền tảng | Linux, macOS, Windows | | Thẻ |

Distributed Training

, `HuggingFace

, `Accelerate

, `DeepSpeed

, `FSDP

, `Mixed Precision

, `PyTorch

, `DDP

, `Unified API

, Simple |

Tham khảo: đầy đủ SKILL.md

thông tin

Sau đây là định nghĩa kỹ năng đầy đủ mà Hermes tải khi kỹ năng này được kích hoạt. Đây là những gì tác nhân coi là hướng dẫn khi kỹ năng được kích hoạt.

Ôm Mặt Tăng Tốc - Thống Nhất Phân Phối Đào Tạo

Bắt đầu nhanh

Tăng tốc đơn giản hóa việc đào tạo phân tán thành 4 dòng mã.

Cài đặt:

`

pip install accelerate

`
``**Chuyển đổi tập lệnh PyTorch** (4 dòng):

`
`Python
 import torch
+ from accelerate import Accelerator
+ accelerator = Accelerator()

model = torch.nn.Transformer()
  optimizer = torch.optim.Adam(model.parameters())
  dataloader = torch.utils.data.DataLoader(dataset)
+ model, optimizer, dataloader = accelerator.prepare(model, optimizer, dataloader)

for batch in dataloader:
      optimizer.zero_grad()
      loss = model(batch)

-     loss.backward()
+     accelerator.backward(loss)
      optimizer.step()

`
``**Chạy** (lệnh đơn):

`
``` bash
accelerate launch train.py

`

## Quy trình công việc chung

### Workflow 1: Từ GPU đơn đến multi GPU`**Kịch bản gốc**:

`
`Python

# train.py
 import torch`model = torch.nn.Linear(10, 2).to('cuda')
optimizer = torch.optim.Adam(model.parameters())
dataloader = torch.utils.data.DataLoader(dataset, batch_size=32)

for epoch in range(10):
    for batch in dataloader:
        batch = batch.to('cuda')
        optimizer.zero_grad()
        loss = model(batch).mean()
        loss.backward()
        optimizer.step()

`
``**Với Tăng tốc** (đã thêm 4 dòng):

`
``` python

# train.py
 import torch
from accelerate import Accelerator  # +1`accelerator = Accelerator()  # +2`model = torch.nn.Linear(10, 2)
optimizer = torch.optim.Adam(model.parameters())
dataloader = torch.utils.data.DataLoader(dataset, batch_size=32)

model, optimizer, dataloader = accelerator.prepare(model, optimizer, dataloader)  # +3`for epoch in range(10):
    for batch in dataloader:
        # No .to('cuda') needed - automatic!
        optimizer.zero_grad()
        loss = model(batch).mean()
        accelerator.backward(loss)  # +4
        optimizer.step()

`
``**Cấu hình** (tương tác):

`
``` bash
accelerate config

`
``**Câu hỏi**:

- Máy nào? (đơn/đa GPU/TPU/CPU)
- Có bao nhiêu máy? (1)
- Độ chính xác hỗn hợp? (không/fp16/bf16/fp8)
- Tốc độ sâu? (không/có)

**Khởi chạy** (hoạt động trên mọi thiết lập):

`
``` bash

# Single GPU
accelerate launch train.py

# Multi-GPU (8 GPUs)
accelerate launch --multi_gpu --num_processes 8 train.py

# Multi-node
accelerate launch --multi_gpu --num_processes 16 \
  --num_machines 2 --machine_rank 0 \
  --main_process_ip $MASTER_ADDR \
  train.py

`

### Quy trình 2: Huấn luyện độ chính xác hỗn hợp`**Bật FP16/BF16**:

`
``` python
from accelerate import Accelerator

# FP16 (with gradient scaling)
accelerator = Accelerator(mixed_precision='fp16')

# BF16 (no scaling, more stable)
accelerator = Accelerator(mixed_precision='bf16')

# FP8 (H100+)
accelerator = Accelerator(mixed_precision='fp8')

model, optimizer, dataloader = accelerator.prepare(model, optimizer, dataloader)

# Everything else is automatic!
for batch in dataloader:
    with accelerator.autocast():  # Optional, done automatically
        loss = model(batch)
    accelerator.backward(loss)

`

### Quy trình làm việc 3: Tích hợp DeepSpeed Zero`**Bật DeepSpeed ZeRO-2**:

`
`Python
from accelerate import Accelerator`accelerator = Accelerator(
    mixed_precision='bf16',
    deepspeed_plugin={
        "zero_stage": 2,  # ZeRO-2
        "offload_optimizer": False,
        "gradient_accumulation_steps": 4
    }
)

# Same code as before!
model, optimizer, dataloader = accelerator.prepare(model, optimizer, dataloader)

`
``**Hoặc thông qua cấu hình**:

`
`bash
accelerate config

# Select: DeepSpeed → ZeRO-2

`
``**deepspeed_config.JSON**:

`
``` json
{
    "fp16": \{"enabled": false},
    "bf16": \{"enabled": true},
    "zero_optimization": {
        "stage": 2,
        "offload_optimizer": \{"device": "cpu"},
        "allgather_bucket_size": 5e8,
        "reduce_bucket_size": 5e8
    }
}

`
``**Khởi động**:

`
`bash
accelerate launch --config_file deepspeed_config.JSON train.py

`

### Quy trình làm việc 4: FSDP (Song song dữ liệu được phân chia hoàn toàn)

**Bật FSDP**:

`
`Python
from accelerate import Accelerator, FullyShardedDataParallelPlugin`fsdp_plugin = FullyShardedDataParallelPlugin(
    sharding_strategy="FULL_SHARD",  # ZeRO-3 equivalent
    auto_wrap_policy="TRANSFORMER_AUTO_WRAP",
    cpu_offload=False
)

accelerator = Accelerator(
    mixed_precision='bf16',
    fsdp_plugin=fsdp_plugin
)

model, optimizer, dataloader = accelerator.prepare(model, optimizer, dataloader)

`
``**Hoặc thông qua cấu hình**:

`
`bash
accelerate config

# Select: FSDP → Full Shard → No CPU Offload

`

### Quy trình 5: Tích lũy độ dốc`**Tích lũy độ dốc**:

`
``` python
from accelerate import Accelerator`accelerator = Accelerator(gradient_accumulation_steps=4)

model, optimizer, dataloader = accelerator.prepare(model, optimizer, dataloader)

for batch in dataloader:
    with accelerator.accumulate(model):  # Handles accumulation
        optimizer.zero_grad()
        loss = model(batch)
        accelerator.backward(loss)
        optimizer.step()

`
``**Kích thước lô hiệu quả**: 
`batch_size * num_gpus * gradient_accumulation_steps

## Khi nào nên sử dụng so với các lựa chọn thay thế`**Sử dụng Tăng tốc khi**:

- Muốn đào tạo phân tán đơn giản nhất
- Cần tập lệnh duy nhất cho mọi phần cứng
- Sử dụng hệ sinh thái HuggingFace
- Muốn có sự linh hoạt (DDP/DeepSpeed/FSDP/Megatron)
- Cần tạo mẫu nhanh`**Ưu điểm chính**:
- **4 dòng**: Thay đổi mã tối thiểu
- **API hợp nhất**: Cùng mã cho DDP, DeepSpeed, FSDP, Megatron
- **Tự động**: Vị trí thiết bị, độ chính xác hỗn hợp, phân mảnh
- **Cấu hình tương tác**: Không có thiết lập trình khởi chạy thủ công
- **Ra mắt một lần**: Hoạt động ở mọi nơi`**Thay vào đó hãy sử dụng các lựa chọn thay thế**:
- **PyTorch Lightning**: Cần lệnh gọi lại, tóm tắt cấp cao
- **Ray Train**: Điều phối nhiều nút, điều chỉnh siêu tham số
- **DeepSpeed**: Kiểm soát API trực tiếp, các tính năng nâng cao
- **DDP thô**: Kiểm soát tối đa, mức độ trừu tượng tối thiểu

## Các vấn đề thường gặp`**Vấn đề: Vị trí thiết bị sai**

Không di chuyển thủ công đến thiết bị:

`
``` python

# WRONG
batch = batch.to('cuda')

# CORRECT
# Accelerate handles it automatically after prepare()

`
``**Vấn đề: Tích lũy độ dốc không hoạt động**

Sử dụng trình quản lý bối cảnh:

`
``` python

# CORRECT
with accelerator.accumulate(model):
    optimizer.zero_grad()
    accelerator.backward(loss)
    optimizer.step()

`
``**Vấn đề: Điểm kiểm tra trong phân phối**

Sử dụng phương pháp tăng tốc:

`
``` python

# Save only on main process
if accelerator.is_main_process:
    accelerator.save_state('checkpoint/')

# Load on all processes
accelerator.load_state('checkpoint/')

`
``**Vấn đề: Kết quả khác nhau với FSDP**

Đảm bảo hạt giống ngẫu nhiên giống nhau:

`
``` python
from accelerate.utils import set_seed
set_seed(42)

`

## Chủ đề nâng cao`**Tích hợp Megatron**: Xem [references/megatron-integration.md](https://GitHub.com/NousResearch/Hermes-agent/blob/main/optional-skills/mlops/accelerate/references/megatron-integration.md) để biết tính song song tensor, tính song song đường ống và thiết lập song song trình tự.

**Plugin tùy chỉnh**: Xem [references/custom-plugins.md](https://GitHub.com/NousResearch/Hermes-agent/blob/main/optional-skills/mlops/accelerate/references/custom-plugins.md) để tạo plugin phân phối tùy chỉnh và cấu hình nâng cao.

**Điều chỉnh hiệu suất**: Xem [references/performance.md](https://GitHub.com/NousResearch/Hermes-agent/blob/main/optional-skills/mlops/accelerate/references/performance.md) để biết cấu hình, tối ưu hóa bộ nhớ và các phương pháp hay nhất.

## Yêu cầu về phần cứng
- **CPU**: Hoạt động (chậm)

- **GPU đơn**: Hoạt động
- **Đa GPU**: DDP (mặc định), DeepSpeed hoặc FSDP
- **Đa nút**: DDP, DeepSpeed, FSDP, Megatron
- **TPU**: Được hỗ trợ
- **Apple MPS**: Được hỗ trợ`**Yêu cầu về trình khởi chạy**:
- **DDP**: 
`torch.distributed.run
` (tích hợp sẵn)
- **DeepSpeed**: 
`deepspeed
` (tốc độ cài đặt pip sâu)
- **FSDP**: PyTorch 1.12+ (tích hợp sẵn)
- **Megatron**: Thiết lập tùy chỉnh

## Tài nguyên- Tài liệu: https://huggingface.co/docs/accelerate
- GitHub: https://GitHub.com/huggingface/accelerate
- Phiên bản: 1.11.0+
- Hướng dẫn: "Tăng tốc tập lệnh của bạn"
- Ví dụ: https://GitHub.com/huggingface/accelerate/tree/main/examples
- Được sử dụng bởi: HuggingFace Transformers, TRL, PEFT, tất cả thư viện HF