# Làm việc với các mô hình lớn

## Phân phát và chuyển

### init_empty_weights[[accelerate.init_empty_weights]]

#### accelerate.init_empty_weights[[accelerate.init_empty_weights]]

```python
accelerate.init_empty_weights(include_buffers: bool | None = None)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/main/src/accelerate/big_modeling.py#L61)

**Tham số:**

include_buffers (`bool`, *tùy chọn*) : Có nên đặt tất cả các buffer lên thiết bị meta trong khi khởi tạo hay không.

Một trình quản lý ngữ cảnh (context manager) mà trong đó các mô hình được khởi tạo với tất cả các tham số trên thiết bị meta, do đó tạo ra một mô hình rỗng. Hữu ích khi việc chỉ khởi tạo mô hình đã làm tràn bộ nhớ RAM khả dụng.

Ví dụ:

```python
import torch.nn as nn
from accelerate import init_empty_weights

# Initialize a model with 100 billions parameters in no time and without using any RAM.
with init_empty_weights():
    tst = nn.Sequential(*[nn.Linear(10000, 10000) for _ in range(1000)])
```

Bất kỳ model nào được tạo dưới context manager này đều không có weights. Do đó, bạn không thể thực hiện thao tác như `model.to(some_device)` với nó. Để nạp weights vào model rỗng của bạn, hãy xem [load_checkpoint_and_dispatch()](/docs/accelerate/main/vi/package_reference/big_modeling#accelerate.load_checkpoint_and_dispatch). Hãy đảm bảo ghi đè tham số device_map mặc định của [load_checkpoint_and_dispatch()](/docs/accelerate/main/vi/package_reference/big_modeling#accelerate.load_checkpoint_and_dispatch), nếu không dispatch sẽ không được gọi.

### cpu_offload[[accelerate.cpu_offload]]

#### accelerate.cpu_offload[[accelerate.cpu_offload]]

```python
accelerate.cpu_offload(model: Module, execution_device: torch.device | None = None, offload_buffers: bool = False, state_dict: dict[str, torch.Tensor] | None = None, preload_module_classes: list[str] | None = None)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/main/src/accelerate/big_modeling.py#L179)

**Tham số:**

model (`torch.nn.Module`) : Mô hình cần offload.

execution_device (`torch.device`, *tùy chọn*) : Thiết bị mà bước truyền thẳng của mô hình sẽ được thực thi (phải là GPU). Mặc định sẽ là thiết bị của tham số đầu tiên của mô hình.

offload_buffers (`bool`, *tùy chọn*, mặc định là `False`) : Có offload các buffer cùng với các tham số của mô hình hay không.

state_dict (`Dict[str, torch.Tensor]`, *tùy chọn*) : state dict của mô hình sẽ được giữ trên CPU.

preload_module_classes (`List[str]`, *tùy chọn*) : Một danh sách các lớp mà các instance của chúng cần tải tất cả trọng số (kể cả trong các submodule) ngay ở đầu forward. Chỉ nên sử dụng cho các lớp có các submodule được đăng ký nhưng không được gọi trực tiếp trong quá trình forward, chẳng hạn nếu một lớp tuyến tính `dense` được đăng ký, nhưng khi forward, `dense.weight` và `dense.bias` được sử dụng trong một số thao tác thay vì gọi trực tiếp `dense`.

Kích hoạt offload CPU hoàn toàn cho một model. Kết quả là tất cả các tham số của model sẽ được offload và chỉ giữ lại một bản sao của state dict của model. Trong quá trình forward pass, các tham số sẽ được trích xuất từ state dict đó và đặt lên thiết bị thực thi được truyền vào khi cần, sau đó lại được offload.

### cpu_offload_with_hook[[accelerate.cpu_offload_with_hook]]

#### accelerate.cpu_offload_with_hook[[accelerate.cpu_offload_with_hook]]

```python
accelerate.cpu_offload_with_hook(model: Module, execution_device: int | str | torch.device | None = None, prev_module_hook: accelerate.hooks.UserCpuOffloadHook | None = None)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/main/src/accelerate/big_modeling.py#L225)

**Tham số:**

model (`torch.nn.Module`) : Mô hình cần offload.

execution_device(`str`, `int` hoặc `torch.device`, *tuỳ chọn*) : Thiết bị mà mô hình nên được thực thi. Mặc định sẽ là thiết bị MPS nếu khả dụng, sau đó là thiết bị 0 nếu có thiết bị tăng tốc, và cuối cùng là CPU.

prev_module_hook (`UserCpuOffloadHook`, *tùy chọn*) : Hook được trả về bởi hàm này cho một model trước đó trong pipeline bạn đang chạy. Nếu được truyền vào, phương thức offload của nó sẽ được gọi ngay trước khi thực hiện forward của model mà hook này được gắn vào.

Tải mô hình xuống CPU và đưa nó trở lại thiết bị thực thi khi được thực thi. Sự khác biệt so với [cpu_offload()](/docs/accelerate/main/vi/package_reference/big_modeling#accelerate.cpu_offload) là mô hình vẫn ở trên thiết bị thực thi sau khi forward và chỉ được tải xuống lại khi phương thức `offload` của `hook` được trả về được gọi. Hữu ích cho các pipeline chạy mô hình trong một vòng lặp.

Ví dụ:

```py
model_1, hook_1 = cpu_offload_with_hook(model_1, device)
model_2, hook_2 = cpu_offload_with_hook(model_2, device, prev_module_hook=hook_1)
model_3, hook_3 = cpu_offload_with_hook(model_3, device, prev_module_hook=hook_2)

hid_1 = model_1(input)
for i in range(50):
    # model1 is offloaded on the CPU at the first iteration, model 2 stays on the GPU for this whole loop.
    hid_2 = model_2(hid_1)
# model2 is offloaded to the CPU just before this forward.
hid_3 = model_3(hid_3)

# For model3, you need to manually call the hook offload method.
hook_3.offload()
```

### disk_offload[[accelerate.disk_offload]]

#### accelerate.disk_offload[[accelerate.disk_offload]]

```python
accelerate.disk_offload(model: Module, offload_dir: str | os.PathLike, execution_device: torch.device | None = None, offload_buffers: bool = False, preload_module_classes: list[str] | None = None)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/main/src/accelerate/big_modeling.py#L269)

**Tham số:**

model (`torch.nn.Module`) : Mô hình cần offload.

offload_dir (`str` hoặc `os.PathLike`) : Thư mục để offload trọng số mô hình (hoặc nơi trọng số mô hình đã được offload).

execution_device (`torch.device`, *tùy chọn*) : Thiết bị mà bước truyền thẳng của mô hình sẽ được thực thi (phải là GPU). Mặc định sẽ là thiết bị của tham số đầu tiên của mô hình.

offload_buffers (`bool`, *tùy chọn*, mặc định là `False`) : Có offload các buffer cùng với các tham số của mô hình hay không.

preload_module_classes (`List[str]`, *tùy chọn*) : Một danh sách các lớp mà các instance của chúng cần tải tất cả trọng số (kể cả trong các submodule) ngay ở đầu forward. Chỉ nên sử dụng cho các lớp có các submodule được đăng ký nhưng không được gọi trực tiếp trong quá trình forward, chẳng hạn nếu một lớp tuyến tính `dense` được đăng ký, nhưng khi forward, `dense.weight` và `dense.bias` được sử dụng trong một số thao tác thay vì gọi trực tiếp `dense`.

Kích hoạt offload toàn bộ đĩa cho một model. Kết quả là, tất cả các tham số của model sẽ được offload dưới dạng mảng memory-mapped vào một thư mục được chỉ định. Trong quá trình forward pass, các tham số sẽ được truy cập từ thư mục đó và được đưa lên thiết bị thực thi được truyền vào khi cần, sau đó lại được offload.

### dispatch_model[[accelerate.dispatch_model]]

#### accelerate.dispatch_model[[accelerate.dispatch_model]]

```python
accelerate.dispatch_model(model: Module, device_map: dict, main_device: torch.device | None = None, state_dict: dict[str, torch.Tensor] | None = None, offload_dir: str | os.PathLike | None = None, offload_index: dict[str, str] | None = None, offload_buffers: bool = False, skip_keys: str | list[str] | None = None, preload_module_classes: list[str] | None = None, force_hooks: bool = False)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/main/src/accelerate/big_modeling.py#L315)

**Tham số:**

model (`torch.nn.Module`) : Mô hình cần dispatch.

device_map (`Dict[str, Union[str, int, torch.device]]`) : Một từ điển ánh xạ tên module trong `state_dict` của các model đến thiết bị mà chúng nên được đặt. Lưu ý rằng `"disk"` được chấp nhận ngay cả khi nó không phải là giá trị hợp lệ cho `torch.device`.

main_device (`str`, `int` hoặc `torch.device`, *tuỳ chọn*) : Thiết bị thực thi chính. Mặc định sẽ là thiết bị đầu tiên trong `device_map` khác với `"cpu"` hoặc `"disk"`.

state_dict (`Dict[str, torch.Tensor]`, *tùy chọn*) : state dict của phần mô hình sẽ được giữ trên CPU.

offload_dir (`str` hoặc `os.PathLike`) : Thư mục để offload trọng số mô hình (hoặc nơi trọng số mô hình đã được offload).

offload_index (`Dict`, *tùy chọn*) : Một từ điển ánh xạ từ tên trọng số đến thông tin của chúng (`dtype`/ `shape` hoặc tên tệp safetensors). Mặc định sẽ dùng chỉ mục được lưu trong `save_folder`.

offload_buffers (`bool`, *tùy chọn*, mặc định là `False`) : Có offload các buffer cùng với các tham số của mô hình hay không.

skip_keys (`str` hoặc `List[str]`, *tùy chọn*) : Một danh sách các khóa cần bỏ qua khi di chuyển đầu vào hoặc đầu ra giữa các thiết bị.

preload_module_classes (`List[str]`, *tùy chọn*) : Một danh sách các lớp mà các instance của chúng cần tải tất cả trọng số (kể cả trong các submodule) ngay ở đầu forward. Chỉ nên sử dụng cho các lớp có các submodule được đăng ký nhưng không được gọi trực tiếp trong quá trình forward, chẳng hạn nếu một lớp tuyến tính `dense` được đăng ký, nhưng khi forward, `dense.weight` và `dense.bias` được sử dụng trong một số thao tác thay vì gọi trực tiếp `dense`.

force_hooks (`bool`, *tùy chọn*, mặc định là `False`) : Có nên buộc gắn các device hooks vào mô hình ngay cả khi tất cả các lớp đều được điều phối đến một thiết bị duy nhất hay không.

Phân phối một mô hình theo bản đồ thiết bị được chỉ định. Các lớp của mô hình có thể được phân bổ trên các GPU, chuyển xuống CPU hoặc thậm chí xuống ổ đĩa.

### load_checkpoint_and_dispatch[[accelerate.load_checkpoint_and_dispatch]]

#### accelerate.load_checkpoint_and_dispatch[[accelerate.load_checkpoint_and_dispatch]]

```python
accelerate.load_checkpoint_and_dispatch(model: Module, checkpoint: str | os.PathLike, device_map: str | dict[str, int | str | torch.device] | None = None, max_memory: dict[int | str, int | str] | None = None, no_split_module_classes: list[str] | None = None, offload_folder: str | os.PathLike | None = None, offload_buffers: bool = False, dtype: str | torch.dtype | None = None, offload_state_dict: bool | None = None, skip_keys: str | list[str] | None = None, preload_module_classes: list[str] | None = None, force_hooks: bool = False, strict: bool = False, full_state_dict: bool = True, broadcast_from_rank0: bool = False)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/main/src/accelerate/big_modeling.py#L524)

**Tham số:**

model (`torch.nn.Module`) : Mô hình mà chúng ta muốn nạp checkpoint vào.

checkpoint (`str` hoặc `os.PathLike`) : Thư mục checkpoint cần tải. Có thể là: - đường dẫn đến tệp chứa toàn bộ state dict của model - đường dẫn đến tệp `.json` chứa index của checkpoint dạng sharded - đường dẫn đến thư mục chứa tệp `.index.json` duy nhất và các shard của checkpoint.

device_map (`Dict[str, Union[int, str, torch.device]]`, *tùy chọn*) : Một bản đồ chỉ định vị trí mà mỗi submodule nên được đặt. Không cần phải chi tiết đến tên của từng parameter/buffer, một khi tên của một module đã được đưa vào, mọi submodule của nó sẽ được gửi đến cùng một device. Để Accelerate tự động tính toán `device_map` tối ưu nhất, hãy đặt `device_map="auto"`. Để biết thêm thông tin về từng tùy chọn, xem [tại đây](../concept_guides/big_model_inference#designing-a-device-map). Mặc định là None, nghĩa là [dispatch_model()](/docs/accelerate/main/vi/package_reference/big_modeling#accelerate.dispatch_model) sẽ không được gọi.

max_memory (`Dict`, *tùy chọn*) : Một từ điển ánh xạ định danh thiết bị tới bộ nhớ tối đa. Nếu không được đặt, giá trị mặc định sẽ là bộ nhớ tối đa khả dụng cho mỗi GPU và RAM CPU khả dụng.

no_split_module_classes (`List[str]`, *tùy chọn*) : Một danh sách tên lớp (layer) không bao giờ được chia cắt giữa các thiết bị (ví dụ bất kỳ lớp nào có kết nối dư - residual connection).

offload_folder (`str` hoặc `os.PathLike`, *tùy chọn*) : Nếu `device_map` chứa bất kỳ giá trị nào là `"disk"`, đây là thư mục nơi chúng ta sẽ offload các trọng số.

offload_buffers (`bool`, *tùy chọn*, mặc định là `False`) : Trong các lớp được offload lên CPU hoặc ổ cứng, có offload cả buffers cùng với các tham số hay không.

dtype (`str` hoặc `torch.dtype`, *tùy chọn*) : Nếu được cung cấp, trọng số sẽ được chuyển đổi sang kiểu đó khi được nạp.

offload_state_dict (`bool`, *tùy chọn*) : Nếu `True`, sẽ tạm thời offload state dict CPU xuống ổ cứng để tránh hết RAM CPU nếu trọng số của state dict CPU + shard lớn nhất không vừa. Mặc định sẽ là `True` nếu device map được chọn chứa các giá trị `"disk"`.

skip_keys (`str` hoặc `List[str]`, *tùy chọn*) : Một danh sách các khóa cần bỏ qua khi di chuyển đầu vào hoặc đầu ra giữa các thiết bị.

preload_module_classes (`List[str]`, *tùy chọn*) : Một danh sách các lớp mà các instance của chúng cần tải tất cả trọng số (kể cả trong các submodule) ngay ở đầu forward. Chỉ nên sử dụng cho các lớp có các submodule được đăng ký nhưng không được gọi trực tiếp trong quá trình forward, chẳng hạn nếu một lớp tuyến tính `dense` được đăng ký, nhưng khi forward, `dense.weight` và `dense.bias` được sử dụng trong một số thao tác thay vì gọi trực tiếp `dense`.

force_hooks (`bool`, *tùy chọn*, mặc định là `False`) : Có nên buộc gắn các device hooks vào mô hình ngay cả khi tất cả các lớp đều được điều phối đến một thiết bị duy nhất hay không.

strict (`bool`, *tùy chọn*, mặc định là `False`) : Có nên thực thi nghiêm ngặt việc các khóa trong state_dict của checkpoint khớp với các khóa của state_dict của mô hình hay không.

full_state_dict (`bool`, *tùy chọn*, mặc định là `True`) : nếu giá trị này được đặt thành `True`, tất cả các tensor trong state_dict đã tải sẽ được gom lại. state_dict đã tải sẽ không chứa ShardedTensor và DTensor.

broadcast_from_rank0 (`False`, *tùy chọn*, mặc định là `False`) : khi tùy chọn này là `True`, một `ProcessGroup` phân tán phải được khởi tạo. rank0 sẽ nhận một state_dict đầy đủ và sẽ broadcast các tensor trong state_dict lần lượt đến các rank khác. Các rank khác sẽ nhận các tensor và chia nhỏ (nếu áp dụng) theo các shard cục bộ trong mô hình.

Tải một checkpoint (có thể được chia mảnh) bên trong một model, có thể gửi trọng số đến một thiết bị đã cho trong khi chúng được tải và thêm các hook khác nhau để model này chạy đúng cách (ngay cả khi được chia trên nhiều thiết bị).

Ví dụ:

```python
>>> from accelerate import init_empty_weights, load_checkpoint_and_dispatch
>>> from huggingface_hub import hf_hub_download
>>> from transformers import AutoConfig, AutoModelForCausalLM

>>> # Download the Weights
>>> checkpoint = "EleutherAI/gpt-j-6B"
>>> weights_location = hf_hub_download(checkpoint, "pytorch_model.bin")

>>> # Create a model and initialize it with empty weights
>>> config = AutoConfig.from_pretrained(checkpoint)
>>> with init_empty_weights():
...     model = AutoModelForCausalLM.from_config(config)

>>> # Load the checkpoint and dispatch it to the right devices
>>> model = load_checkpoint_and_dispatch(
...     model, weights_location, device_map="auto", no_split_module_classes=["GPTJBlock"]
... )
```

### load_checkpoint_in_model[[accelerate.load_checkpoint_in_model]]

#### accelerate.load_checkpoint_in_model[[accelerate.load_checkpoint_in_model]]

```python
accelerate.load_checkpoint_in_model(model: Module, checkpoint: str | os.PathLike, device_map: dict[str, int | str | torch.device] | None = None, offload_folder: str | os.PathLike | None = None, dtype: str | torch.dtype | None = None, offload_state_dict: bool = False, offload_buffers: bool = False, keep_in_fp32_modules: list[str] | None = None, offload_8bit_bnb: bool = False, strict: bool = False, full_state_dict: bool = True, broadcast_from_rank0: bool = False)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L1830)

**Tham số:**

model (`torch.nn.Module`) : Mô hình mà chúng ta muốn nạp checkpoint vào.

checkpoint (`str` hoặc `os.PathLike`) : Thư mục checkpoint cần tải. Có thể là: - đường dẫn đến tệp chứa toàn bộ state dict của model - đường dẫn đến tệp `.json` chứa index của checkpoint dạng sharded - đường dẫn đến thư mục chứa tệp `.index.json` duy nhất và các shard của checkpoint. - đường dẫn đến thư mục chứa tệp pytorch_model.bin hoặc model.safetensors duy nhất.

device_map (`Dict[str, Union[int, str, torch.device]]`, *tùy chọn*) : Một bản đồ chỉ định vị trí mà mỗi submodule nên được đặt. Không cần phải chi tiết đến tên của từng parameter/buffer, một khi tên của một module đã được đưa vào, mọi submodule của nó sẽ được gửi đến cùng một device.

offload_folder (`str` hoặc `os.PathLike`, *tùy chọn*) : Nếu `device_map` chứa bất kỳ giá trị nào là `"disk"`, đây là thư mục nơi chúng ta sẽ offload các trọng số.

dtype (`str` hoặc `torch.dtype`, *tùy chọn*) : Nếu được cung cấp, trọng số sẽ được chuyển đổi sang kiểu đó khi được nạp.

offload_state_dict (`bool`, *tùy chọn*, mặc định là `False`) : Nếu `True`, sẽ tạm thời offload state dict CPU xuống ổ cứng để tránh hết RAM CPU nếu trọng số của state dict CPU + shard lớn nhất không vừa.

offload_buffers (`bool`, *tùy chọn*, mặc định là `False`) : Có bao gồm các buffer trong các trọng số được chuyển xuống đĩa hay không.

keep_in_fp32_modules(`List[str]`, *tuỳ chọn*) : Một danh sách các module mà chúng ta giữ ở kiểu dữ liệu `torch.float32`.

offload_8bit_bnb (`bool`, *tùy chọn*) : Có bật offload các module 8-bit lên cpu/disk hay không.

strict (`bool`, *tùy chọn*, mặc định là `False`) : Có nên thực thi nghiêm ngặt việc các khóa trong state_dict của checkpoint khớp với các khóa của state_dict của mô hình hay không.

full_state_dict (`bool`, *tùy chọn*, mặc định là `True`) : nếu giá trị này được đặt thành `True`, tất cả các tensor trong state_dict đã tải sẽ được gom lại. state_dict đã tải sẽ không chứa ShardedTensor và DTensor.

broadcast_from_rank0 (`False`, *tùy chọn*, mặc định là `False`) : khi tùy chọn này là `True`, một `ProcessGroup` phân tán phải được khởi tạo. rank0 sẽ nhận một state_dict đầy đủ và sẽ broadcast các tensor trong state_dict lần lượt đến các rank khác. Các rank khác sẽ nhận các tensor và chia nhỏ (nếu áp dụng) theo các shard cục bộ trong mô hình.

Tải một checkpoint (có thể được chia mảnh) bên trong một model, đồng thời có thể gửi các trọng số đến một thiết bị đã chỉ định trong quá trình tải.

Sau khi tải lên các thiết bị, bạn vẫn cần gọi [dispatch_model()](/docs/accelerate/main/vi/package_reference/big_modeling#accelerate.dispatch_model) trên mô hình của mình để nó có thể chạy. Để nhóm việc tải checkpoint và dispatch vào một lần gọi duy nhất, hãy sử dụng [load_checkpoint_and_dispatch()](/docs/accelerate/main/vi/package_reference/big_modeling#accelerate.load_checkpoint_and_dispatch).

### infer_auto_device_map[[accelerate.infer_auto_device_map]]

#### accelerate.infer_auto_device_map[[accelerate.infer_auto_device_map]]

```python
accelerate.infer_auto_device_map(model: Module, max_memory: dict[int | str, int | str] | None = None, no_split_module_classes: list[str] | None = None, dtype: str | torch.dtype | None = None, special_dtypes: dict[str, str | torch.dtype] | None = None, verbose: bool = False, clean_result: bool = True, offload_buffers: bool = False, fallback_allocation: bool = False)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L1319)

**Tham số:**

model (`torch.nn.Module`) : Mô hình cần phân tích.

max_memory (`Dict`, *tùy chọn*) : Một từ điển ánh xạ định danh thiết bị đến bộ nhớ tối đa. Nếu không được đặt, giá trị mặc định sẽ là bộ nhớ tối đa khả dụng. Ví dụ: `max_memory={0: "1GB"}`.

no_split_module_classes (`List[str]`, *tùy chọn*) : Một danh sách tên lớp (layer) không bao giờ được chia cắt giữa các thiết bị (ví dụ bất kỳ lớp nào có kết nối dư - residual connection).

dtype (`str` hoặc `torch.dtype`, *tùy chọn*) : Nếu được cung cấp, trọng số sẽ được chuyển đổi sang kiểu đó khi được nạp.

special_dtypes (`Dict[str, Union[str, torch.device]]`, *tùy chọn*) : Nếu được cung cấp, các dtype đặc biệt cần xem xét cho một số trọng số cụ thể (sẽ ghi đè dtype được dùng làm mặc định cho tất cả các trọng số).

verbose (`bool`, *tùy chọn*, mặc định là `False`) : Có cung cấp các câu lệnh gỡ lỗi khi hàm xây dựng device_map hay không.

clean_result (`bool`, *tùy chọn*, mặc định là `True`) : Làm sạch device_map kết quả bằng cách nhóm tất cả các submodule chạy trên cùng một thiết bị lại với nhau.

offload_buffers (`bool`, *tùy chọn*, mặc định là `False`) : Trong các lớp được offload lên CPU hoặc ổ cứng, có offload cả buffers cùng với các tham số hay không.

fallback_allocation (`bool`, *tùy chọn*, mặc định là `False`) : Khi phân bổ thông thường thất bại, hãy thử phân bổ một module phù hợp với giới hạn kích thước bằng BFS.

Tính toán bản đồ thiết bị cho một mô hình đã cho, ưu tiên sử dụng GPU, sau đó offload sang CPU và cuối cùng offload sang đĩa, sao cho:
- chúng ta không vượt quá bộ nhớ khả dụng của bất kỳ GPU nào.
- nếu cần offload sang CPU, luôn còn chỗ trống trên GPU 0 để đưa lại lớp có kích thước lớn nhất đã được offload sang CPU.
- nếu cần offload sang CPU, chúng ta sẽ không vượt quá bộ nhớ RAM khả dụng trên CPU.
- nếu cần offload ra đĩa, luôn còn chỗ trống trên CPU để đưa lại lớp có kích thước lớn nhất đã được offload ra đĩa.

Toàn bộ phép tính được thực hiện bằng cách phân tích kích thước và dtype của các tham số mô hình. Do đó, mô hình có thể nằm trên thiết bị meta (như khi được khởi tạo bên trong trình quản lý ngữ cảnh `init_empty_weights`).

## Hooks

### ModelHook[[accelerate.hooks.ModelHook]]

#### accelerate.hooks.ModelHook[[accelerate.hooks.ModelHook]]

```python
accelerate.hooks.ModelHook()
```

[Nguồn](https://github.com/huggingface/accelerate/blob/main/src/accelerate/hooks.py#L58)

Một hook chứa các callback sẽ được thực thi ngay trước và sau phương thức forward của một model. Điểm khác biệt so với các hook có sẵn trong PyTorch là chúng được truyền kèm theo các kwargs.

Thuộc tính lớp:
- **no_grad** (`bool`, *tuỳ chọn*, mặc định là `False`) -- Có thực hiện bước truyền tiến thực sự dưới trình quản lý ngữ cảnh `torch.no_grad()` hay không.

#### detach_hook[[accelerate.hooks.ModelHook.detach_hook]]

```python
detach_hook(module)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/main/src/accelerate/hooks.py#L106)

**Tham số:**

module (`torch.nn.Module`) : Module được tách khỏi hook này.

Được thực thi khi hook được tách khỏi một module.

#### init_hook[[accelerate.hooks.ModelHook.init_hook]]

```python
init_hook(module)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/main/src/accelerate/hooks.py#L70)

**Tham số:**

module (`torch.nn.Module`) : Module được gắn với hook này.

Được thực thi khi hook được gắn vào module.

#### post_forward[[accelerate.hooks.ModelHook.post_forward]]

```python
post_forward(module, output)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/main/src/accelerate/hooks.py#L93)

**Tham số:**

module (`torch.nn.Module`) : Module mà bước forward của nó vừa được thực thi ngay trước sự kiện này.

output (`Any`) : Đầu ra của module.

**Trả về:** `Any`

`output` đã được xử lý.

Để được thực thi ngay sau phương thức forward của mô hình.

#### pre_forward[[accelerate.hooks.ModelHook.pre_forward]]

```python
pre_forward(module, *args, **kwargs)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/main/src/accelerate/hooks.py#L79)

**Tham số:**

module (`torch.nn.Module`) : Module mà bước forward sẽ được thực thi ngay sau sự kiện này.

args (`Tuple[Any]`) : Các đối số vị trí được truyền vào module.

kwargs (`Dict[Str, Any]`) : Các đối số dạng từ khóa được truyền vào module.

**Trả về:** `Tuple[Tuple[Any], Dict[Str, Any]]`

Một tuple chứa `args` và `kwargs` đã được xử lý.

Để được thực thi ngay trước phương thức forward của mô hình.

### AlignDevicesHook[[accelerate.hooks.AlignDevicesHook]]

#### accelerate.hooks.AlignDevicesHook[[accelerate.hooks.AlignDevicesHook]]

```python
accelerate.hooks.AlignDevicesHook(execution_device: int | str | torch.device | None = None, offload: bool = False, io_same_device: bool = False, weights_map: collections.abc.Mapping | None = None, offload_buffers: bool = False, place_submodules: bool = False, skip_keys: str | list[str] | None = None, tied_params_map: dict[int, dict[torch.device, torch.Tensor]] | None = None)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/main/src/accelerate/hooks.py#L242)

**Tham số:**

execution_device (`torch.device`, *tùy chọn*) : Thiết bị mà các đầu vào và trọng số mô hình cần được đặt trước khi thực hiện bước truyền thẳng (forward pass).

offload (`bool`, *tùy chọn*, mặc định là `False`) : Xác định xem có nên chuyển trọng số (offload) sau bước truyền trực tiếp (forward pass) hay không.

io_same_device (`bool`, *tùy chọn*, mặc định là `False`) : Xác định xem đầu ra có nên được đặt trên cùng thiết bị với đầu vào hay không.

weights_map (`Mapping[str, torch.Tensor]`, *tùy chọn*) : Khi trọng số của mô hình được offload, một bản ánh xạ (có thể là lazy) từ tên tham số đến giá trị tensor.

offload_buffers (`bool`, *tùy chọn*, mặc định là `False`) : Có bao gồm các buffer của module liên quan khi offloading hay không.

place_submodules (`bool`, *tùy chọn*, mặc định là `False`) : Có nên đặt các submodule trên `execution_device` trong sự kiện `init_hook` hay không.

Một `ModelHook` chung đảm bảo rằng các đầu vào và trọng số mô hình nằm trên cùng một thiết bị cho quá trình truyền trực tiếp của module liên quan, đồng thời có thể chuyển trọng số ra khỏi bộ nhớ sau quá trình truyền trực tiếp.

### SequentialHook[[accelerate.hooks.SequentialHook]]

#### accelerate.hooks.SequentialHook[[accelerate.hooks.SequentialHook]]

```python
accelerate.hooks.SequentialHook(*hooks)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/main/src/accelerate/hooks.py#L116)

Một hook có thể chứa nhiều hook và lặp qua chúng tại mỗi sự kiện.

### LayerwiseCastingHook[[accelerate.hooks.LayerwiseCastingHook]]

#### accelerate.hooks.LayerwiseCastingHook[[accelerate.hooks.LayerwiseCastingHook]]

```python
accelerate.hooks.LayerwiseCastingHook(storage_dtype: dtype, compute_dtype: dtype, non_blocking: bool)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/main/src/accelerate/hooks.py#L791)

Một hook chuyển đổi trọng số của một module sang dtype độ chính xác cao để tính toán và sang dtype độ chính xác thấp để lưu trữ. Quá trình này có thể dẫn đến mất chất lượng trong đầu ra, nhưng có thể giảm đáng kể bộ nhớ sử dụng.

## Thêm Hooks

### add_hook_to_module[[accelerate.hooks.add_hook_to_module]]

#### accelerate.hooks.add_hook_to_module[[accelerate.hooks.add_hook_to_module]]

```python
accelerate.hooks.add_hook_to_module(module: Module, hook: ModelHook, append: bool = False)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/main/src/accelerate/hooks.py#L147)

**Tham số:**

module (`torch.nn.Module`) : Module cần gắn hook vào.

hook (`ModelHook`) : Hook cần gắn.

append (`bool`, *tùy chọn*, mặc định là `False`) : Xác định xem hook có nên được nối tiếp với một hook hiện có (nếu module đã chứa hook) hay không.

**Trả về:** `torch.nn.Module`

Cùng một module, với hook được gắn vào (module được sửa đổi tại chỗ, nên kết quả có thể bị bỏ qua).

Thêm một hook vào một module đã cho. Thao tác này sẽ viết lại phương thức `forward` của module để bao gồm hook. Để loại bỏ hành vi này và khôi phục phương thức `forward` gốc, hãy sử dụng `remove_hook_from_module`.

Nếu module đã chứa một hook, hook này sẽ thay thế nó bằng hook mới được truyền theo mặc định. Để nối hai hook lại với nhau, hãy truyền `append=True` để nối hook hiện tại và hook mới thành một instance của lớp `SequentialHook`.

### attach_execution_device_hook[[accelerate.hooks.attach_execution_device_hook]]

#### accelerate.hooks.attach_execution_device_hook[[accelerate.hooks.attach_execution_device_hook]]

```python
accelerate.hooks.attach_execution_device_hook(module: Module, execution_device: int | str | torch.device, skip_keys: str | list[str] | None = None, preload_module_classes: list[str] | None = None, tied_params_map: dict[int, dict[torch.device, torch.Tensor]] | None = None)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/main/src/accelerate/hooks.py#L450)

**Tham số:**

module (`torch.nn.Module`) : Module nơi chúng ta muốn gắn các hooks.

execution_device (`int`, `str` hoặc `torch.device`) : Thiết bị mà các đầu vào và trọng số mô hình cần được đặt trước khi thực hiện bước truyền thẳng.

skip_keys (`str` hoặc `List[str]`, *tùy chọn*) : Một danh sách các khóa cần bỏ qua khi di chuyển đầu vào hoặc đầu ra giữa các thiết bị.

preload_module_classes (`List[str]`, *tùy chọn*) : Một danh sách các lớp mà các instance của chúng cần tải tất cả trọng số (kể cả trong các submodule) ngay ở đầu forward. Chỉ nên sử dụng cho các lớp có các submodule được đăng ký nhưng không được gọi trực tiếp trong quá trình forward, chẳng hạn nếu một lớp tuyến tính `dense` được đăng ký, nhưng khi forward, `dense.weight` và `dense.bias` được sử dụng trong một số thao tác thay vì gọi trực tiếp `dense`.

tied_params_map (Optional[Dict[int, Dict[torch.device, torch.Tensor]]], *optional*, mặc định là `None`) : Một bản đồ ánh xạ các con trỏ dữ liệu đến các từ điển ánh xạ thiết bị đến các trọng số liên kết đã được điều phối sẵn. Đối với một thiết bị thực thi cụ thể, tham số này hữu ích để tái sử dụng con trỏ khả dụng đầu tiên của một trọng số dùng chung cho tất cả các thiết bị khác, thay vì sao chép bộ nhớ.

Gắn đệ quy `AlignDevicesHook` vào tất cả các submodule của một model cho trước để đảm bảo chúng có thiết bị thực thi đúng

### attach_align_device_hook[[accelerate.hooks.attach_align_device_hook]]

#### accelerate.hooks.attach_align_device_hook[[accelerate.hooks.attach_align_device_hook]]

```python
accelerate.hooks.attach_align_device_hook(module: Module, execution_device: torch.device | None = None, offload: bool = False, weights_map: collections.abc.Mapping | None = None, offload_buffers: bool = False, module_name: str = '', skip_keys: str | list[str] | None = None, preload_module_classes: list[str] | None = None, tied_params_map: dict[int, dict[torch.device, torch.Tensor]] | None = None)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/main/src/accelerate/hooks.py#L498)

**Tham số:**

module (`torch.nn.Module`) : Module nơi chúng ta muốn gắn các hooks.

execution_device (`torch.device`, *tùy chọn*) : Thiết bị mà các đầu vào và trọng số mô hình cần được đặt trước khi thực hiện bước truyền thẳng (forward pass).

offload (`bool`, *tùy chọn*, mặc định là `False`) : Xác định xem có nên chuyển trọng số (offload) sau bước truyền trực tiếp (forward pass) hay không.

weights_map (`Mapping[str, torch.Tensor]`, *tùy chọn*) : Khi trọng số của mô hình được offload, một bản ánh xạ (có thể là lazy) từ tên tham số đến giá trị tensor.

offload_buffers (`bool`, *tùy chọn*, mặc định là `False`) : Có bao gồm các buffer của module liên quan khi offloading hay không.

module_name (`str`, *tùy chọn*, mặc định là `""`) : Tên của module.

skip_keys (`str` hoặc `List[str]`, *tùy chọn*) : Một danh sách các khóa cần bỏ qua khi di chuyển đầu vào hoặc đầu ra giữa các thiết bị.

preload_module_classes (`List[str]`, *tùy chọn*) : Một danh sách các lớp mà các instance của chúng cần tải tất cả trọng số (kể cả trong các submodule) ngay ở đầu forward. Chỉ nên sử dụng cho các lớp có các submodule được đăng ký nhưng không được gọi trực tiếp trong quá trình forward, chẳng hạn nếu một lớp tuyến tính `dense` được đăng ký, nhưng khi forward, `dense.weight` và `dense.bias` được sử dụng trong một số thao tác thay vì gọi trực tiếp `dense`.

tied_params_map (Optional[Dict[int, Dict[torch.device, torch.Tensor]]], *optional*, mặc định là `None`) : Một bản đồ ánh xạ các con trỏ dữ liệu đến các từ điển ánh xạ thiết bị đến các trọng số liên kết đã được điều phối sẵn. Đối với một thiết bị thực thi cụ thể, tham số này hữu ích để tái sử dụng con trỏ khả dụng đầu tiên của một trọng số dùng chung cho tất cả các thiết bị khác, thay vì sao chép bộ nhớ.

Gắn đệ quy `AlignDevicesHook` vào tất cả các submodule của một model cho trước có tham số và/hoặc buffer trực tiếp.

### attach_align_device_hook_on_blocks[[accelerate.hooks.attach_align_device_hook_on_blocks]]

#### accelerate.hooks.attach_align_device_hook_on_blocks[[accelerate.hooks.attach_align_device_hook_on_blocks]]

```python
accelerate.hooks.attach_align_device_hook_on_blocks(module: Module, execution_device: torch.device | dict[str, torch.device] | None = None, offload: bool | dict[str, bool] = False, weights_map: collections.abc.Mapping | None = None, offload_buffers: bool = False, module_name: str = '', skip_keys: str | list[str] | None = None, preload_module_classes: list[str] | None = None, tied_params_map: dict[int, dict[torch.device, torch.Tensor]] | None = None)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/main/src/accelerate/hooks.py#L593)

**Tham số:**

module (`torch.nn.Module`) : Module nơi chúng ta muốn gắn các hooks.

execution_device (`torch.device` hoặc `Dict[str, torch.device]`, *tùy chọn*) : Thiết bị mà các đầu vào và trọng số mô hình cần được đặt trước khi thực hiện bước truyền thẳng. Nó có thể là một thiết bị cho toàn bộ module, hoặc một từ điển ánh xạ tên module đến thiết bị.

offload (`bool`, *tùy chọn*, mặc định là `False`) : Xác định xem có nên offload trọng số sau bước forward hay không. Giá trị này có thể là một boolean cho toàn bộ module, hoặc một dictionary ánh xạ tên module sang boolean.

weights_map (`Mapping[str, torch.Tensor]`, *tùy chọn*) : Khi trọng số của mô hình được offload, một bản ánh xạ (có thể là lazy) từ tên tham số đến giá trị tensor.

offload_buffers (`bool`, *tùy chọn*, mặc định là `False`) : Có bao gồm các buffer của module liên quan khi offloading hay không.

module_name (`str`, *tùy chọn*, mặc định là `""`) : Tên của module.

skip_keys (`str` hoặc `List[str]`, *tùy chọn*) : Một danh sách các khóa cần bỏ qua khi di chuyển đầu vào hoặc đầu ra giữa các thiết bị.

preload_module_classes (`List[str]`, *tùy chọn*) : Một danh sách các lớp mà các instance của chúng cần tải tất cả trọng số (kể cả trong các submodule) ngay ở đầu forward. Chỉ nên sử dụng cho các lớp có các submodule được đăng ký nhưng không được gọi trực tiếp trong quá trình forward, chẳng hạn nếu một lớp tuyến tính `dense` được đăng ký, nhưng khi forward, `dense.weight` và `dense.bias` được sử dụng trong một số thao tác thay vì gọi trực tiếp `dense`.

tied_params_map (Optional[Dict[int, Dict[torch.device, torch.Tensor]]], *optional*, mặc định là `None`) : Một bản đồ ánh xạ các con trỏ dữ liệu đến các từ điển ánh xạ thiết bị đến các trọng số liên kết đã được điều phối sẵn. Đối với một thiết bị thực thi cụ thể, tham số này hữu ích để tái sử dụng con trỏ khả dụng đầu tiên của một trọng số dùng chung cho tất cả các thiết bị khác, thay vì sao chép bộ nhớ.

Gắn `AlignDevicesHook` vào tất cả các khối của một mô hình cho trước khi cần.

### attach_layerwise_casting_hooks[[accelerate.big_modeling.attach_layerwise_casting_hooks]]

#### accelerate.big_modeling.attach_layerwise_casting_hooks[[accelerate.big_modeling.attach_layerwise_casting_hooks]]

```python
accelerate.big_modeling.attach_layerwise_casting_hooks(module: Module, storage_dtype: dtype, compute_dtype: dtype, skip_modules_pattern: str | tuple[str, ...] | None = None, skip_modules_classes: tuple[type[torch.nn.Module], ...] | None = None, non_blocking: bool = False)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/main/src/accelerate/big_modeling.py#L665)

**Tham số:**

module (`torch.nn.Module`) : Module mà các module lá của nó sẽ được chuyển sang dtype độ chính xác cao để tính toán và sang dtype độ chính xác thấp để lưu trữ.

storage_dtype (`torch.dtype`) : dtype để chuyển đổi module trước/sau bước forward để lưu trữ.

compute_dtype (`torch.dtype`) : dtype để chuyển đổi module trong quá trình forward pass để tính toán.

skip_modules_pattern (`tuple[str, ...]`, mặc định là `None`) : Một danh sách các mẫu để khớp với tên của các module cần bỏ qua trong quá trình chuyển đổi kiểu dữ liệu theo từng lớp. Nếu được đặt thành `None` cùng với `skip_modules_classes` là `None`, quá trình chuyển đổi kiểu dữ liệu theo từng lớp sẽ được áp dụng trực tiếp lên module thay vì các submodule bên trong của nó.

skip_modules_classes (`tuple[type[torch.nn.Module], ...]`, mặc định là `None`) : Một danh sách các lớp module cần bỏ qua trong quá trình chuyển đổi kiểu theo từng lớp.

non_blocking (`bool`, mặc định là `False`) : Nếu `True`, các thao tác chuyển đổi trọng số sẽ không chặn.

Áp dụng việc chuyển kiểu (casting) theo từng lớp cho một module được chỉ định. Module kỳ vọng ở đây là một `nn.Module` của PyTorch. Điều này hữu ích để giảm yêu cầu về bộ nhớ khi không muốn lượng tử hóa (quantize) hoàn toàn một mô hình. Tham số của mô hình có thể được giữ ở dạng, ví dụ, `torch.float8_e4m3fn` và được chuyển lên (upcast) lên độ chính xác cao hơn như `torch.bfloat16` trong quá trình truyền thẳng (forward pass), sau đó được chuyển xuống (downcast) về `torch.float8_e4m3fn` để đạt được lợi ích tiết kiệm bộ nhớ.

Ví dụ:

```python
>>> from accelerate.hooks import attach_layerwise_casting_hooks
>>> from transformers import AutoModelForCausalLM
>>> import torch

>>> # Model
>>> checkpoint = "EleutherAI/gpt-j-6B"
>>> model = AutoModelForCausalLM.from_pretrained(checkpoint)

>>> # Attach hooks and perform inference
>>> attach_layerwise_casting_hooks(model, storage_dtype=torch.float8_e4m3fn, compute_dtype=torch.bfloat16)
>>> with torch.no_grad():
...     model(...)
```

Người dùng cũng có thể truyền các module mà họ muốn tránh bị downcast.

```py
>>> attach_layerwise_casting_hooks(
...     model, storage_dtype=torch.float8_e4m3fn, compute_dtype=torch.bfloat16, skip_modules_pattern=["norm"]
... )
```

## Gỡ bỏ Hooks

### remove_hook_from_module[[accelerate.hooks.remove_hook_from_module]]

#### accelerate.hooks.remove_hook_from_module[[accelerate.hooks.remove_hook_from_module]]

```python
accelerate.hooks.remove_hook_from_module(module: Module, recurse = False)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/main/src/accelerate/hooks.py#L205)

**Tham số:**

module (`torch.nn.Module`) : Module cần gắn hook vào.

recurse (`bool`, **tùy chọn**) : Có gỡ bỏ các hook đệ quy hay không

**Trả về:** `torch.nn.Module`

Cùng một module, với hook đã được tách ra (module được sửa đổi tại chỗ, nên kết quả có thể bị bỏ qua).

Xóa mọi hook được gắn vào một module thông qua `add_hook_to_module`.

### remove_hook_from_submodules[[accelerate.hooks.remove_hook_from_submodules]]

#### accelerate.hooks.remove_hook_from_submodules[[accelerate.hooks.remove_hook_from_submodules]]

```python
accelerate.hooks.remove_hook_from_submodules(module: Module)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/main/src/accelerate/hooks.py#L581)

**Tham số:**

module (`torch.nn.Module`) : Module cần gỡ bỏ tất cả các hook.

Xóa đệ quy tất cả các hook được gắn trên các submodule của một model cho trước.

## Công cụ tiện ích

### has_offloaded_params[[accelerate.utils.has_offloaded_params]]

#### accelerate.utils.has_offloaded_params[[accelerate.utils.has_offloaded_params]]

```python
accelerate.utils.has_offloaded_params(module: Module)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L2172)

**Tham số:**

module (`torch.nn.Module`) : Module cần kiểm tra hook offload.

**Trả về:** `bool`

`True` nếu module có offload hook và offloading được bật, `False` trong trường hợp ngược lại.

Kiểm tra xem một module có các tham số đã được offload hay không bằng cách kiểm tra xem module được cung cấp có gắn AlignDevicesHook với offloading được bật hay không

### align_module_device[[accelerate.utils.align_module_device]]

#### accelerate.utils.align_module_device[[accelerate.utils.align_module_device]]

```python
accelerate.utils.align_module_device(module: Module, execution_device: torch.device | None = None)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L2188)

**Tham số:**

module (`torch.nn.Module`) : Module có các tham số cần căn chỉnh.

execution_device (`torch.device`, *tùy chọn*) : Nếu được cung cấp, ghi đè thiết bị thực thi của module trong ngữ cảnh. Nếu không, sử dụng thiết bị thực thi của hook hoặc bỏ qua

Trình quản lý ngữ cảnh di chuyển các tham số của module sang thiết bị thực thi được chỉ định.