# DEFT: Tinh chỉnh hiệu quả phân rã cho các mô hình từ văn bản sang hình ảnh

[DEFT](https://proceedings.neurips.cc/paper_files/paper/2025/hash/93a34a7138bdad95e874018d5f491cc6-Abstract-Conference.html) (Decompositional Efficient Fine-Tuning) là một phương pháp tinh chỉnh hiệu quả về tham số cho các mô hình từ văn bản sang hình ảnh. Phương pháp này phân tách việc cập nhật ma trận trọng số đóng băng `W` thành hai thành phần có thể huấn luyện: một phép chiếu loại bỏ không gian con hạng thấp khỏi `W`, và một phép cập nhật hạng thấp đưa nội dung mới vào không gian con đó. Công thức này được thiết kế để cân bằng giữa việc căn chỉnh với phân phối mục tiêu, học các khái niệm mới từ một vài hình ảnh (cá nhân hóa) và duy trì khả năng tuân theo chỉ dẫn cũng như khả năng chỉnh sửa của mô hình được huấn luyện trước.

Cụ thể, DEFT kết hợp hai thành phần hạng thấp có thể huấn luyện: (1) một phép chiếu lên phần bù của một không gian con hạng thấp được tạo bởi một ma trận hạng thấp, và (2) một bản cập nhật hạng thấp. Ma trận hạng thấp đầu tiên xác định không gian con, trong khi ma trận thứ hai cho phép thích ứng tham số linh hoạt trong không gian con đó.

Khi nào nên sử dụng DEFT: phương pháp này phù hợp nhất để điều chỉnh mô hình cho dữ liệu hoặc khái niệm mới trong khi **giữ lại và thậm chí cải thiện khả năng tuân theo chỉ thị của mô hình gốc** và hạn chế **sự quên các khả năng trước đó ở mức tối thiểu**.

Với mỗi lớp đích, DEFT học một hướng chiếu `P` (hình dạng `out_features x r`) và một ma trận tiêm `R` (hình dạng `r x in_features`). Trọng số hiệu dụng là phép chiếu phần dư

```
W' = (I - P_proj) @ W + Q_P @ R
```

Bộ chiếu `P_proj` được suy ra từ `P` theo `decomposition_method`:

- `"relu"` (mặc định): `Q_P = P`, `P_proj = P @ relu(P).T` — một phép chiếu không trực giao.
- `"qr"`: `Q_P = qr(P)`, `P_proj = Q_P @ Q_P.T` — một phép chiếu trực giao.

Thuật toán `(I - P_proj) @ W` loại bỏ một không gian con của trọng số được huấn luyện trước, trong khi `Q_P @ R` tiêm nội dung mới vào đó. Mặc định (`init_weights=True`), `R` được khởi tạo sao cho phép cập nhật là một phép đồng nhất chính xác tại thời điểm khởi tạo (`W' == W`), do đó quá trình huấn luyện bắt đầu từ các trọng số được huấn luyện trước và học cách tiêm. Phép cập nhật tương đương với một delta cộng hạng thấp `Q_P @ (R - right.T @ W)`, được tính toán mà không bao giờ tạo ra ma trận chiếu `out x out` và có thể được hợp nhất vào các trọng số cơ bản để triển khai mà không cần suy luận.

Đặt `para=True` sẽ chọn biến thể [PaRa](https://proceedings.iclr.cc/paper_files/paper/2025/hash/f09e8dd9274cb7c2dd0dc65ffc6f427a-Abstract-Conference.html) (Parameter Rank Reduction): một bản cập nhật chỉ loại bỏ `W' = (I - P_proj) @ W`, giữ lại đúng hạng mục loại bỏ không gian con và bỏ qua phần tiêm. Chỉ có phép chiếu `P` được huấn luyện (không có ma trận tiêm `R`), do đó adapter không phải là phép đồng nhất tại thời điểm khởi tạo. PaRa được giới thiệu để cá nhân hóa các mô hình khuếch tán từ văn bản sang hình ảnh và có sẵn ở đây như một trường hợp đặc biệt của DEFT.

DEFT hiện được triển khai cho các lớp `torch.nn.Linear` và `Conv1D` (ví dụ: gpt-2, thông qua `fan_in_fan_out`). Bản triển khai gốc và các thí nghiệm từ bài báo (Dreambooth, Dreambench Plus, InsDet, VisualCloze, trên Stable Diffusion và một mô hình thống nhất) có sẵn tại [github.com/MAXNORM8650/DEFT](https://github.com/MAXNORM8650/DEFT).

Nếu bạn sử dụng DEFT trong công việc của mình, vui lòng trích dẫn bài báo:

```bibtex
@article{kumar2026deft,
  title={DEFT: Decompositional Efficient Fine-Tuning for Text-to-Image Models},
  author={Kumar, Komal and Anwer, Rao and Shahbaz Khan, Fahad and Khan, Salman and Laptev, Ivan and Cholakkal, Hisham},
  journal={Advances in Neural Information Processing Systems},
  volume={38},
  pages={102009--102035},
  year={2026}
}
```

Nếu bạn sử dụng biến thể PaRa (`para=True`), vui lòng trích dẫn thêm:

```bibtex
@inproceedings{chen2025personalizing,
  title={Para: Personalizing text-to-image diffusion via parameter rank reduction},
  author={Chen, Shangyu and Pan, Zizheng and Cai, Jianfei and Phung, Dinh},
  booktitle={International Conference on Learning Representations},
  year={2025}
}
```

## DeftConfig[[peft.DeftConfig]]

#### peft.DeftConfig[[peft.DeftConfig]]

```python
peft.DeftConfig(task_type: Optional[Union[str, TaskType]] = None, peft_type: Optional[Union[str, PeftType]] = None, auto_mapping: Optional[dict] = None, peft_version: Optional[str] = None, base_model_name_or_path: Optional[str] = None, revision: Optional[str] = None, inference_mode: bool = False, r: int = 8, target_modules: Optional[Union[list[str], str]] = None, exclude_modules: Optional[Union[list[str], str]] = None, decomposition_method: Literal['relu', 'qr'] = 'relu', init_scale: float = 1.0, alpha: Optional[int] = None, para: bool = False, fan_in_fan_out: bool = False, deft_dropout: float = 0.0, init_weights: bool = True, layers_to_transform: Optional[Union[list[int], int]] = None, layers_pattern: Optional[Union[list[str], str]] = None, bias: str = 'none', modules_to_save: Optional[list[str]] = None)
```

[Nguồn](https://github.com/huggingface/peft/blob/main/src/peft/tuners/deft/config.py#L25)

**Tham số:**

r (`int`) : Bậc của phép chiếu/phép tiêm DEFT xuyên suốt các lớp.

target_modules (`Optional[Union[List[str], str]]`) : Tên của các module cần áp dụng adapter. Nếu được chỉ định, chỉ các module có tên được chỉ định sẽ được thay thế. Khi truyền một chuỗi, một phép khớp regex sẽ được thực hiện. Khi truyền một danh sách các chuỗi, một phép khớp chính xác sẽ được thực hiện hoặc kiểm tra xem tên của module có kết thúc bằng bất kỳ chuỗi nào được truyền hay không. Nếu được chỉ định là 'all-linear', tất cả các module tuyến tính sẽ được chọn, ngoại trừ lớp đầu ra. Nếu không được chỉ định, các module sẽ được chọn theo kiến trúc của mô hình. Nếu kiến trúc không được biết đến, một lỗi sẽ được ném ra -- trong trường hợp này, bạn nên chỉ định các module đích thủ công.

exclude_modules (`Optional[Union[List[str], str]]`) : Tên của các module không áp dụng adapter. Khi truyền một chuỗi, một phép khớp regex sẽ được thực hiện. Khi truyền một danh sách các chuỗi, một phép khớp chính xác sẽ được thực hiện hoặc kiểm tra xem tên của module có kết thúc bằng bất kỳ chuỗi nào được truyền vào hay không.

decomposition_method (`str`) : Cách projector `P_proj` được suy ra từ `P`. Hoặc là `"relu"` (mặc định, `P @ relu(P).T` không trực giao) hoặc là `"qr"` (`Q_P @ Q_P.T` trực giao).

init_scale (`float`) : Hệ số tỷ lệ áp dụng cho độ lệch chuẩn được dùng để khởi tạo ma trận tiêm `R` (chỉ được sử dụng khi `init_weights=False`). Các giá trị nhỏ hơn sẽ giữ cho bản cập nhật được tiêm gần với không hơn tại thời điểm khởi tạo. Mặc định là `1.0`.

alpha (`Optional[int]`) : Hệ số tỷ lệ cho thành phần tiêm, được nhân với `alpha / r` (tương tự như alpha của LoRA). Nếu là `None`, sẽ không áp dụng tỷ lệ (hệ số `1.0`). Thành phần loại bỏ không gian con không bị ảnh hưởng.

para (`bool`) : Xác định có sử dụng phương pháp PaRa hay không: loại bỏ không gian con thuần túy (`delta = -P_proj @ W`) mà không có số hạng tiêm. Khi `True`, `R` không được tạo ra, `P` là ma trận có thể huấn luyện duy nhất, và adapter không thể là ma trận đồng nhất tại thời điểm khởi tạo. Mặc định là `False` (DEFT đầy đủ).

fan_in_fan_out (`bool`) : Đặt giá trị này thành `True` nếu lớp cần thay thế lưu trọng số theo dạng (fan_in, fan_out). Ví dụ, gpt-2 sử dụng `Conv1D`, lưu trọng số theo dạng (fan_in, fan_out), do đó cần đặt giá trị này thành `True`.

deft_dropout (`float`) : Xác suất dropout được áp dụng cho đầu vào của lớp. Mặc định là `0.0`.

init_weights (`bool`) : Có sử dụng khởi tạo mặc định (đồng nhất) của DEFT cho trọng số adapter hay không, để adapter không có tác dụng (no-op) tại thời điểm bắt đầu huấn luyện. Không thay đổi cài đặt này, trừ khi bạn biết chính xác mình đang làm gì. Mặc định là `True`.

layers_to_transform (`Union[List[int], int]`) : Các chỉ số lớp cần biến đổi. Nếu truyền vào một danh sách các số nguyên, adapter sẽ được áp dụng cho các chỉ số lớp được chỉ định trong danh sách này. Nếu truyền vào một số nguyên duy nhất, các phép biến đổi sẽ được áp dụng cho lớp tại chỉ số này.

layers_pattern (`Optional[Union[List[str], str]]`) : Tên mẫu lớp, chỉ được sử dụng nếu `layers_to_transform` khác `None`. Giá trị này phải nhắm đến `nn.ModuleList` của mô hình, thường được gọi là `'layers'` hoặc `'h'`.

bias (`str`) : Kiểu bias cho DEFT. Có thể là `'none'`, `'all'` hoặc `'deft_only'`.

modules_to_save (`List[str]`) : Danh sách các module, ngoại trừ các lớp adapter, cần được đặt là có thể huấn luyện và được lưu trong checkpoint cuối cùng.

Đây là lớp cấu hình để lưu trữ cấu hình của một [DeftModel](/docs/peft/main/vi/package_reference/deft#peft.DeftModel).

DEFT (Decompositional Efficient Fine-Tuning) thực hiện tiêm kiến thức thông qua một bản cập nhật dạng residual-projection. Đối với trọng lượng cơ sở đóng băng `W`, một hướng chiếu hạng thấp `P` (hình dạng `out_features x r`) và một ma trận tiêm `R` (hình dạng `r x in_features`) được học. Trọng lượng đã thích ứng là `W' = (I - P_proj) @ W + Q_P @ R`, trong đó bộ chiếu `P_proj` được suy ra từ `P` theo `decomposition_method`:

- `"relu"` (mặc định): `Q_P = P`, `P_proj = P @ relu(P).T` (chiếu không trực giao)
- `"qr"`: `Q_P = qr(P)`, `P_proj = Q_P @ Q_P.T` (chiếu trực giao)

Mặc định (`init_weights=True`), `R` được khởi tạo sao cho phép cập nhật là một phép đồng nhất chính xác tại thời điểm khởi tạo (trọng số thích ứng bằng `W`), do đó quá trình huấn luyện bắt đầu từ các trọng số được huấn luyện trước và học cách tiêm.

## DeftModel[[peft.DeftModel]]

#### peft.DeftModel[[peft.DeftModel]]

```python
peft.DeftModel(model, peft_config: Union[PeftConfig, dict[str, PeftConfig]], adapter_name: str, low_cpu_mem_usage: bool = False, state_dict: Optional[dict[str, torch.Tensor]] = None)
```

[Nguồn](https://github.com/huggingface/peft/blob/main/src/peft/tuners/deft/model.py#L27)

**Tham số:**

model (`torch.nn.Module`) : Mô hình mà các lớp adapter tuner sẽ được gắn vào.

config ([DeftConfig](/docs/peft/main/vi/package_reference/deft#peft.DeftConfig)) : Cấu hình của mô hình DEFT.

adapter_name (`str`) : Tên của adapter, mặc định là `"default"`.

low_cpu_mem_usage (`bool`, `optional`, mặc định là `False`) : Tạo trọng số adapter rỗng trên thiết bị meta. Hữu ích để tăng tốc quá trình tải.

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

Mô hình DEFT.

Tạo một mô hình DEFT (Decompositional Efficient Fine-Tuning) từ một mô hình được huấn luyện trước.

DEFT đóng băng các trọng số cơ sở và học, cho mỗi module đích, một hướng chiếu hạng thấp `P` và một ma trận tiêm `R`. Trọng số hiệu dụng trở thành `(I - P_proj) @ W + Q_P @ R`, thay thế một không gian con của `W` bằng nội dung mới được tiêm (xem [DeftConfig](/docs/peft/main/vi/package_reference/deft#peft.DeftConfig) cho các biến thể `decomposition_method` khả dụng).

**Thuộc tính**:
- **model** (`~torch.nn.Module`) -- Mô hình cần được thích ứng.
- **peft_config** ([DeftConfig](/docs/peft/main/vi/package_reference/deft#peft.DeftConfig)): Cấu hình của mô hình DEFT.