Buckets:
| # ControlNetUnionModel | |
| ControlNetUnionModel là một triển khai của ControlNet cho Stable Diffusion XL. | |
| Mô hình ControlNet được giới thiệu trong [ControlNetPlus](https://github.com/xinsir6/ControlNetPlus) bởi xinsir6. Nó hỗ trợ nhiều đầu vào điều kiện mà không làm tăng lượng tính toán. | |
| *Chúng tôi thiết kế một kiến trúc mới có thể hỗ trợ hơn 10 loại điều khiển trong tạo ảnh từ văn bản có điều kiện và có thể tạo ra các hình ảnh độ phân giải cao tương đương về mặt thị giác với midjourney. Mạng dựa trên kiến trúc ControlNet gốc, chúng tôi đề xuất hai module mới để: 1 Mở rộng ControlNet gốc để hỗ trợ các điều kiện ảnh khác nhau bằng cùng một tham số mạng. 2 Hỗ trợ đầu vào nhiều điều kiện mà không làm tăng chi phí tính toán, điều này đặc biệt quan trọng đối với các nhà thiết kế muốn chỉnh sửa ảnh chi tiết, các điều kiện khác nhau sử dụng cùng một bộ mã hóa điều kiện, không thêm tính toán hoặc tham số bổ sung.* | |
| ## Đang tải | |
| Mặc định, [ControlNetUnionModel](/docs/diffusers/main/vi/api/models/controlnet_union#diffusers.ControlNetUnionModel) nên được tải bằng [from_pretrained()](/docs/diffusers/main/vi/api/models/overview#diffusers.ModelMixin.from_pretrained). | |
| ```py | |
| from diffusers import StableDiffusionXLControlNetUnionPipeline, ControlNetUnionModel | |
| controlnet = ControlNetUnionModel.from_pretrained("xinsir/controlnet-union-sdxl-1.0") | |
| pipe = StableDiffusionXLControlNetUnionPipeline.from_pretrained("stabilityai/stable-diffusion-xl-base-1.0", controlnet=controlnet) | |
| ``` | |
| ## ControlNetUnionModel[[diffusers.ControlNetUnionModel]] | |
| #### diffusers.ControlNetUnionModel[[diffusers.ControlNetUnionModel]] | |
| ```python | |
| diffusers.ControlNetUnionModel(in_channels: int = 4, conditioning_channels: int = 3, flip_sin_to_cos: bool = True, freq_shift: int = 0, down_block_types: tuple[str, ...] = ('CrossAttnDownBlock2D', 'CrossAttnDownBlock2D', 'CrossAttnDownBlock2D', 'DownBlock2D'), only_cross_attention: bool | tuple[bool] = False, block_out_channels: tuple[int, ...] = (320, 640, 1280, 1280), layers_per_block: int = 2, downsample_padding: int = 1, mid_block_scale_factor: float = 1, act_fn: str = 'silu', norm_num_groups: int | None = 32, norm_eps: float = 1e-05, cross_attention_dim: int = 1280, transformer_layers_per_block: int | tuple[int, ...] = 1, encoder_hid_dim: int | None = None, encoder_hid_dim_type: str | None = None, attention_head_dim: int | tuple[int, ...] = 8, num_attention_heads: int | tuple[int, ...] | None = None, use_linear_projection: bool = False, class_embed_type: str | None = None, addition_embed_type: str | None = None, addition_time_embed_dim: int | None = None, num_class_embeds: int | None = None, upcast_attention: bool = False, resnet_time_scale_shift: str = 'default', projection_class_embeddings_input_dim: int | None = None, controlnet_conditioning_channel_order: str = 'rgb', conditioning_embedding_out_channels: tuple[int, ...] | None = (48, 96, 192, 384), global_pool_conditions: bool = False, addition_embed_type_num_heads: int = 64, num_control_type: int = 6, num_trans_channel: int = 320, num_trans_head: int = 8, num_trans_layer: int = 1, num_proj_channel: int = 320) | |
| ``` | |
| [Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/controlnets/controlnet_union.py#L85) | |
| **Tham số:** | |
| in_channels (`int`, mặc định là 4) : Số kênh trong mẫu đầu vào. | |
| flip_sin_to_cos (`bool`, mặc định là `True`) : Có nên đảo sin thành cos trong nhúng thời gian hay không. | |
| freq_shift (`int`, mặc định là 0) : Độ dịch tần số cần áp dụng cho nhúng thời gian. | |
| down_block_types (`tuple[str]`, mặc định là `("CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "DownBlock2D")`) : Bộ tuple các khối downsample cần sử dụng. | |
| only_cross_attention (`bool | tuple[bool]`, mặc định là `False`) -- | |
| block_out_channels (`tuple[int]`, mặc định là `(320, 640, 1280, 1280)`) : Bộ tuple các kênh đầu ra cho mỗi khối. | |
| layers_per_block (`int`, mặc định là 2) : Số lượng lớp trong mỗi khối. | |
| downsample_padding (`int`, mặc định là 1) : Padding được sử dụng cho phép tích chập hạ mẫu. | |
| mid_block_scale_factor (`float`, mặc định là 1) : Hệ số tỷ lệ cần sử dụng cho khối giữa. | |
| act_fn (`str`, mặc định là "silu") : Hàm kích hoạt cần sử dụng. | |
| norm_num_groups (`int`, *optional*, mặc định là 32) : Số nhóm được sử dụng cho phép chuẩn hóa. Nếu là None, các lớp chuẩn hóa và kích hoạt sẽ bị bỏ qua trong xử lý hậu kỳ. | |
| norm_eps (`float`, mặc định là 1e-5) : Epsilon được sử dụng cho phép chuẩn hóa. | |
| cross_attention_dim (`int`, mặc định là 1280) : Kích thước của các đặc trưng chú ý chéo (cross attention). | |
| transformer_layers_per_block (`int` hoặc `tuple[int]`, *tuỳ chọn*, mặc định là 1) : Số lượng khối transformer có kiểu `BasicTransformerBlock`. Chỉ liên quan đến `~models.unet_2d_blocks.CrossAttnDownBlock2D`, `~models.unet_2d_blocks.CrossAttnUpBlock2D`, `~models.unet_2d_blocks.UNetMidBlock2DCrossAttn`. | |
| encoder_hid_dim (`int`, *tuỳ chọn*, mặc định là None) : Nếu `encoder_hid_dim_type` được định nghĩa, `encoder_hidden_states` sẽ được chiếu từ chiều `encoder_hid_dim` sang `cross_attention_dim`. | |
| encoder_hid_dim_type (`str`, *tùy chọn*, mặc định là `None`) : Nếu được cung cấp, `encoder_hidden_states` và các embedding khác (nếu có) sẽ được down-project xuống các embedding văn bản có chiều `cross_attention` theo `encoder_hid_dim_type`. | |
| attention_head_dim (`int | tuple[int]`, mặc định là 8) : Kích thước của các đầu chú ý (attention heads). | |
| use_linear_projection (`bool`, mặc định là `False`) -- | |
| class_embed_type (`str`, *tùy chọn*, mặc định là `None`) : Loại class embedding được sử dụng, cuối cùng sẽ được cộng với các time embeddings. Chọn từ None, `"timestep"`, `"identity"`, `"projection"` hoặc `"simple_projection"`. | |
| addition_embed_type (`str`, *tùy chọn*, mặc định là `None`) : Cấu hình một embedding tùy chọn sẽ được cộng với các time embeddings. Chọn từ `None` hoặc "text". "text" sẽ sử dụng lớp `TextTimeEmbedding`. | |
| num_class_embeds (`int`, *optional*, mặc định là 0) : Kích thước đầu vào của ma trận nhúng có thể học được để chiếu sang `time_embed_dim`, khi thực hiện điều kiện hóa theo lớp với `class_embed_type` bằng `None`. | |
| upcast_attention (`bool`, mặc định là `False`) -- | |
| resnet_time_scale_shift (`str`, mặc định là `"default"`) : Cấu hình dịch chuyển thang thời gian cho các khối ResNet (xem `ResnetBlock2D`). Chọn từ `default` hoặc `scale_shift`. | |
| projection_class_embeddings_input_dim (`int`, *tuỳ chọn*, mặc định là `None`) : Kích thước của đầu vào `class_labels` khi `class_embed_type="projection"`. Bắt buộc khi `class_embed_type="projection"`. | |
| controlnet_conditioning_channel_order (`str`, mặc định là `"rgb"`) : Thứ tự kênh của ảnh điều kiện. Sẽ chuyển sang `rgb` nếu là `bgr`. | |
| conditioning_embedding_out_channels (`tuple[int]`, *optional*, mặc định là `(48, 96, 192, 384)`) : Bộ tuple số kênh đầu ra cho mỗi khối trong lớp `conditioning_embedding`. | |
| global_pool_conditions (`bool`, mặc định là `False`) -- | |
| Một mô hình ControlNetUnion. | |
| #### forward[[diffusers.ControlNetUnionModel.forward]] | |
| ```python | |
| forward(sample: Tensor, timestep: typing.Union[torch.Tensor, float, int], encoder_hidden_states: Tensor, controlnet_cond: list[torch.Tensor], control_type: Tensor, control_type_idx: list[int], conditioning_scale: float | list[float] = 1.0, class_labels: typing.Optional[torch.Tensor] = None, timestep_cond: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, added_cond_kwargs: dict[str, torch.Tensor] | None = None, cross_attention_kwargs: dict[str, typing.Any] | None = None, from_multi: bool = False, guess_mode: bool = False, return_dict: bool = True) | |
| ``` | |
| [Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/controlnets/controlnet_union.py#L541) | |
| **Tham số:** | |
| sample (`torch.Tensor`) : Tensor đầu vào có nhiễu. | |
| timestep (`torch.Tensor | float | int`) : Số bước thời gian để khử nhiễu một đầu vào. | |
| encoder_hidden_states (`torch.Tensor`) : Trạng thái ẩn của bộ mã hóa. | |
| controlnet_cond (`list[torch.Tensor]`) : Các tensor đầu vào có điều kiện. | |
| control_type (`torch.Tensor`) : Một tensor có hình dạng `(batch, num_control_type)` với các giá trị `0` hoặc `1` tùy thuộc vào việc loại điều khiển có được sử dụng hay không. | |
| control_type_idx (`list[int]`) : Các chỉ số của `control_type`. | |
| conditioning_scale (`float`, mặc định là `1.0`) : Hệ số tỷ lệ cho đầu ra của ControlNet. | |
| class_labels (`torch.Tensor`, *tùy chọn*, mặc định là `None`) : Nhãn lớp tùy chọn để điều kiện. Các embedding của chúng sẽ được cộng với các embedding của bước thời gian. | |
| timestep_cond (`torch.Tensor`, *tùy chọn*, mặc định là `None`) : Các embedding điều kiện bổ sung cho timestep. Nếu được cung cấp, các embedding này sẽ được cộng với timestep_embedding được truyền qua lớp `self.time_embedding` để thu được các embedding timestep cuối cùng. | |
| attention_mask (`torch.Tensor`, *tùy chọn*, mặc định là `None`) : Một attention mask có shape `(batch, key_tokens)` được áp dụng cho `encoder_hidden_states`. Nếu là `1`, mask được giữ lại; ngược lại, nếu là `0`, nó sẽ bị loại bỏ. Mask sẽ được chuyển đổi thành một bias, thêm các giá trị âm lớn vào các điểm attention tương ứng với các token "loại bỏ". | |
| added_cond_kwargs (`dict`) : Các điều kiện bổ sung cho UNet của Stable Diffusion XL. | |
| cross_attention_kwargs (`dict[str]`, *tùy chọn*, mặc định là `None`) : Một từ điển kwargs mà nếu được chỉ định sẽ được truyền đến `AttnProcessor`. | |
| from_multi (`bool`, mặc định là `False`) : Sử dụng chuẩn hóa tiêu chuẩn khi được gọi từ `MultiControlNetUnionModel`. | |
| guess_mode (`bool`, mặc định là `False`) : Ở chế độ này, bộ mã hóa ControlNet sẽ cố gắng hết sức để nhận diện nội dung đầu vào của input ngay cả khi bạn xóa tất cả các prompt. Khuyến nghị sử dụng `guidance_scale` trong khoảng từ 3.0 đến 5.0. | |
| return_dict (`bool`, mặc định là `True`) : Có nên trả về một `~models.controlnet.ControlNetOutput` thay vì một tuple thông thường hay không. | |
| **Trả về:** `~models.controlnet.ControlNetOutput` **hoặc** `tuple` | |
| Nếu `return_dict` là `True`, một `~models.controlnet.ControlNetOutput` sẽ được trả về, ngược lại một tuple sẽ được trả về trong đó phần tử đầu tiên là tensor mẫu. | |
| Phương thức forward của [ControlNetUnionModel](/docs/diffusers/main/vi/api/models/controlnet_union#diffusers.ControlNetUnionModel). | |
| #### from_unet[[diffusers.ControlNetUnionModel.from_unet]] | |
| ```python | |
| from_unet(unet: UNet2DConditionModel, controlnet_conditioning_channel_order: str = 'rgb', conditioning_embedding_out_channels: tuple[int, ...] | None = (16, 32, 96, 256), load_weights_from_unet: bool = True) | |
| ``` | |
| [Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/controlnets/controlnet_union.py#L389) | |
| **Tham số:** | |
| unet (`UNet2DConditionModel`) : Trọng số của mô hình UNet để sao chép sang [ControlNetUnionModel](/docs/diffusers/main/vi/api/models/controlnet_union#diffusers.ControlNetUnionModel). Tất cả các tùy chọn cấu hình cũng được sao chép khi phù hợp. | |
| Tạo một [ControlNetUnionModel](/docs/diffusers/main/vi/api/models/controlnet_union#diffusers.ControlNetUnionModel) từ [UNet2DConditionModel](/docs/diffusers/main/vi/api/models/unet2d-cond#diffusers.UNet2DConditionModel). | |
| #### set_attention_slice[[diffusers.ControlNetUnionModel.set_attention_slice]] | |
| ```python | |
| set_attention_slice(slice_size: str | int | list[int]) | |
| ``` | |
| [Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/controlnets/controlnet_union.py#L476) | |
| **Tham số:** | |
| slice_size (`str` hoặc `int` hoặc `list(int)`, *tuỳ chọn*, mặc định là `"auto"`) : Khi `"auto"`, đầu vào cho các đầu chú ý sẽ được chia đôi, do đó chú ý được tính toán trong hai bước. Nếu `"max"`, lượng bộ nhớ tối đa được tiết kiệm bằng cách chỉ chạy một lát một lần. Nếu cung cấp một số, sẽ sử dụng nhiều lát bằng `attention_head_dim // slice_size`. Trong trường hợp này, `attention_head_dim` phải là bội số của `slice_size`. | |
| Bật tính toán chú ý dạng lát cắt. | |
| Khi tùy chọn này được bật, module attention sẽ chia tensor đầu vào thành các lát để tính toán attention qua nhiều bước. Điều này hữu ích để tiết kiệm một phần bộ nhớ, đổi lại là sự giảm tốc độ nhỏ. | |
| #### set_default_attn_processor[[diffusers.ControlNetUnionModel.set_default_attn_processor]] | |
| ```python | |
| set_default_attn_processor() | |
| ``` | |
| [Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/controlnets/controlnet_union.py#L460) | |
| Tắt các bộ xử lý chú ý tùy chỉnh và đặt cài đặt chú ý mặc định. | |
Xet Storage Details
- Size:
- 14.1 kB
- Xet hash:
- 96d6645eb5b599f575f0796a59f07df37c0d96fcef56d2309de2490adbd6f23f
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.