Buckets:

hf-doc-build
/

doc

Files
xet
hf-doc-build/doc / diffusers /v0.43.0 /vi /api /pipelines /diffusion_gemma.md
mishig
2 days ago
preview code
download
raw
20.4 kB
# DiffusionGemma

DiffusionGemma là một mô hình ngôn ngữ encoder-decoder dạng block-diffusion. Một encoder causal đọc prompt sạch (cùng với các block đã được tạo trước đó) vào KV cache, và một decoder hai chiều khử nhiễu một "canvas" có kích thước cố định gồm `canvas_length` token bằng cách cross-attend đến cache đó. Quá trình tạo ra xen kẽ một vòng lặp tự hồi quy bên ngoài trên các canvas với một vòng lặp khử nhiễu bên trong, trong đó mỗi bước lấy mẫu các token ứng viên, cam kết những token tự tin nhất thông qua [BlockRefinementScheduler](/docs/diffusers/v0.43.0/vi/api/schedulers/block_refinement#diffusers.BlockRefinementScheduler) ở chế độ hư hỏng đồng đều, và thêm nhiễu lại cho phần còn lại. Bản thân mô hình nằm trong `transformers` dưới dạng `DiffusionGemmaForBlockDiffusion`; checkpoint được phát hành là [`google/diffusiongemma-26B-A4B-it`](https://huggingface.co/google/diffusiongemma-26B-A4B-it).

## Cách sử dụng

```py
import torch
from transformers import AutoProcessor, DiffusionGemmaForBlockDiffusion
from diffusers import BlockRefinementScheduler, DiffusionGemmaPipeline
model_id = "google/diffusiongemma-26B-A4B-it"
model = DiffusionGemmaForBlockDiffusion.from_pretrained(model_id, dtype=torch.bfloat16, device_map="auto")
processor = AutoProcessor.from_pretrained(model_id)
scheduler = BlockRefinementScheduler()
pipe = DiffusionGemmaPipeline(model=model, scheduler=scheduler, processor=processor)
pipe.model.model.decoder = torch.compile(pipe.model.model.decoder, mode="reduce-overhead", fullgraph=True)
output = pipe(
    prompt="Why is the sky blue?",
    gen_length=256,
    num_inference_steps=48,
    cache_implementation="static",
)
print(output.texts[0])
```

`num_inference_steps` là số bước khử nhiễu trên mỗi canvas (48 khớp với checkpoint đã phát hành); ít bước hơn sẽ nhanh hơn nhưng chất lượng thấp hơn. `cache_implementation="static"` cho phép bộ giải mã được `torch.compile`-d với cudagraphs (xem [Static cache and compilation](#static-cache-and-compilation)); bỏ cả hai để chạy với dynamic-cache đơn giản hơn.

Với đầu vào đa lượt hoặc đa phương thức, hãy truyền hội thoại `messages` thô thay vì `prompt`. Đây là một danh sách các dict `{"role", "content"}` theo định dạng chat thông thường, được bộ xử lý chạy qua mẫu chat của nó:

```py
messages = [
    {"role": "user", "content": "Why is the sky blue?"},
]
# or with an image:
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "image": image},
            {"type": "text", "text": "Describe this image."},
        ],
    },
]
output = pipe(messages=messages, gen_length=256)
```

Với một lượt của người dùng, bạn có thể bỏ qua `messages` và truyền `image` cùng với `prompt`; bộ xử lý sẽ tự động chuyển đổi nó thành các đầu vào hình ảnh của mô hình.

## Trình lập lịch

Trình lập lịch là trình lấy mẫu khử nhiễu cho mỗi canvas và có thể thay thế được: thay đổi nó để đổi chiến lược lấy mẫu mà không cần đụng chạm đến bất kỳ phần nào khác. Có ba trình lập lịch khả dụng:

- [BlockRefinementScheduler](/docs/diffusers/v0.43.0/vi/api/schedulers/block_refinement#diffusers.BlockRefinementScheduler) (mặc định): cam kết các token tự tin nhất ở mỗi bước (trên `threshold`, cộng thêm một hạn mức đều mỗi bước) và thêm nhiễu lại phần còn lại. `editing_threshold` cho phép nó chỉnh sửa lại các token đã cam kết.
- [DiscreteDDIMScheduler](/docs/diffusers/v0.43.0/vi/api/schedulers/discrete_ddim#diffusers.DiscreteDDIMScheduler): lấy mẫu từng vị trí từ hậu nghiệm rời rạc chính xác của quá trình làm nhiễu đều (D3PM). Nó không có tham số, và bước cuối cùng cam kết một cách tất định các token được dự đoán.
- [EntropyBoundScheduler](/docs/diffusers/v0.43.0/vi/api/schedulers/entropy_bound#diffusers.EntropyBoundScheduler): cam kết các vị trí có entropy thấp nhất mà entropy liên hợp của chúng vẫn nằm dưới `entropy_bound`, nhờ đó các token gần như độc lập được chấp nhận cùng nhau. Nó làm nguội nhiệt độ lấy mẫu từ `t_max` (`0.8`) ở bước đầu tiên xuống `t_min` (`0.4`) ở bước cuối, khớp với trình lấy mẫu của checkpoint đã phát hành.

```py
from diffusers import DiscreteDDIMScheduler, EntropyBoundScheduler
pipe.scheduler = DiscreteDDIMScheduler()
# or: pipe.scheduler = EntropyBoundScheduler(entropy_bound=0.1)
output = pipe(prompt="Why is the sky blue?", gen_length=256, num_inference_steps=48)
print(output.texts[0])
```

Các tùy chọn lấy mẫu cụ thể cho trình lập lịch (ngưỡng `threshold`/`top_k` của khối tinh chỉnh, ràng buộc entropy, ...) được đặt trong cấu hình trình lập lịch:

```py
from diffusers import BlockRefinementScheduler
pipe.scheduler = BlockRefinementScheduler.from_config(pipe.scheduler.config, threshold=0.9)
```

`EntropyBoundScheduler` giảm dần nhiệt độ lấy mẫu (`t_max`/`t_min`) bên trong qua các bước khử nhiễu; `DiscreteDDIMScheduler` và `BlockRefinementScheduler` sử dụng `temperature` phẳng được truyền vào pipeline (`0.0` cho greedy).

### Mẫu hóa dự đoán-chỉnh sửa

`DiscreteDDIMScheduler` hỗ trợ bộ dự đoán-chỉnh sửa leave-one-out của [Uniform Diffusion Models Revisited: Leave-One-Out Denoiser and Absorbing State Reformulation](https://huggingface.co/papers/2605.22765). Nó tinh chỉnh canvas bằng `corrector_steps` lượt quét Gibbs, trong đó lấy lại mẫu các vị trí kém tự tin nhất từ điều kiện một tọa độ của phân phối biên nhiễu, điều này giữ nguyên phân phối biên đó và cải thiện chất lượng sinh mà không phát sinh chi phí huấn luyện thêm. Nó hoạt động trực tiếp trên checkpoint đã phát hành: đối với uniform diffusion, bộ khử nhiễu và hậu nghiệm leave-one-out có thể thay thế cho nhau theo dạng đóng, do đó bộ chỉnh sửa khôi phục được các đại lượng leave-one-out cần thiết mà không cần huấn luyện lại.

Các bước corrector được gộp vào ngân sách `num_inference_steps` thay vì cộng thêm: pipeline thực hiện ít bước predictor hơn và dùng các lần forward được giải phóng cho corrector, do đó tổng số lần forward của model vẫn là `num_inference_steps` và chi phí predictor-corrector bằng với chi phí của phương pháp lấy mẫu tổ tiên thông thường.

```py
from diffusers import DiscreteDDIMScheduler
pipe.scheduler = DiscreteDDIMScheduler(corrector_steps=2, corrector_k=12)
output = pipe(prompt="Why is the sky blue?", gen_length=256, num_inference_steps=48)
print(output.texts[0])
```

## Bộ thích ứng PEFT

Denoiser là một mô hình 🤗 Transformers, do đó các adapter được nạp thông qua tích hợp [PEFT](https://huggingface.co/docs/peft) bản địa của nó thay vì API `load_lora_weights` của diffusers. Vì tích hợp này không phụ thuộc vào loại adapter, các lệnh gọi giống nhau sẽ nạp LoRA, DoRA hoặc bất kỳ adapter PEFT nào khác (ví dụ: kết quả đầu ra của `SFTTrainer` của TRL). Hãy quản lý các adapter trực tiếp trên thành phần mô hình:

```py
pipe.model.load_adapter("path/to/adapter", adapter_name="sft")  # LoRA, DoRA, ...
pipe.model.set_adapter("sft")
output = pipe(prompt="Why is the sky blue?", gen_length=256)
pipe.model.disable_adapters()  # run the base model
pipe.model.delete_adapter("sft")
```

Adapters vẫn ở trạng thái hoạt động và chưa được hợp nhất: DiffusionGemma liên kết trọng lượng cơ bản của encoder và decoder, do đó việc hợp nhất adapter vào chúng sẽ làm hỏng cả hai nhánh.

## Bộ nhớ đệm tĩnh và biên dịch

Pipeline nạp trước encoder một lần cho mỗi khối vào một bộ nhớ đệm có thể tái sử dụng (mặc định là `DynamicCache`). Truyền `cache_implementation="static"` sẽ sử dụng `StaticCache` có hình dạng cố định thay thế, trong đó các hình dạng cho phép bạn `torch.compile` bộ giải mã với cudagraphs để tăng tốc độ hơn nữa (pipeline đánh dấu từng bước và nhân bản logits để bộ nhớ cudagraph không bị ghi đè); đây là cấu hình được hiển thị trong [Sử dụng](#usage). Bỏ cả lệnh gọi `torch.compile` và `cache_implementation="static"` để chạy với bộ nhớ đệm động đơn giản hơn.

## Dừng thích ứng

Một khối thường hội tụ trước khi dùng hết `num_inference_steps`, vì vậy mặc định pipeline sẽ đóng băng mỗi ví dụ trong batch một khi dự đoán argmax của nó ổn định trong `stability_threshold` bước và entropy trung bình trên mỗi token của nó giảm xuống dưới `confidence_threshold` (`0.005`, giá trị được sử dụng bởi checkpoint đã phát hành). Vòng lặp khử nhiễu kết thúc khi mọi ví dụ đều được đóng băng. Điều này giảm khoảng một nửa số lần chạy decoder ở chất lượng tương đương và là đòn bẩy thông lượng lớn nhất. Truyền `confidence_threshold=None` để luôn chạy đầy đủ `num_inference_steps`:

```py
output = pipe(prompt="Why is the sky blue?", gen_length=256, confidence_threshold=None)  # disable adaptive stopping
```

## Callbacks

Callbacks được thực thi sau mỗi bước khử nhiễu. Truyền `callback_on_step_end_tensor_inputs` để chọn các tensor nào được bao gồm trong `callback_kwargs`; `canvas` (các token khối hiện tại) và `logits` có sẵn. Trả về `{"canvas": ...}` từ callback để thay thế canvas.

```py
def on_step_end(pipe, step, timestep, callback_kwargs):
    canvas = callback_kwargs["canvas"]
    # Inspect or modify `canvas` here.
    return {"canvas": canvas}
out = pipe(
    prompt="Why is the sky blue?",
    callback_on_step_end=on_step_end,
    callback_on_step_end_tensor_inputs=["canvas"],
)
```

## DiffusionGemmaPipeline[[diffusers.DiffusionGemmaPipeline]]

#### diffusers.DiffusionGemmaPipeline[[diffusers.DiffusionGemmaPipeline]]

```python
diffusers.DiffusionGemmaPipeline(model: Any, scheduler: BlockRefinementScheduler | DiscreteDDIMScheduler | EntropyBoundScheduler, processor: Any)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/diffusion_gemma/pipeline_diffusion_gemma.py#L53)

**Tham số:**

model ([DiffusionGemmaForBlockDiffusion](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/diffusion_gemma#transformers.DiffusionGemmaForBlockDiffusion)) : Bộ khử nhiễu block-diffusion (encoder nhân quả + decoder hai chiều với trọng số liên kết).

scheduler ([BlockRefinementScheduler](/docs/diffusers/v0.43.0/vi/api/schedulers/block_refinement#diffusers.BlockRefinementScheduler), [DiscreteDDIMScheduler](/docs/diffusers/v0.43.0/vi/api/schedulers/discrete_ddim#diffusers.DiscreteDDIMScheduler) hoặc [EntropyBoundScheduler](/docs/diffusers/v0.43.0/vi/api/schedulers/entropy_bound#diffusers.EntropyBoundScheduler)) : Bộ lấy mẫu (sampler) thực hiện cam kết (commit) và thêm nhiễu lại (renoise) các token canvas ở mỗi bước khử nhiễu (denoising step).

processor ([ProcessorMixin](https://huggingface.co/docs/transformers/v5.22.2/en/main_classes/processors#transformers.ProcessorMixin)) : Bộ xử lý được sử dụng để áp dụng mẫu trò chuyện và giải mã các token đã tạo.

Pipeline cho việc tạo văn bản block-diffusion của DiffusionGemma.

DiffusionGemma là một mô hình encoder-decoder dạng block-diffusion: một encoder nhân quả đọc prompt sạch (và các block đã được tạo trước đó) vào bộ nhớ đệm KV, và một decoder hai chiều khử nhiễu một "bảng vẽ" có kích thước cố định gồm `canvas_length` token bằng cách chú ý chéo (cross-attention) đến bộ nhớ đệm đó. Quá trình tạo ra xen kẽ một vòng lặp tự hồi quy bên ngoài trên các bảng vẽ với một vòng lặp khử nhiễu bên trong, trong đó mỗi bước lấy mẫu các token ứng viên, cam kết những token tự tin nhất thông qua [BlockRefinementScheduler](/docs/diffusers/v0.43.0/vi/api/schedulers/block_refinement#diffusers.BlockRefinementScheduler) (chế độ phá hủy đồng nhất, `mask_token_id=None`), và thêm nhiễu lại cho phần còn lại.

Mô hình được kỳ vọng là một instance của `DiffusionGemmaForBlockDiffusion`, phơi bày `forward(input_ids, decoder_input_ids=..., self_conditioning_logits=..., ...)` và trả về logits có shape `[batch, canvas_length, vocab_size]` trên canvas. Xem model card tại https://huggingface.co/google/diffusiongemma-26B-A4B-it.

#### __call__[[diffusers.DiffusionGemmaPipeline.__call__]]

```python
__call__(prompt: str | list[str] | None = None, messages: list[dict] | None = None, image: Any | list[Any] | None = None, add_generation_prompt: bool = True, gen_length: int = 256, num_inference_steps: int = 48, temperature: float = 0.0, cache_implementation: str | None = None, eos_early_stop: bool = True, eos_token_id: int | None = None, stability_threshold: int = 1, confidence_threshold: float | None = 0.005, generator: torch.Generator | None = None, output_type: str = 'text', return_dict: bool = True, callback_on_step_end: Callable[[Any, int, int, dict], dict] | PipelineCallback | MultiPipelineCallbacks | None = None, callback_on_step_end_tensor_inputs: list[str] | None = None)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/diffusion_gemma/pipeline_diffusion_gemma.py#L163)

**Tham số:**

prompt (`str` hoặc `List[str]`, *tùy chọn*) : Văn bản prompt, được bọc trong một chat template và được token hóa bởi processor. Cung cấp một trong hai: trường này hoặc `messages`.

messages (`List[Dict]`, *tùy chọn*) : Một cuộc trò chuyện chat thô để mã hóa, ví dụ `[{"role": "user", "content": "Hello"}]` hoặc một cuộc trò chuyện đa lượt / đa phương thức. Hãy dùng tham số này thay vì `prompt` cho bất kỳ trường hợp nào vượt quá một lượt người dùng duy nhất.

image (`PIL.Image.Image` hoặc `List`, *tùy chọn*) : Ảnh để ghép với `prompt` cho việc tạo đa phương thức; bộ xử lý sẽ chuyển chúng thành đầu vào ảnh của mô hình. Để có bố cục phong phú hơn, hãy đặt nội dung ảnh trực tiếp trong `messages`.

add_generation_prompt (`bool`, mặc định là `True`) : Có thêm prompt sinh khi áp dụng mẫu chat hay không.

gen_length (`int`, mặc định là `256`) : Số lượng token cần tạo, được làm tròn lên thành bội số của `canvas_length` của mô hình.

num_inference_steps (`int`, mặc định là `48`) : Số bước khử nhiễu trên mỗi canvas.

temperature (`float`, mặc định là `0.0`) : Nhiệt độ lấy mẫu cho `DiscreteDDIMScheduler`/`BlockRefinementScheduler` (`0.0` là tham lam); `EntropyBoundScheduler` bỏ qua giá trị này và tự giảm nhiệt độ của riêng nó. Các thông số lấy mẫu khác (ví dụ `top_k`, `threshold`, `t_min`/`t_max`) là cấu hình của scheduler; hãy đặt chúng trên scheduler, ví dụ `pipe.scheduler = BlockRefinementScheduler.from_config(pipe.scheduler.config, top_k=...)`.

cache_implementation (`str`, *tùy chọn*) : Đặt thành `"static"` để nạp trước encoder một lần cho mỗi khối vào `StaticCache` bền vững và chạy decoder đối với nó với các hình dạng cố định, thay vì mã hóa lại toàn bộ chuỗi ở mỗi bước. Các hình dạng cố định cũng cho phép bạn biên dịch decoder, ví dụ `pipe.model.model.decoder = torch.compile(pipe.model.model.decoder, fullgraph=True)`.
eos_early_stop (`bool`, mặc định là `True`) : Có nên dừng việc tạo thêm các canvas khi mọi chuỗi đã phát ra EOS hay không.
eos_token_id (`int`, *optional*) : ID của token EOS để dừng sớm. Nếu không có, sẽ dùng tokenizer của processor.
stability_threshold (`int`, mặc định là `1`) : Số bước liên tiếp mà dự đoán argmax của một ví dụ phải giữ nguyên không đổi để ví dụ đó được tính là ổn định. Chỉ được sử dụng khi `confidence_threshold` được đặt.

confidence_threshold (`float`, *optional*, mặc định là `0.005`) : Đóng băng mỗi ví dụ một khi nó ổn định (xem `stability_threshold`) và entropy trung bình trên mỗi token của logits dự đoán có hình dạng scheduler của nó thấp hơn giá trị này. Vòng lặp khử nhiễu của khối sẽ kết thúc một khi mọi ví dụ đều được đóng băng. Tăng tốc độ sinh ra với chất lượng tương đương; giá trị mặc định khớp với checkpoint đã phát hành. Đặt thành `None` để luôn chạy tất cả `num_inference_steps`.

generator (`torch.Generator`, *tùy chọn*) : RNG để lấy mẫu.

output_type (`str`, mặc định là `"text"`) : `"text"` giải mã các chuỗi thành chuỗi ký tự (yêu cầu một bộ xử lý); `"seq"` chỉ trả về các ID token.
return_dict (`bool`, mặc định là `True`) : Xác định có trả về [DiffusionGemmaPipelineOutput](/docs/diffusers/v0.43.0/vi/api/pipelines/diffusion_gemma#diffusers.DiffusionGemmaPipelineOutput) thay vì một tuple hay không.

callback_on_step_end (`Callable` hoặc `PipelineCallback`, *tùy chọn*) : Callback được thực thi sau mỗi bước khử nhiễu với chữ ký `callback_on_step_end(self, step, timestep, callback_kwargs)`. Các khóa tensor được phép: `canvas`, `logits`.
callback_on_step_end_tensor_inputs (`List[str]`, *tùy chọn*) : Các khóa Tensor để truyền cho callback.

**Trả về:** [DiffusionGemmaPipelineOutput](/docs/diffusers/v0.43.0/vi/api/pipelines/diffusion_gemma#diffusers.DiffusionGemmaPipelineOutput) hoặc `tuple`

Các ID token được tạo ra (`sequences`) và, đối với `output_type="text"`, các `texts` đã được giải mã.

Sinh văn bản bằng khuếch tán khối.

Ví dụ:
```python
>>> import torch
>>> from transformers import AutoProcessor, DiffusionGemmaForBlockDiffusion
>>> from diffusers import BlockRefinementScheduler, DiffusionGemmaPipeline
>>> model_id = "google/diffusiongemma-26B-A4B-it"
>>> model = DiffusionGemmaForBlockDiffusion.from_pretrained(model_id, dtype=torch.bfloat16, device_map="auto")
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> scheduler = BlockRefinementScheduler()
>>> pipe = DiffusionGemmaPipeline(model=model, scheduler=scheduler, processor=processor)
>>> output = pipe(prompt="Why is the sky blue?", gen_length=256)
>>> print(output.texts[0])
```

## DiffusionGemmaPipelineOutput[[diffusers.DiffusionGemmaPipelineOutput]]

#### diffusers.DiffusionGemmaPipelineOutput[[diffusers.DiffusionGemmaPipelineOutput]]

```python
diffusers.DiffusionGemmaPipelineOutput(sequences: torch.LongTensor, texts: list[str] | None = None)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/diffusion_gemma/pipeline_output.py#L25)

**Tham số:**

sequences (`torch.LongTensor` có hình dạng `(batch_size, gen_length)`) : Các ID token được tạo ra (prompt đã được loại bỏ).

texts (`list[str]`, *tùy chọn*) : Văn bản đã giải mã, mỗi chuỗi một chuỗi ký tự. Chỉ được đặt khi `output_type="text"`.

Lớp đầu ra cho việc tạo block-diffusion của DiffusionGemma.
Xet Storage Details

Size:: 20.4 kB
Xet hash:: 39e4cbf6d3882990bd260fb863f3fd50c50ed03d1f21f0a023cf0b44710959a5
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.