From 6e616a9cc847b60ab4afb5f67727bc4db7a5116f Mon Sep 17 00:00:00 2001 From: junsongc Date: Fri, 18 Oct 2024 17:39:16 +0800 Subject: [PATCH 001/141] first add a script for DC-AE; --- .../models/autoencoders/autoencoder_dc.py | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 src/diffusers/models/autoencoders/autoencoder_dc.py diff --git a/src/diffusers/models/autoencoders/autoencoder_dc.py b/src/diffusers/models/autoencoders/autoencoder_dc.py new file mode 100644 index 000000000000..ba838bffb5fd --- /dev/null +++ b/src/diffusers/models/autoencoders/autoencoder_dc.py @@ -0,0 +1,15 @@ +# Copyright 2024 MIT, Tsinghua University, NVIDIA CORPORATION and The HuggingFace Team. +# All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + From 90e893936d24f54f489782880a294c734dd3dbfb Mon Sep 17 00:00:00 2001 From: Junyu Chen Date: Tue, 22 Oct 2024 23:49:59 -0700 Subject: [PATCH 002/141] DC-AE init --- .../models/autoencoders/autoencoder_dc.py | 15 - src/diffusers/models/autoencoders/dc_ae.py | 542 ++++++++++++ .../models/efficientvit_blocks/act.py | 27 + .../models/efficientvit_blocks/norm.py | 53 ++ .../models/efficientvit_blocks/ops.py | 820 ++++++++++++++++++ .../efficientvit_blocks/triton_rms_norm.py | 191 ++++ .../models/efficientvit_blocks/utils/list.py | 51 ++ .../efficientvit_blocks/utils/network.py | 95 ++ 8 files changed, 1779 insertions(+), 15 deletions(-) delete mode 100644 src/diffusers/models/autoencoders/autoencoder_dc.py create mode 100644 src/diffusers/models/autoencoders/dc_ae.py create mode 100644 src/diffusers/models/efficientvit_blocks/act.py create mode 100644 src/diffusers/models/efficientvit_blocks/norm.py create mode 100644 src/diffusers/models/efficientvit_blocks/ops.py create mode 100644 src/diffusers/models/efficientvit_blocks/triton_rms_norm.py create mode 100644 src/diffusers/models/efficientvit_blocks/utils/list.py create mode 100644 src/diffusers/models/efficientvit_blocks/utils/network.py diff --git a/src/diffusers/models/autoencoders/autoencoder_dc.py b/src/diffusers/models/autoencoders/autoencoder_dc.py deleted file mode 100644 index ba838bffb5fd..000000000000 --- a/src/diffusers/models/autoencoders/autoencoder_dc.py +++ /dev/null @@ -1,15 +0,0 @@ -# Copyright 2024 MIT, Tsinghua University, NVIDIA CORPORATION and The HuggingFace Team. -# All rights reserved. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - diff --git a/src/diffusers/models/autoencoders/dc_ae.py b/src/diffusers/models/autoencoders/dc_ae.py new file mode 100644 index 000000000000..616a124f62e4 --- /dev/null +++ b/src/diffusers/models/autoencoders/dc_ae.py @@ -0,0 +1,542 @@ +# Copyright 2024 MIT, Tsinghua University, NVIDIA CORPORATION and The HuggingFace Team. +# All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from dataclasses import dataclass, field +from typing import Any, Optional, Callable + +import torch +import torch.nn as nn +from omegaconf import MISSING, OmegaConf +from huggingface_hub import PyTorchModelHubMixin + +from ..efficientvit_blocks.act import build_act +from ..efficientvit_blocks.norm import build_norm +from ..efficientvit_blocks.ops import ( + ChannelDuplicatingPixelUnshuffleUpSampleLayer, + ConvLayer, + ConvPixelShuffleUpSampleLayer, + ConvPixelUnshuffleDownSampleLayer, + EfficientViTBlock, + IdentityLayer, + InterpolateConvUpSampleLayer, + OpSequential, + PixelUnshuffleChannelAveragingDownSampleLayer, + ResBlock, + ResidualBlock, +) + +__all__ = ["DCAE", "dc_ae_f32c32", "dc_ae_f64c128", "dc_ae_f128c512"] + + +@dataclass +class EncoderConfig: + in_channels: int = MISSING + latent_channels: int = MISSING + width_list: tuple[int, ...] = (128, 256, 512, 512, 1024, 1024) + depth_list: tuple[int, ...] = (2, 2, 2, 2, 2, 2) + block_type: Any = "ResBlock" + norm: str = "trms2d" + act: str = "silu" + downsample_block_type: str = "ConvPixelUnshuffle" + downsample_match_channel: bool = True + downsample_shortcut: Optional[str] = "averaging" + out_norm: Optional[str] = None + out_act: Optional[str] = None + out_shortcut: Optional[str] = "averaging" + double_latent: bool = False + + +@dataclass +class DecoderConfig: + in_channels: int = MISSING + latent_channels: int = MISSING + in_shortcut: Optional[str] = "duplicating" + width_list: tuple[int, ...] = (128, 256, 512, 512, 1024, 1024) + depth_list: tuple[int, ...] = (2, 2, 2, 2, 2, 2) + block_type: Any = "ResBlock" + norm: Any = "trms2d" + act: Any = "silu" + upsample_block_type: str = "ConvPixelShuffle" + upsample_match_channel: bool = True + upsample_shortcut: str = "duplicating" + out_norm: str = "trms2d" + out_act: str = "relu" + + +@dataclass +class DCAEConfig: + in_channels: int = 3 + latent_channels: int = 32 + encoder: EncoderConfig = field( + default_factory=lambda: EncoderConfig(in_channels="${..in_channels}", latent_channels="${..latent_channels}") + ) + decoder: DecoderConfig = field( + default_factory=lambda: DecoderConfig(in_channels="${..in_channels}", latent_channels="${..latent_channels}") + ) + use_quant_conv: bool = False + + pretrained_path: Optional[str] = None + pretrained_source: str = "dc-ae" + + scaling_factor: Optional[float] = None + + +def build_block( + block_type: str, in_channels: int, out_channels: int, norm: Optional[str], act: Optional[str] +) -> nn.Module: + if block_type == "ResBlock": + assert in_channels == out_channels + main_block = ResBlock( + in_channels=in_channels, + out_channels=out_channels, + kernel_size=3, + stride=1, + use_bias=(True, False), + norm=(None, norm), + act_func=(act, None), + ) + block = ResidualBlock(main_block, IdentityLayer()) + elif block_type == "EViT_GLU": + assert in_channels == out_channels + block = EfficientViTBlock(in_channels, norm=norm, act_func=act, local_module="GLUMBConv", scales=()) + elif block_type == "EViTS5_GLU": + assert in_channels == out_channels + block = EfficientViTBlock(in_channels, norm=norm, act_func=act, local_module="GLUMBConv", scales=(5,)) + else: + raise ValueError(f"block_type {block_type} is not supported") + return block + + +def build_stage_main( + width: int, depth: int, block_type: str | list[str], norm: str, act: str, input_width: int +) -> list[nn.Module]: + assert isinstance(block_type, str) or (isinstance(block_type, list) and depth == len(block_type)) + stage = [] + for d in range(depth): + current_block_type = block_type[d] if isinstance(block_type, list) else block_type + block = build_block( + block_type=current_block_type, + in_channels=width if d > 0 else input_width, + out_channels=width, + norm=norm, + act=act, + ) + stage.append(block) + return stage + + +def build_downsample_block(block_type: str, in_channels: int, out_channels: int, shortcut: Optional[str]) -> nn.Module: + if block_type == "Conv": + block = ConvLayer( + in_channels=in_channels, + out_channels=out_channels, + kernel_size=3, + stride=2, + use_bias=True, + norm=None, + act_func=None, + ) + elif block_type == "ConvPixelUnshuffle": + block = ConvPixelUnshuffleDownSampleLayer( + in_channels=in_channels, out_channels=out_channels, kernel_size=3, factor=2 + ) + else: + raise ValueError(f"block_type {block_type} is not supported for downsampling") + if shortcut is None: + pass + elif shortcut == "averaging": + shortcut_block = PixelUnshuffleChannelAveragingDownSampleLayer( + in_channels=in_channels, out_channels=out_channels, factor=2 + ) + block = ResidualBlock(block, shortcut_block) + else: + raise ValueError(f"shortcut {shortcut} is not supported for downsample") + return block + + +def build_upsample_block(block_type: str, in_channels: int, out_channels: int, shortcut: Optional[str]) -> nn.Module: + if block_type == "ConvPixelShuffle": + block = ConvPixelShuffleUpSampleLayer( + in_channels=in_channels, out_channels=out_channels, kernel_size=3, factor=2 + ) + elif block_type == "InterpolateConv": + block = InterpolateConvUpSampleLayer( + in_channels=in_channels, out_channels=out_channels, kernel_size=3, factor=2 + ) + else: + raise ValueError(f"block_type {block_type} is not supported for upsampling") + if shortcut is None: + pass + elif shortcut == "duplicating": + shortcut_block = ChannelDuplicatingPixelUnshuffleUpSampleLayer( + in_channels=in_channels, out_channels=out_channels, factor=2 + ) + block = ResidualBlock(block, shortcut_block) + else: + raise ValueError(f"shortcut {shortcut} is not supported for upsample") + return block + + +def build_encoder_project_in_block(in_channels: int, out_channels: int, factor: int, downsample_block_type: str): + if factor == 1: + block = ConvLayer( + in_channels=in_channels, + out_channels=out_channels, + kernel_size=3, + stride=1, + use_bias=True, + norm=None, + act_func=None, + ) + elif factor == 2: + block = build_downsample_block( + block_type=downsample_block_type, in_channels=in_channels, out_channels=out_channels, shortcut=None + ) + else: + raise ValueError(f"downsample factor {factor} is not supported for encoder project in") + return block + + +def build_encoder_project_out_block( + in_channels: int, out_channels: int, norm: Optional[str], act: Optional[str], shortcut: Optional[str] +): + block = OpSequential( + [ + build_norm(norm), + build_act(act), + ConvLayer( + in_channels=in_channels, + out_channels=out_channels, + kernel_size=3, + stride=1, + use_bias=True, + norm=None, + act_func=None, + ), + ] + ) + if shortcut is None: + pass + elif shortcut == "averaging": + shortcut_block = PixelUnshuffleChannelAveragingDownSampleLayer( + in_channels=in_channels, out_channels=out_channels, factor=1 + ) + block = ResidualBlock(block, shortcut_block) + else: + raise ValueError(f"shortcut {shortcut} is not supported for encoder project out") + return block + + +def build_decoder_project_in_block(in_channels: int, out_channels: int, shortcut: Optional[str]): + block = ConvLayer( + in_channels=in_channels, + out_channels=out_channels, + kernel_size=3, + stride=1, + use_bias=True, + norm=None, + act_func=None, + ) + if shortcut is None: + pass + elif shortcut == "duplicating": + shortcut_block = ChannelDuplicatingPixelUnshuffleUpSampleLayer( + in_channels=in_channels, out_channels=out_channels, factor=1 + ) + block = ResidualBlock(block, shortcut_block) + else: + raise ValueError(f"shortcut {shortcut} is not supported for decoder project in") + return block + + +def build_decoder_project_out_block( + in_channels: int, out_channels: int, factor: int, upsample_block_type: str, norm: Optional[str], act: Optional[str] +): + layers: list[nn.Module] = [ + build_norm(norm, in_channels), + build_act(act), + ] + if factor == 1: + layers.append( + ConvLayer( + in_channels=in_channels, + out_channels=out_channels, + kernel_size=3, + stride=1, + use_bias=True, + norm=None, + act_func=None, + ) + ) + elif factor == 2: + layers.append( + build_upsample_block( + block_type=upsample_block_type, in_channels=in_channels, out_channels=out_channels, shortcut=None + ) + ) + else: + raise ValueError(f"upsample factor {factor} is not supported for decoder project out") + return OpSequential(layers) + + +class Encoder(nn.Module): + def __init__(self, cfg: EncoderConfig): + super().__init__() + self.cfg = cfg + num_stages = len(cfg.width_list) + self.num_stages = num_stages + assert len(cfg.depth_list) == num_stages + assert len(cfg.width_list) == num_stages + assert isinstance(cfg.block_type, str) or ( + isinstance(cfg.block_type, list) and len(cfg.block_type) == num_stages + ) + + self.project_in = build_encoder_project_in_block( + in_channels=cfg.in_channels, + out_channels=cfg.width_list[0] if cfg.depth_list[0] > 0 else cfg.width_list[1], + factor=1 if cfg.depth_list[0] > 0 else 2, + downsample_block_type=cfg.downsample_block_type, + ) + + self.stages: list[OpSequential] = [] + for stage_id, (width, depth) in enumerate(zip(cfg.width_list, cfg.depth_list)): + block_type = cfg.block_type[stage_id] if isinstance(cfg.block_type, list) else cfg.block_type + stage = build_stage_main( + width=width, depth=depth, block_type=block_type, norm=cfg.norm, act=cfg.act, input_width=width + ) + + if stage_id < num_stages - 1 and depth > 0: + downsample_block = build_downsample_block( + block_type=cfg.downsample_block_type, + in_channels=width, + out_channels=cfg.width_list[stage_id + 1] if cfg.downsample_match_channel else width, + shortcut=cfg.downsample_shortcut, + ) + stage.append(downsample_block) + self.stages.append(OpSequential(stage)) + self.stages = nn.ModuleList(self.stages) + + self.project_out = build_encoder_project_out_block( + in_channels=cfg.width_list[-1], + out_channels=2 * cfg.latent_channels if cfg.double_latent else cfg.latent_channels, + norm=cfg.out_norm, + act=cfg.out_act, + shortcut=cfg.out_shortcut, + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = self.project_in(x) + for stage in self.stages: + if len(stage.op_list) == 0: + continue + x = stage(x) + x = self.project_out(x) + return x + + +class Decoder(nn.Module): + def __init__(self, cfg: DecoderConfig): + super().__init__() + self.cfg = cfg + num_stages = len(cfg.width_list) + self.num_stages = num_stages + assert len(cfg.depth_list) == num_stages + assert len(cfg.width_list) == num_stages + assert isinstance(cfg.block_type, str) or ( + isinstance(cfg.block_type, list) and len(cfg.block_type) == num_stages + ) + assert isinstance(cfg.norm, str) or (isinstance(cfg.norm, list) and len(cfg.norm) == num_stages) + assert isinstance(cfg.act, str) or (isinstance(cfg.act, list) and len(cfg.act) == num_stages) + + self.project_in = build_decoder_project_in_block( + in_channels=cfg.latent_channels, + out_channels=cfg.width_list[-1], + shortcut=cfg.in_shortcut, + ) + + self.stages: list[OpSequential] = [] + for stage_id, (width, depth) in reversed(list(enumerate(zip(cfg.width_list, cfg.depth_list)))): + stage = [] + if stage_id < num_stages - 1 and depth > 0: + upsample_block = build_upsample_block( + block_type=cfg.upsample_block_type, + in_channels=cfg.width_list[stage_id + 1], + out_channels=width if cfg.upsample_match_channel else cfg.width_list[stage_id + 1], + shortcut=cfg.upsample_shortcut, + ) + stage.append(upsample_block) + + block_type = cfg.block_type[stage_id] if isinstance(cfg.block_type, list) else cfg.block_type + norm = cfg.norm[stage_id] if isinstance(cfg.norm, list) else cfg.norm + act = cfg.act[stage_id] if isinstance(cfg.act, list) else cfg.act + stage.extend( + build_stage_main( + width=width, + depth=depth, + block_type=block_type, + norm=norm, + act=act, + input_width=( + width if cfg.upsample_match_channel else cfg.width_list[min(stage_id + 1, num_stages - 1)] + ), + ) + ) + self.stages.insert(0, OpSequential(stage)) + self.stages = nn.ModuleList(self.stages) + + self.project_out = build_decoder_project_out_block( + in_channels=cfg.width_list[0] if cfg.depth_list[0] > 0 else cfg.width_list[1], + out_channels=cfg.in_channels, + factor=1 if cfg.depth_list[0] > 0 else 2, + upsample_block_type=cfg.upsample_block_type, + norm=cfg.out_norm, + act=cfg.out_act, + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = self.project_in(x) + for stage in reversed(self.stages): + if len(stage.op_list) == 0: + continue + x = stage(x) + x = self.project_out(x) + return x + + +class DCAE(nn.Module): + def __init__(self, cfg: DCAEConfig): + super().__init__() + self.cfg = cfg + self.encoder = Encoder(cfg.encoder) + self.decoder = Decoder(cfg.decoder) + + if self.cfg.pretrained_path is not None: + self.load_model() + + def load_model(self): + if self.cfg.pretrained_source == "dc-ae": + state_dict = torch.load(self.cfg.pretrained_path, map_location="cpu", weights_only=True)["state_dict"] + self.load_state_dict(state_dict) + else: + raise NotImplementedError + + @property + def spatial_compression_ratio(self) -> int: + return 2 ** (self.decoder.num_stages - 1) + + def encode(self, x: torch.Tensor) -> torch.Tensor: + x = self.encoder(x) + return x + + def decode(self, x: torch.Tensor) -> torch.Tensor: + x = self.decoder(x) + return x + + def forward(self, x: torch.Tensor, global_step: int) -> torch.Tensor: + x = self.encoder(x) + x = self.decoder(x) + return x, torch.tensor(0), {} + + +def dc_ae_f32c32(name: str, pretrained_path: str) -> DCAEConfig: + if name in ["dc-ae-f32c32-in-1.0", "dc-ae-f32c32-mix-1.0"]: + cfg_str = ( + "latent_channels=32 " + "encoder.block_type=[ResBlock,ResBlock,ResBlock,EViT_GLU,EViT_GLU,EViT_GLU] " + "encoder.width_list=[128,256,512,512,1024,1024] encoder.depth_list=[0,4,8,2,2,2] " + "decoder.block_type=[ResBlock,ResBlock,ResBlock,EViT_GLU,EViT_GLU,EViT_GLU] " + "decoder.width_list=[128,256,512,512,1024,1024] decoder.depth_list=[0,5,10,2,2,2] " + "decoder.norm=[bn2d,bn2d,bn2d,trms2d,trms2d,trms2d] decoder.act=[relu,relu,relu,silu,silu,silu]" + ) + elif name in ["dc-ae-f32c32-sana-1.0"]: + cfg_str = ( + "latent_channels=32 " + "encoder.block_type=[ResBlock,ResBlock,ResBlock,EViTS5_GLU,EViTS5_GLU,EViTS5_GLU] " + "encoder.width_list=[128,256,512,512,1024,1024] encoder.depth_list=[2,2,2,3,3,3] " + "encoder.downsample_block_type=Conv " + "decoder.block_type=[ResBlock,ResBlock,ResBlock,EViTS5_GLU,EViTS5_GLU,EViTS5_GLU] " + "decoder.width_list=[128,256,512,512,1024,1024] decoder.depth_list=[3,3,3,3,3,3] " + "decoder.upsample_block_type=InterpolateConv " + "decoder.norm=trms2d decoder.act=silu" + ) + else: + raise NotImplementedError + cfg = OmegaConf.from_dotlist(cfg_str.split(" ")) + cfg: DCAEConfig = OmegaConf.to_object(OmegaConf.merge(OmegaConf.structured(DCAEConfig), cfg)) + cfg.pretrained_path = pretrained_path + return cfg + + +def dc_ae_f64c128(name: str, pretrained_path: Optional[str] = None) -> DCAEConfig: + if name in ["dc-ae-f64c128-in-1.0", "dc-ae-f64c128-mix-1.0"]: + cfg_str = ( + "latent_channels=128 " + "encoder.block_type=[ResBlock,ResBlock,ResBlock,EViT_GLU,EViT_GLU,EViT_GLU,EViT_GLU] " + "encoder.width_list=[128,256,512,512,1024,1024,2048] encoder.depth_list=[0,4,8,2,2,2,2] " + "decoder.block_type=[ResBlock,ResBlock,ResBlock,EViT_GLU,EViT_GLU,EViT_GLU,EViT_GLU] " + "decoder.width_list=[128,256,512,512,1024,1024,2048] decoder.depth_list=[0,5,10,2,2,2,2] " + "decoder.norm=[bn2d,bn2d,bn2d,trms2d,trms2d,trms2d,trms2d] decoder.act=[relu,relu,relu,silu,silu,silu,silu]" + ) + else: + raise NotImplementedError + cfg = OmegaConf.from_dotlist(cfg_str.split(" ")) + cfg: DCAEConfig = OmegaConf.to_object(OmegaConf.merge(OmegaConf.structured(DCAEConfig), cfg)) + cfg.pretrained_path = pretrained_path + return cfg + + +def dc_ae_f128c512(name: str, pretrained_path: Optional[str] = None) -> DCAEConfig: + if name in ["dc-ae-f128c512-in-1.0", "dc-ae-f128c512-mix-1.0"]: + cfg_str = ( + "latent_channels=512 " + "encoder.block_type=[ResBlock,ResBlock,ResBlock,EViT_GLU,EViT_GLU,EViT_GLU,EViT_GLU,EViT_GLU] " + "encoder.width_list=[128,256,512,512,1024,1024,2048,2048] encoder.depth_list=[0,4,8,2,2,2,2,2] " + "decoder.block_type=[ResBlock,ResBlock,ResBlock,EViT_GLU,EViT_GLU,EViT_GLU,EViT_GLU,EViT_GLU] " + "decoder.width_list=[128,256,512,512,1024,1024,2048,2048] decoder.depth_list=[0,5,10,2,2,2,2,2] " + "decoder.norm=[bn2d,bn2d,bn2d,trms2d,trms2d,trms2d,trms2d,trms2d] decoder.act=[relu,relu,relu,silu,silu,silu,silu,silu]" + ) + else: + raise NotImplementedError + cfg = OmegaConf.from_dotlist(cfg_str.split(" ")) + cfg: DCAEConfig = OmegaConf.to_object(OmegaConf.merge(OmegaConf.structured(DCAEConfig), cfg)) + cfg.pretrained_path = pretrained_path + return cfg + + +REGISTERED_DCAE_MODEL: dict[str, tuple[Callable, Optional[str]]] = { + "dc-ae-f32c32-in-1.0": (dc_ae_f32c32, None), + "dc-ae-f64c128-in-1.0": (dc_ae_f64c128, None), + "dc-ae-f128c512-in-1.0": (dc_ae_f128c512, None), + ################################################################################################# + "dc-ae-f32c32-mix-1.0": (dc_ae_f32c32, None), + "dc-ae-f64c128-mix-1.0": (dc_ae_f64c128, None), + "dc-ae-f128c512-mix-1.0": (dc_ae_f128c512, None), + ################################################################################################# + "dc-ae-f32c32-sana-1.0": (dc_ae_f32c32, None), +} + + +def create_dc_ae_model_cfg(name: str, pretrained_path: Optional[str] = None) -> DCAEConfig: + assert name in REGISTERED_DCAE_MODEL, f"{name} is not supported" + dc_ae_cls, default_pt_path = REGISTERED_DCAE_MODEL[name] + pretrained_path = default_pt_path if pretrained_path is None else pretrained_path + model_cfg = dc_ae_cls(name, pretrained_path) + return model_cfg + + +class DCAE_HF(DCAE, PyTorchModelHubMixin): + def __init__(self, model_name: str): + cfg = create_dc_ae_model_cfg(model_name) + DCAE.__init__(self, cfg) diff --git a/src/diffusers/models/efficientvit_blocks/act.py b/src/diffusers/models/efficientvit_blocks/act.py new file mode 100644 index 000000000000..c5fadd90deef --- /dev/null +++ b/src/diffusers/models/efficientvit_blocks/act.py @@ -0,0 +1,27 @@ +from functools import partial +from typing import Optional + +import torch.nn as nn + +from .utils.network import build_kwargs_from_config + +__all__ = ["build_act"] + + +# register activation function here +REGISTERED_ACT_DICT: dict[str, type] = { + "relu": nn.ReLU, + "relu6": nn.ReLU6, + "hswish": nn.Hardswish, + "silu": nn.SiLU, + "gelu": partial(nn.GELU, approximate="tanh"), +} + + +def build_act(name: str, **kwargs) -> Optional[nn.Module]: + if name in REGISTERED_ACT_DICT: + act_cls = REGISTERED_ACT_DICT[name] + args = build_kwargs_from_config(kwargs, act_cls) + return act_cls(**args) + else: + return None diff --git a/src/diffusers/models/efficientvit_blocks/norm.py b/src/diffusers/models/efficientvit_blocks/norm.py new file mode 100644 index 000000000000..583ecbfc8bf0 --- /dev/null +++ b/src/diffusers/models/efficientvit_blocks/norm.py @@ -0,0 +1,53 @@ +from typing import Optional + +import torch +import torch.nn as nn +from torch.nn.modules.batchnorm import _BatchNorm + +from .triton_rms_norm import TritonRMSNorm2dFunc +from .utils.network import build_kwargs_from_config + +__all__ = ["LayerNorm2d", "TritonRMSNorm2d", "build_norm", "set_norm_eps"] + + +class LayerNorm2d(nn.LayerNorm): + def forward(self, x: torch.Tensor) -> torch.Tensor: + out = x - torch.mean(x, dim=1, keepdim=True) + out = out / torch.sqrt(torch.square(out).mean(dim=1, keepdim=True) + self.eps) + if self.elementwise_affine: + out = out * self.weight.view(1, -1, 1, 1) + self.bias.view(1, -1, 1, 1) + return out + + +class TritonRMSNorm2d(nn.LayerNorm): + def forward(self, x: torch.Tensor) -> torch.Tensor: + return TritonRMSNorm2dFunc.apply(x, self.weight, self.bias, self.eps) + + +# register normalization function here +REGISTERED_NORM_DICT: dict[str, type] = { + "bn2d": nn.BatchNorm2d, + "ln": nn.LayerNorm, + "ln2d": LayerNorm2d, + "trms2d": TritonRMSNorm2d, +} + + +def build_norm(name="bn2d", num_features=None, **kwargs) -> Optional[nn.Module]: + if name in ["ln", "ln2d", "trms2d"]: + kwargs["normalized_shape"] = num_features + else: + kwargs["num_features"] = num_features + if name in REGISTERED_NORM_DICT: + norm_cls = REGISTERED_NORM_DICT[name] + args = build_kwargs_from_config(kwargs, norm_cls) + return norm_cls(**args) + else: + return None + + +def set_norm_eps(model: nn.Module, eps: Optional[float] = None) -> None: + for m in model.modules(): + if isinstance(m, (nn.GroupNorm, nn.LayerNorm, _BatchNorm)): + if eps is not None: + m.eps = eps diff --git a/src/diffusers/models/efficientvit_blocks/ops.py b/src/diffusers/models/efficientvit_blocks/ops.py new file mode 100644 index 000000000000..e239f7314182 --- /dev/null +++ b/src/diffusers/models/efficientvit_blocks/ops.py @@ -0,0 +1,820 @@ +from typing import Optional + +import torch +import torch.nn as nn +import torch.nn.functional as F + +from .act import build_act +from .norm import build_norm +from .utils.network import get_same_padding, resize +from .utils.list import list_sum, val2list, val2tuple + +__all__ = [ + "ConvLayer", + "UpSampleLayer", + "ConvPixelUnshuffleDownSampleLayer", + "PixelUnshuffleChannelAveragingDownSampleLayer", + "ConvPixelShuffleUpSampleLayer", + "ChannelDuplicatingPixelUnshuffleUpSampleLayer", + "LinearLayer", + "IdentityLayer", + "DSConv", + "MBConv", + "FusedMBConv", + "ResBlock", + "LiteMLA", + "EfficientViTBlock", + "ResidualBlock", + "DAGBlock", + "OpSequential", +] + + +################################################################################# +# Basic Layers # +################################################################################# + + +class ConvLayer(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + kernel_size=3, + stride=1, + dilation=1, + groups=1, + use_bias=False, + dropout=0, + norm="bn2d", + act_func="relu", + ): + super(ConvLayer, self).__init__() + + padding = get_same_padding(kernel_size) + padding *= dilation + + self.dropout = nn.Dropout2d(dropout, inplace=False) if dropout > 0 else None + self.conv = nn.Conv2d( + in_channels, + out_channels, + kernel_size=(kernel_size, kernel_size), + stride=(stride, stride), + padding=padding, + dilation=(dilation, dilation), + groups=groups, + bias=use_bias, + ) + self.norm = build_norm(norm, num_features=out_channels) + self.act = build_act(act_func) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + if self.dropout is not None: + x = self.dropout(x) + x = self.conv(x) + if self.norm: + x = self.norm(x) + if self.act: + x = self.act(x) + return x + + +class UpSampleLayer(nn.Module): + def __init__( + self, + mode="bicubic", + size: Optional[int | tuple[int, int] | list[int]] = None, + factor=2, + align_corners=False, + ): + super(UpSampleLayer, self).__init__() + self.mode = mode + self.size = val2list(size, 2) if size is not None else None + self.factor = None if self.size is not None else factor + self.align_corners = align_corners + + @torch.autocast(device_type="cuda", enabled=False) + def forward(self, x: torch.Tensor) -> torch.Tensor: + if (self.size is not None and tuple(x.shape[-2:]) == self.size) or self.factor == 1: + return x + if x.dtype in [torch.float16, torch.bfloat16]: + x = x.float() + return resize(x, self.size, self.factor, self.mode, self.align_corners) + + +class ConvPixelUnshuffleDownSampleLayer(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + kernel_size: int, + factor: int, + ): + super().__init__() + self.factor = factor + out_ratio = factor**2 + assert out_channels % out_ratio == 0 + self.conv = ConvLayer( + in_channels=in_channels, + out_channels=out_channels // out_ratio, + kernel_size=kernel_size, + use_bias=True, + norm=None, + act_func=None, + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = self.conv(x) + x = F.pixel_unshuffle(x, self.factor) + return x + + +class PixelUnshuffleChannelAveragingDownSampleLayer(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + factor: int, + ): + super().__init__() + self.in_channels = in_channels + self.out_channels = out_channels + self.factor = factor + assert in_channels * factor**2 % out_channels == 0 + self.group_size = in_channels * factor**2 // out_channels + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = F.pixel_unshuffle(x, self.factor) + B, C, H, W = x.shape + x = x.view(B, self.out_channels, self.group_size, H, W) + x = x.mean(dim=2) + return x + + +class ConvPixelShuffleUpSampleLayer(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + kernel_size: int, + factor: int, + ): + super().__init__() + self.factor = factor + out_ratio = factor**2 + self.conv = ConvLayer( + in_channels=in_channels, + out_channels=out_channels * out_ratio, + kernel_size=kernel_size, + use_bias=True, + norm=None, + act_func=None, + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = self.conv(x) + x = F.pixel_shuffle(x, self.factor) + return x + + +class InterpolateConvUpSampleLayer(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + kernel_size: int, + factor: int, + mode: str = "nearest", + ) -> None: + super().__init__() + self.factor = factor + self.mode = mode + self.conv = ConvLayer( + in_channels=in_channels, + out_channels=out_channels, + kernel_size=kernel_size, + use_bias=True, + norm=None, + act_func=None, + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = torch.nn.functional.interpolate(x, scale_factor=self.factor, mode=self.mode) + x = self.conv(x) + return x + + +class ChannelDuplicatingPixelUnshuffleUpSampleLayer(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + factor: int, + ): + super().__init__() + self.in_channels = in_channels + self.out_channels = out_channels + self.factor = factor + assert out_channels * factor**2 % in_channels == 0 + self.repeats = out_channels * factor**2 // in_channels + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = x.repeat_interleave(self.repeats, dim=1) + x = F.pixel_shuffle(x, self.factor) + return x + + +class LinearLayer(nn.Module): + def __init__( + self, + in_features: int, + out_features: int, + use_bias=True, + dropout=0, + norm=None, + act_func=None, + ): + super(LinearLayer, self).__init__() + + self.dropout = nn.Dropout(dropout, inplace=False) if dropout > 0 else None + self.linear = nn.Linear(in_features, out_features, use_bias) + self.norm = build_norm(norm, num_features=out_features) + self.act = build_act(act_func) + + def _try_squeeze(self, x: torch.Tensor) -> torch.Tensor: + if x.dim() > 2: + x = torch.flatten(x, start_dim=1) + return x + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = self._try_squeeze(x) + if self.dropout: + x = self.dropout(x) + x = self.linear(x) + if self.norm: + x = self.norm(x) + if self.act: + x = self.act(x) + return x + + +class IdentityLayer(nn.Module): + def forward(self, x: torch.Tensor) -> torch.Tensor: + return x + + +################################################################################# +# Basic Blocks # +################################################################################# + + +class DSConv(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + kernel_size=3, + stride=1, + use_bias=False, + norm=("bn2d", "bn2d"), + act_func=("relu6", None), + ): + super(DSConv, self).__init__() + + use_bias = val2tuple(use_bias, 2) + norm = val2tuple(norm, 2) + act_func = val2tuple(act_func, 2) + + self.depth_conv = ConvLayer( + in_channels, + in_channels, + kernel_size, + stride, + groups=in_channels, + norm=norm[0], + act_func=act_func[0], + use_bias=use_bias[0], + ) + self.point_conv = ConvLayer( + in_channels, + out_channels, + 1, + norm=norm[1], + act_func=act_func[1], + use_bias=use_bias[1], + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = self.depth_conv(x) + x = self.point_conv(x) + return x + + +class MBConv(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + kernel_size=3, + stride=1, + mid_channels=None, + expand_ratio=6, + use_bias=False, + norm=("bn2d", "bn2d", "bn2d"), + act_func=("relu6", "relu6", None), + ): + super(MBConv, self).__init__() + + use_bias = val2tuple(use_bias, 3) + norm = val2tuple(norm, 3) + act_func = val2tuple(act_func, 3) + mid_channels = round(in_channels * expand_ratio) if mid_channels is None else mid_channels + + self.inverted_conv = ConvLayer( + in_channels, + mid_channels, + 1, + stride=1, + norm=norm[0], + act_func=act_func[0], + use_bias=use_bias[0], + ) + self.depth_conv = ConvLayer( + mid_channels, + mid_channels, + kernel_size, + stride=stride, + groups=mid_channels, + norm=norm[1], + act_func=act_func[1], + use_bias=use_bias[1], + ) + self.point_conv = ConvLayer( + mid_channels, + out_channels, + 1, + norm=norm[2], + act_func=act_func[2], + use_bias=use_bias[2], + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = self.inverted_conv(x) + x = self.depth_conv(x) + x = self.point_conv(x) + return x + + +class FusedMBConv(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + kernel_size=3, + stride=1, + mid_channels=None, + expand_ratio=6, + groups=1, + use_bias=False, + norm=("bn2d", "bn2d"), + act_func=("relu6", None), + ): + super().__init__() + use_bias = val2tuple(use_bias, 2) + norm = val2tuple(norm, 2) + act_func = val2tuple(act_func, 2) + + mid_channels = round(in_channels * expand_ratio) if mid_channels is None else mid_channels + + self.spatial_conv = ConvLayer( + in_channels, + mid_channels, + kernel_size, + stride, + groups=groups, + use_bias=use_bias[0], + norm=norm[0], + act_func=act_func[0], + ) + self.point_conv = ConvLayer( + mid_channels, + out_channels, + 1, + use_bias=use_bias[1], + norm=norm[1], + act_func=act_func[1], + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = self.spatial_conv(x) + x = self.point_conv(x) + return x + + +class GLUMBConv(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + kernel_size=3, + stride=1, + mid_channels=None, + expand_ratio=6, + use_bias=False, + norm=(None, None, "ln2d"), + act_func=("silu", "silu", None), + ): + super().__init__() + use_bias = val2tuple(use_bias, 3) + norm = val2tuple(norm, 3) + act_func = val2tuple(act_func, 3) + + mid_channels = round(in_channels * expand_ratio) if mid_channels is None else mid_channels + + self.glu_act = build_act(act_func[1], inplace=False) + self.inverted_conv = ConvLayer( + in_channels, + mid_channels * 2, + 1, + use_bias=use_bias[0], + norm=norm[0], + act_func=act_func[0], + ) + self.depth_conv = ConvLayer( + mid_channels * 2, + mid_channels * 2, + kernel_size, + stride=stride, + groups=mid_channels * 2, + use_bias=use_bias[1], + norm=norm[1], + act_func=None, + ) + self.point_conv = ConvLayer( + mid_channels, + out_channels, + 1, + use_bias=use_bias[2], + norm=norm[2], + act_func=act_func[2], + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = self.inverted_conv(x) + x = self.depth_conv(x) + + x, gate = torch.chunk(x, 2, dim=1) + gate = self.glu_act(gate) + x = x * gate + + x = self.point_conv(x) + return x + + +class ResBlock(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + kernel_size=3, + stride=1, + mid_channels=None, + expand_ratio=1, + use_bias=False, + norm=("bn2d", "bn2d"), + act_func=("relu6", None), + ): + super().__init__() + use_bias = val2tuple(use_bias, 2) + norm = val2tuple(norm, 2) + act_func = val2tuple(act_func, 2) + + mid_channels = round(in_channels * expand_ratio) if mid_channels is None else mid_channels + + self.conv1 = ConvLayer( + in_channels, + mid_channels, + kernel_size, + stride, + use_bias=use_bias[0], + norm=norm[0], + act_func=act_func[0], + ) + self.conv2 = ConvLayer( + mid_channels, + out_channels, + kernel_size, + 1, + use_bias=use_bias[1], + norm=norm[1], + act_func=act_func[1], + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = self.conv1(x) + x = self.conv2(x) + return x + + +class LiteMLA(nn.Module): + r"""Lightweight multi-scale linear attention""" + + def __init__( + self, + in_channels: int, + out_channels: int, + heads: Optional[int] = None, + heads_ratio: float = 1.0, + dim=8, + use_bias=False, + norm=(None, "bn2d"), + act_func=(None, None), + kernel_func="relu", + scales: tuple[int, ...] = (5,), + eps=1.0e-15, + ): + super(LiteMLA, self).__init__() + self.eps = eps + heads = int(in_channels // dim * heads_ratio) if heads is None else heads + + total_dim = heads * dim + + use_bias = val2tuple(use_bias, 2) + norm = val2tuple(norm, 2) + act_func = val2tuple(act_func, 2) + + self.dim = dim + self.qkv = ConvLayer( + in_channels, + 3 * total_dim, + 1, + use_bias=use_bias[0], + norm=norm[0], + act_func=act_func[0], + ) + self.aggreg = nn.ModuleList( + [ + nn.Sequential( + nn.Conv2d( + 3 * total_dim, + 3 * total_dim, + scale, + padding=get_same_padding(scale), + groups=3 * total_dim, + bias=use_bias[0], + ), + nn.Conv2d(3 * total_dim, 3 * total_dim, 1, groups=3 * heads, bias=use_bias[0]), + ) + for scale in scales + ] + ) + self.kernel_func = build_act(kernel_func, inplace=False) + + self.proj = ConvLayer( + total_dim * (1 + len(scales)), + out_channels, + 1, + use_bias=use_bias[1], + norm=norm[1], + act_func=act_func[1], + ) + + @torch.autocast(device_type="cuda", enabled=False) + def relu_linear_att(self, qkv: torch.Tensor) -> torch.Tensor: + B, _, H, W = list(qkv.size()) + + if qkv.dtype == torch.float16: + qkv = qkv.float() + + qkv = torch.reshape( + qkv, + ( + B, + -1, + 3 * self.dim, + H * W, + ), + ) + q, k, v = ( + qkv[:, :, 0 : self.dim], + qkv[:, :, self.dim : 2 * self.dim], + qkv[:, :, 2 * self.dim :], + ) + + # lightweight linear attention + q = self.kernel_func(q) + k = self.kernel_func(k) + + # linear matmul + trans_k = k.transpose(-1, -2) + + v = F.pad(v, (0, 0, 0, 1), mode="constant", value=1) + vk = torch.matmul(v, trans_k) + out = torch.matmul(vk, q) + if out.dtype == torch.bfloat16: + out = out.float() + out = out[:, :, :-1] / (out[:, :, -1:] + self.eps) + + out = torch.reshape(out, (B, -1, H, W)) + return out + + @torch.autocast(device_type="cuda", enabled=False) + def relu_quadratic_att(self, qkv: torch.Tensor) -> torch.Tensor: + B, _, H, W = list(qkv.size()) + + qkv = torch.reshape( + qkv, + ( + B, + -1, + 3 * self.dim, + H * W, + ), + ) + q, k, v = ( + qkv[:, :, 0 : self.dim], + qkv[:, :, self.dim : 2 * self.dim], + qkv[:, :, 2 * self.dim :], + ) + + q = self.kernel_func(q) + k = self.kernel_func(k) + + att_map = torch.matmul(k.transpose(-1, -2), q) # b h n n + original_dtype = att_map.dtype + if original_dtype in [torch.float16, torch.bfloat16]: + att_map = att_map.float() + att_map = att_map / (torch.sum(att_map, dim=2, keepdim=True) + self.eps) # b h n n + att_map = att_map.to(original_dtype) + out = torch.matmul(v, att_map) # b h d n + + out = torch.reshape(out, (B, -1, H, W)) + return out + + def forward(self, x: torch.Tensor) -> torch.Tensor: + # generate multi-scale q, k, v + qkv = self.qkv(x) + multi_scale_qkv = [qkv] + for op in self.aggreg: + multi_scale_qkv.append(op(qkv)) + qkv = torch.cat(multi_scale_qkv, dim=1) + + H, W = list(qkv.size())[-2:] + if H * W > self.dim: + out = self.relu_linear_att(qkv).to(qkv.dtype) + else: + out = self.relu_quadratic_att(qkv) + out = self.proj(out) + + return out + + +class EfficientViTBlock(nn.Module): + def __init__( + self, + in_channels: int, + heads_ratio: float = 1.0, + dim=32, + expand_ratio: float = 4, + scales: tuple[int, ...] = (5,), + norm: str = "bn2d", + act_func: str = "hswish", + context_module: str = "LiteMLA", + local_module: str = "MBConv", + ): + super(EfficientViTBlock, self).__init__() + if context_module == "LiteMLA": + self.context_module = ResidualBlock( + LiteMLA( + in_channels=in_channels, + out_channels=in_channels, + heads_ratio=heads_ratio, + dim=dim, + norm=(None, norm), + scales=scales, + ), + IdentityLayer(), + ) + else: + raise ValueError(f"context_module {context_module} is not supported") + if local_module == "MBConv": + self.local_module = ResidualBlock( + MBConv( + in_channels=in_channels, + out_channels=in_channels, + expand_ratio=expand_ratio, + use_bias=(True, True, False), + norm=(None, None, norm), + act_func=(act_func, act_func, None), + ), + IdentityLayer(), + ) + elif local_module == "GLUMBConv": + self.local_module = ResidualBlock( + GLUMBConv( + in_channels=in_channels, + out_channels=in_channels, + expand_ratio=expand_ratio, + use_bias=(True, True, False), + norm=(None, None, norm), + act_func=(act_func, act_func, None), + ), + IdentityLayer(), + ) + else: + raise NotImplementedError(f"local_module {local_module} is not supported") + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = self.context_module(x) + x = self.local_module(x) + return x + + +################################################################################# +# Functional Blocks # +################################################################################# + + +class ResidualBlock(nn.Module): + def __init__( + self, + main: Optional[nn.Module], + shortcut: Optional[nn.Module], + post_act=None, + pre_norm: Optional[nn.Module] = None, + ): + super(ResidualBlock, self).__init__() + + self.pre_norm = pre_norm + self.main = main + self.shortcut = shortcut + self.post_act = build_act(post_act) + + def forward_main(self, x: torch.Tensor) -> torch.Tensor: + if self.pre_norm is None: + return self.main(x) + else: + return self.main(self.pre_norm(x)) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + if self.main is None: + res = x + elif self.shortcut is None: + res = self.forward_main(x) + else: + res = self.forward_main(x) + self.shortcut(x) + if self.post_act: + res = self.post_act(res) + return res + + +class DAGBlock(nn.Module): + def __init__( + self, + inputs: dict[str, nn.Module], + merge: str, + post_input: Optional[nn.Module], + middle: nn.Module, + outputs: dict[str, nn.Module], + ): + super(DAGBlock, self).__init__() + + self.input_keys = list(inputs.keys()) + self.input_ops = nn.ModuleList(list(inputs.values())) + self.merge = merge + self.post_input = post_input + + self.middle = middle + + self.output_keys = list(outputs.keys()) + self.output_ops = nn.ModuleList(list(outputs.values())) + + def forward(self, feature_dict: dict[str, torch.Tensor]) -> dict[str, torch.Tensor]: + feat = [op(feature_dict[key]) for key, op in zip(self.input_keys, self.input_ops)] + if self.merge == "add": + feat = list_sum(feat) + elif self.merge == "cat": + feat = torch.concat(feat, dim=1) + else: + raise NotImplementedError + if self.post_input is not None: + feat = self.post_input(feat) + feat = self.middle(feat) + for key, op in zip(self.output_keys, self.output_ops): + feature_dict[key] = op(feat) + return feature_dict + + +class OpSequential(nn.Module): + def __init__(self, op_list: list[Optional[nn.Module]]): + super(OpSequential, self).__init__() + valid_op_list = [] + for op in op_list: + if op is not None: + valid_op_list.append(op) + self.op_list = nn.ModuleList(valid_op_list) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + for op in self.op_list: + x = op(x) + return x diff --git a/src/diffusers/models/efficientvit_blocks/triton_rms_norm.py b/src/diffusers/models/efficientvit_blocks/triton_rms_norm.py new file mode 100644 index 000000000000..e6a3ca76a12a --- /dev/null +++ b/src/diffusers/models/efficientvit_blocks/triton_rms_norm.py @@ -0,0 +1,191 @@ +import torch +import triton +import triton.language as tl + +__all__ = ["TritonRMSNorm2dFunc"] + + +@triton.jit +def _rms_norm_2d_fwd_fused( + X, # pointer to the input + Y, # pointer to the output + W, # pointer to the weights + B, # pointer to the biases + Rrms, # pointer to the 1/rms + M, + C, + N, + num_blocks, # number of columns in X + eps, # epsilon to avoid division by zero + BLOCK_SIZE: tl.constexpr, +): + # Map the program id to the row of X and Y it should compute. + m_n = tl.program_id(0) + m, n = m_n // num_blocks, m_n % num_blocks + + Y += m * C * N + X += m * C * N + # Compute mean + + cols = n * BLOCK_SIZE + tl.arange(0, BLOCK_SIZE) + mask = cols < N + + x_sum_square = tl.zeros([BLOCK_SIZE], dtype=tl.float32) + for off in range(0, C): + x = tl.load(X + off * N + cols, mask=mask, other=0.0).to(tl.float32) + x_sum_square += x * x + mean_square = x_sum_square / C + rrms = 1 / tl.sqrt(mean_square + eps) + # Write rstd + tl.store(Rrms + m * N + cols, rrms, mask=mask) + # Normalize and apply linear transformation + for off in range(0, C): + pos = off * N + cols + w = tl.load(W + off) + b = tl.load(B + off) + x = tl.load(X + pos, mask=mask, other=0.0).to(tl.float32) + x_hat = x * rrms + y = x_hat * w + b + # Write output + tl.store(Y + pos, y, mask=mask) + + +@triton.jit +def _rms_norm_2d_bwd_dx_fused( + DX, # pointer to the input gradient + DY, # pointer to the output gradient + DW, # pointer to the partial sum of weights gradient + DB, # pointer to the partial sum of biases gradient + X, # pointer to the input + W, # pointer to the weights + B, # pointer to the biases + Rrms, # pointer to the 1/rms + M, + C, + N, # number of columns in X + num_blocks, + eps, # epsilon to avoid division by zero + GROUP_SIZE_M: tl.constexpr, + BLOCK_SIZE: tl.constexpr, + BLOCK_SIZE_C: tl.constexpr, +): + # Map the program id to the elements of X, DX, and DY it should compute. + m_n = tl.program_id(0) + m, n = m_n // num_blocks, m_n % num_blocks + X += m * C * N + DY += m * C * N + DX += m * C * N + Rrms += m * N + + cols = n * BLOCK_SIZE + tl.arange(0, BLOCK_SIZE) + mask = cols < N + # Offset locks and weights/biases gradient pointer for parallel reduction + DW = DW + m_n * C + DB = DB + m_n * C + rrms = tl.load(Rrms + cols, mask=mask, other=1) + # Load data to SRAM + c1 = tl.zeros([BLOCK_SIZE], dtype=tl.float32) + for off in range(0, C): + pos = off * N + cols + x = tl.load(X + pos, mask=mask, other=0).to(tl.float32) + dy = tl.load(DY + pos, mask=mask, other=0).to(tl.float32) + w = tl.load(W + off).to(tl.float32) + # Compute dx + xhat = x * rrms + wdy = w * dy + xhat = tl.where(mask, xhat, 0.0) + wdy = tl.where(mask, wdy, 0.0) + c1 += xhat * wdy + # Accumulate partial sums for dw/db + tl.store(DW + off, tl.sum((dy * xhat).to(w.dtype), axis=0)) + tl.store(DB + off, tl.sum(dy.to(w.dtype), axis=0)) + + c1 /= C + for off in range(0, C): + pos = off * N + cols + x = tl.load(X + pos, mask=mask, other=0).to(tl.float32) + dy = tl.load(DY + pos, mask=mask, other=0).to(tl.float32) + w = tl.load(W + off).to(tl.float32) + xhat = x * rrms + wdy = w * dy + dx = (wdy - (xhat * c1)) * rrms + # Write dx + tl.store(DX + pos, dx, mask=mask) + + +class TritonRMSNorm2dFunc(torch.autograd.Function): + @staticmethod + def forward(ctx, x, weight, bias, eps): + # allocate output + y = torch.empty_like(x) + # reshape input data into 2D tensor + x_arg = x.reshape(x.shape[0], x.shape[1], -1) + M, C, N = x_arg.shape + rrms = torch.empty((M, N), dtype=torch.float32, device="cuda") + # Less than 64KB per feature: enqueue fused kernel + BLOCK_SIZE = 256 + num_blocks = triton.cdiv(N, BLOCK_SIZE) + num_warps = 8 + # enqueue kernel + _rms_norm_2d_fwd_fused[(M * num_blocks,)]( # + x_arg, + y, + weight, + bias, + rrms, # + M, + C, + N, + num_blocks, + eps, # + BLOCK_SIZE=BLOCK_SIZE, + num_warps=num_warps, + num_ctas=1, + ) + ctx.save_for_backward(x, weight, bias, rrms) + ctx.BLOCK_SIZE = BLOCK_SIZE + ctx.num_blocks = num_blocks + ctx.num_warps = num_warps + ctx.eps = eps + return y + + @staticmethod + def backward(ctx, dy): + x, w, b, rrms = ctx.saved_tensors + num_blocks = ctx.num_blocks + + x_arg = x.reshape(x.shape[0], x.shape[1], -1) + M, C, N = x_arg.shape + # GROUP_SIZE_M = 64 + GROUP_SIZE_M = M * num_blocks + # allocate output + _dw = torch.empty((GROUP_SIZE_M, C), dtype=x.dtype, device=w.device) + _db = torch.empty((GROUP_SIZE_M, C), dtype=x.dtype, device=w.device) + dw = torch.empty((C,), dtype=w.dtype, device=w.device) + db = torch.empty((C,), dtype=w.dtype, device=w.device) + dx = torch.empty_like(dy) + # enqueue kernel using forward pass heuristics + # also compute partial sums for DW and DB + # print(f"M={M}, num_blocks={num_blocks}, dx={dx.shape}, dy={dy.shape}, _dw={_dw.shape}, _db={_db.shape}, x={x.shape}, w={w.shape}, b={b.shape}, m={m.shape}, v={v.shape}, M={M}, C={C}, N={N}") + _rms_norm_2d_bwd_dx_fused[(M * num_blocks,)]( # + dx, + dy, + _dw, + _db, + x, + w, + b, + rrms, # + M, + C, + N, + num_blocks, + ctx.eps, # + BLOCK_SIZE=ctx.BLOCK_SIZE, + GROUP_SIZE_M=GROUP_SIZE_M, # + BLOCK_SIZE_C=triton.next_power_of_2(C), + num_warps=ctx.num_warps, + ) + dw = _dw.sum(dim=0) + db = _db.sum(dim=0) + return dx, dw, db, None diff --git a/src/diffusers/models/efficientvit_blocks/utils/list.py b/src/diffusers/models/efficientvit_blocks/utils/list.py new file mode 100644 index 000000000000..71fa5f78131f --- /dev/null +++ b/src/diffusers/models/efficientvit_blocks/utils/list.py @@ -0,0 +1,51 @@ +from typing import Any, Optional + +__all__ = [ + "list_sum", + "list_mean", + "weighted_list_sum", + "list_join", + "val2list", + "val2tuple", + "squeeze_list", +] + + +def list_sum(x: list) -> Any: + return x[0] if len(x) == 1 else x[0] + list_sum(x[1:]) + + +def list_mean(x: list) -> Any: + return list_sum(x) / len(x) + + +def weighted_list_sum(x: list, weights: list) -> Any: + assert len(x) == len(weights) + return x[0] * weights[0] if len(x) == 1 else x[0] * weights[0] + weighted_list_sum(x[1:], weights[1:]) + + +def list_join(x: list, sep="\t", format_str="%s") -> str: + return sep.join([format_str % val for val in x]) + + +def val2list(x: list | tuple | Any, repeat_time=1) -> list: + if isinstance(x, (list, tuple)): + return list(x) + return [x for _ in range(repeat_time)] + + +def val2tuple(x: list | tuple | Any, min_len: int = 1, idx_repeat: int = -1) -> tuple: + x = val2list(x) + + # repeat elements if necessary + if len(x) > 0: + x[idx_repeat:idx_repeat] = [x[idx_repeat] for _ in range(min_len - len(x))] + + return tuple(x) + + +def squeeze_list(x: Optional[list]) -> list | Any: + if x is not None and len(x) == 1: + return x[0] + else: + return x diff --git a/src/diffusers/models/efficientvit_blocks/utils/network.py b/src/diffusers/models/efficientvit_blocks/utils/network.py new file mode 100644 index 000000000000..fa054e7acb8f --- /dev/null +++ b/src/diffusers/models/efficientvit_blocks/utils/network.py @@ -0,0 +1,95 @@ +import collections +import os +from inspect import signature +from typing import Any, Callable, Optional + +import torch +import torch.nn as nn +import torch.nn.functional as F + +__all__ = [ + "is_parallel", + "get_device", + "get_same_padding", + "resize", + "build_kwargs_from_config", + "load_state_dict_from_file", + "get_submodule_weights", +] + + +def is_parallel(model: nn.Module) -> bool: + return isinstance(model, (nn.parallel.DataParallel, nn.parallel.DistributedDataParallel)) + + +def get_device(model: nn.Module) -> torch.device: + return model.parameters().__next__().device + + +def get_dtype(model: nn.Module) -> torch.dtype: + return model.parameters().__next__().dtype + + +def get_same_padding(kernel_size: int | tuple[int, ...]) -> int | tuple[int, ...]: + if isinstance(kernel_size, tuple): + return tuple([get_same_padding(ks) for ks in kernel_size]) + else: + assert kernel_size % 2 > 0, "kernel size should be odd number" + return kernel_size // 2 + + +def resize( + x: torch.Tensor, + size: Optional[Any] = None, + scale_factor: Optional[list[float]] = None, + mode: str = "bicubic", + align_corners: Optional[bool] = False, +) -> torch.Tensor: + if mode in {"bilinear", "bicubic"}: + return F.interpolate( + x, + size=size, + scale_factor=scale_factor, + mode=mode, + align_corners=align_corners, + ) + elif mode in {"nearest", "area"}: + return F.interpolate(x, size=size, scale_factor=scale_factor, mode=mode) + else: + raise NotImplementedError(f"resize(mode={mode}) not implemented.") + + +def build_kwargs_from_config(config: dict, target_func: Callable) -> dict[str, Any]: + valid_keys = list(signature(target_func).parameters) + kwargs = {} + for key in config: + if key in valid_keys: + kwargs[key] = config[key] + return kwargs + + +def load_state_dict_from_file(file: str, only_state_dict=True) -> dict[str, torch.Tensor]: + file = os.path.realpath(os.path.expanduser(file)) + checkpoint = torch.load(file, map_location="cpu", weights_only=True) + if only_state_dict and "state_dict" in checkpoint: + checkpoint = checkpoint["state_dict"] + return checkpoint + + +def get_submodule_weights(weights: collections.OrderedDict, prefix: str): + submodule_weights = collections.OrderedDict() + len_prefix = len(prefix) + for key, weight in weights.items(): + if key.startswith(prefix): + submodule_weights[key[len_prefix:]] = weight + return submodule_weights + + +def get_dtype_from_str(dtype: str) -> torch.dtype: + if dtype == "fp32": + return torch.float32 + if dtype == "fp16": + return torch.float16 + if dtype == "bf16": + return torch.bfloat16 + raise NotImplementedError(f"dtype {dtype} is not supported") From 825c975cb9a191f6ecd4d7575e3559f6cc7b2fba Mon Sep 17 00:00:00 2001 From: Junyu Chen Date: Wed, 23 Oct 2024 00:48:42 -0700 Subject: [PATCH 003/141] replace triton with custom implementation --- demo_dc_ae.png | Bin 0 -> 1140382 bytes src/diffusers/models/attention_processor.py | 73 +++++++ src/diffusers/models/autoencoders/dc_ae.py | 52 ++++- .../dc_ae_blocks}/act.py | 0 .../dc_ae_blocks}/norm.py | 15 +- .../dc_ae_blocks}/ops.py | 0 .../dc_ae_blocks}/utils/list.py | 0 .../dc_ae_blocks}/utils/network.py | 0 .../efficientvit_blocks/triton_rms_norm.py | 191 ------------------ 9 files changed, 123 insertions(+), 208 deletions(-) create mode 100644 demo_dc_ae.png rename src/diffusers/models/{efficientvit_blocks => autoencoders/dc_ae_blocks}/act.py (100%) rename src/diffusers/models/{efficientvit_blocks => autoencoders/dc_ae_blocks}/norm.py (78%) rename src/diffusers/models/{efficientvit_blocks => autoencoders/dc_ae_blocks}/ops.py (100%) rename src/diffusers/models/{efficientvit_blocks => autoencoders/dc_ae_blocks}/utils/list.py (100%) rename src/diffusers/models/{efficientvit_blocks => autoencoders/dc_ae_blocks}/utils/network.py (100%) delete mode 100644 src/diffusers/models/efficientvit_blocks/triton_rms_norm.py diff --git a/demo_dc_ae.png b/demo_dc_ae.png new file mode 100644 index 0000000000000000000000000000000000000000..f7428ea009a7e74b5344568d98cf07a3bd680c97 GIT binary patch literal 1140382 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 z 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�sE2hU-YjHco2#Mv;gb^CS9h#Bw8p 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 z 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 z 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 ^hloS4cNo? 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

EW&;m*>U3?G5e-P=Tr_1()#wzx6V7~ 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

!5Dsg% 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

rt@PTe2dQe7-G|U00Xr+ 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 z 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

rAXPzrE1;lM(Nx2 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%0DyO8_ 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∈s@V1!^8hX#e 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 yHHBKc5STts) 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 QoWc3o& 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 IM6N<$f@BGDcK`qY literal 0 HcmV?d00001 diff --git a/src/diffusers/models/attention_processor.py b/src/diffusers/models/attention_processor.py index e735c4ee7d17..df6c00099859 100644 --- a/src/diffusers/models/attention_processor.py +++ b/src/diffusers/models/attention_processor.py @@ -4283,6 +4283,79 @@ def __init__(self): super().__init__() +class DCAEAttnProcessor: + r""" + This class is modified from https://github.com/mit-han-lab/efficientvit + Processor for EfficientViT in DC-AE. + """ + + def __call__( + self, + attn: Attention, + hidden_states: torch.Tensor, + encoder_hidden_states: Optional[torch.Tensor] = None, + attention_mask: Optional[torch.Tensor] = None, + temb: Optional[torch.Tensor] = None, + *args, + **kwargs, + ) -> torch.Tensor: + if len(args) > 0 or kwargs.get("scale", None) is not None: + deprecation_message = "The `scale` argument is deprecated and will be ignored. Please remove it, as passing it will raise an error in the future. `scale` should directly be passed while calling the underlying pipeline component i.e., via `cross_attention_kwargs`." + deprecate("scale", "1.0.0", deprecation_message) + + residual = hidden_states + + if attn.spatial_norm is not None: + hidden_states = attn.spatial_norm(hidden_states, temb) + + input_ndim = hidden_states.ndim + + if input_ndim == 4: + batch_size, channel, height, width = hidden_states.shape + hidden_states = hidden_states.view(batch_size, channel, height * width).transpose(1, 2) + + batch_size, sequence_length, _ = ( + hidden_states.shape if encoder_hidden_states is None else encoder_hidden_states.shape + ) + attention_mask = attn.prepare_attention_mask(attention_mask, sequence_length, batch_size) + + if attn.group_norm is not None: + hidden_states = attn.group_norm(hidden_states.transpose(1, 2)).transpose(1, 2) + + query = attn.to_q(hidden_states) + + if encoder_hidden_states is None: + encoder_hidden_states = hidden_states + elif attn.norm_cross: + encoder_hidden_states = attn.norm_encoder_hidden_states(encoder_hidden_states) + + key = attn.to_k(encoder_hidden_states) + value = attn.to_v(encoder_hidden_states) + + query = attn.head_to_batch_dim(query) + key = attn.head_to_batch_dim(key) + value = attn.head_to_batch_dim(value) + + attention_probs = attn.get_attention_scores(query, key, attention_mask) + hidden_states = torch.bmm(attention_probs, value) + hidden_states = attn.batch_to_head_dim(hidden_states) + + # linear proj + hidden_states = attn.to_out[0](hidden_states) + # dropout + hidden_states = attn.to_out[1](hidden_states) + + if input_ndim == 4: + hidden_states = hidden_states.transpose(-1, -2).reshape(batch_size, channel, height, width) + + if attn.residual_connection: + hidden_states = hidden_states + residual + + hidden_states = hidden_states / attn.rescale_output_factor + + return hidden_states + + ADDED_KV_ATTENTION_PROCESSORS = ( AttnAddedKVProcessor, SlicedAttnAddedKVProcessor, diff --git a/src/diffusers/models/autoencoders/dc_ae.py b/src/diffusers/models/autoencoders/dc_ae.py index 616a124f62e4..387356574867 100644 --- a/src/diffusers/models/autoencoders/dc_ae.py +++ b/src/diffusers/models/autoencoders/dc_ae.py @@ -21,9 +21,9 @@ from omegaconf import MISSING, OmegaConf from huggingface_hub import PyTorchModelHubMixin -from ..efficientvit_blocks.act import build_act -from ..efficientvit_blocks.norm import build_norm -from ..efficientvit_blocks.ops import ( +from .dc_ae_blocks.act import build_act +from .dc_ae_blocks.norm import build_norm +from .dc_ae_blocks.ops import ( ChannelDuplicatingPixelUnshuffleUpSampleLayer, ConvLayer, ConvPixelShuffleUpSampleLayer, @@ -47,7 +47,7 @@ class EncoderConfig: width_list: tuple[int, ...] = (128, 256, 512, 512, 1024, 1024) depth_list: tuple[int, ...] = (2, 2, 2, 2, 2, 2) block_type: Any = "ResBlock" - norm: str = "trms2d" + norm: str = "rms2d" act: str = "silu" downsample_block_type: str = "ConvPixelUnshuffle" downsample_match_channel: bool = True @@ -66,12 +66,12 @@ class DecoderConfig: width_list: tuple[int, ...] = (128, 256, 512, 512, 1024, 1024) depth_list: tuple[int, ...] = (2, 2, 2, 2, 2, 2) block_type: Any = "ResBlock" - norm: Any = "trms2d" + norm: Any = "rms2d" act: Any = "silu" upsample_block_type: str = "ConvPixelShuffle" upsample_match_channel: bool = True upsample_shortcut: str = "duplicating" - out_norm: str = "trms2d" + out_norm: str = "rms2d" out_act: str = "relu" @@ -458,7 +458,7 @@ def dc_ae_f32c32(name: str, pretrained_path: str) -> DCAEConfig: "encoder.width_list=[128,256,512,512,1024,1024] encoder.depth_list=[0,4,8,2,2,2] " "decoder.block_type=[ResBlock,ResBlock,ResBlock,EViT_GLU,EViT_GLU,EViT_GLU] " "decoder.width_list=[128,256,512,512,1024,1024] decoder.depth_list=[0,5,10,2,2,2] " - "decoder.norm=[bn2d,bn2d,bn2d,trms2d,trms2d,trms2d] decoder.act=[relu,relu,relu,silu,silu,silu]" + "decoder.norm=[bn2d,bn2d,bn2d,rms2d,rms2d,rms2d] decoder.act=[relu,relu,relu,silu,silu,silu]" ) elif name in ["dc-ae-f32c32-sana-1.0"]: cfg_str = ( @@ -469,7 +469,7 @@ def dc_ae_f32c32(name: str, pretrained_path: str) -> DCAEConfig: "decoder.block_type=[ResBlock,ResBlock,ResBlock,EViTS5_GLU,EViTS5_GLU,EViTS5_GLU] " "decoder.width_list=[128,256,512,512,1024,1024] decoder.depth_list=[3,3,3,3,3,3] " "decoder.upsample_block_type=InterpolateConv " - "decoder.norm=trms2d decoder.act=silu" + "decoder.norm=rms2d decoder.act=silu" ) else: raise NotImplementedError @@ -487,7 +487,7 @@ def dc_ae_f64c128(name: str, pretrained_path: Optional[str] = None) -> DCAEConfi "encoder.width_list=[128,256,512,512,1024,1024,2048] encoder.depth_list=[0,4,8,2,2,2,2] " "decoder.block_type=[ResBlock,ResBlock,ResBlock,EViT_GLU,EViT_GLU,EViT_GLU,EViT_GLU] " "decoder.width_list=[128,256,512,512,1024,1024,2048] decoder.depth_list=[0,5,10,2,2,2,2] " - "decoder.norm=[bn2d,bn2d,bn2d,trms2d,trms2d,trms2d,trms2d] decoder.act=[relu,relu,relu,silu,silu,silu,silu]" + "decoder.norm=[bn2d,bn2d,bn2d,rms2d,rms2d,rms2d,rms2d] decoder.act=[relu,relu,relu,silu,silu,silu,silu]" ) else: raise NotImplementedError @@ -505,7 +505,7 @@ def dc_ae_f128c512(name: str, pretrained_path: Optional[str] = None) -> DCAEConf "encoder.width_list=[128,256,512,512,1024,1024,2048,2048] encoder.depth_list=[0,4,8,2,2,2,2,2] " "decoder.block_type=[ResBlock,ResBlock,ResBlock,EViT_GLU,EViT_GLU,EViT_GLU,EViT_GLU,EViT_GLU] " "decoder.width_list=[128,256,512,512,1024,1024,2048,2048] decoder.depth_list=[0,5,10,2,2,2,2,2] " - "decoder.norm=[bn2d,bn2d,bn2d,trms2d,trms2d,trms2d,trms2d,trms2d] decoder.act=[relu,relu,relu,silu,silu,silu,silu,silu]" + "decoder.norm=[bn2d,bn2d,bn2d,rms2d,rms2d,rms2d,rms2d,rms2d] decoder.act=[relu,relu,relu,silu,silu,silu,silu,silu]" ) else: raise NotImplementedError @@ -540,3 +540,35 @@ class DCAE_HF(DCAE, PyTorchModelHubMixin): def __init__(self, model_name: str): cfg = create_dc_ae_model_cfg(model_name) DCAE.__init__(self, cfg) + + +def main(): + dc_ae_f32c32_sana = DCAE_HF.from_pretrained("mit-han-lab/dc-ae-f32c32-sana-1.0") + + from PIL import Image + import torch + import torchvision.transforms as transforms + from torchvision.utils import save_image + + device = torch.device("cuda") + dc_ae_f32c32_sana = dc_ae_f32c32_sana.to(device).eval() + + transform = transforms.Compose([ + transforms.ToTensor(), + transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), + ]) + image = Image.open("/home/junyuc/workspace/code/efficientvit/assets/fig/girl.png") + x = transform(image)[None].to(device) + latent = dc_ae_f32c32_sana.encode(x) + print(latent.shape) + + # decode + y = dc_ae_f32c32_sana.decode(latent) + save_image(y * 0.5 + 0.5, "demo_dc_ae.png") + +if __name__ == "__main__": + main() + +""" +python -m src.diffusers.models.autoencoders.dc_ae +""" \ No newline at end of file diff --git a/src/diffusers/models/efficientvit_blocks/act.py b/src/diffusers/models/autoencoders/dc_ae_blocks/act.py similarity index 100% rename from src/diffusers/models/efficientvit_blocks/act.py rename to src/diffusers/models/autoencoders/dc_ae_blocks/act.py diff --git a/src/diffusers/models/efficientvit_blocks/norm.py b/src/diffusers/models/autoencoders/dc_ae_blocks/norm.py similarity index 78% rename from src/diffusers/models/efficientvit_blocks/norm.py rename to src/diffusers/models/autoencoders/dc_ae_blocks/norm.py index 583ecbfc8bf0..cd3dc85a227a 100644 --- a/src/diffusers/models/efficientvit_blocks/norm.py +++ b/src/diffusers/models/autoencoders/dc_ae_blocks/norm.py @@ -4,10 +4,9 @@ import torch.nn as nn from torch.nn.modules.batchnorm import _BatchNorm -from .triton_rms_norm import TritonRMSNorm2dFunc from .utils.network import build_kwargs_from_config -__all__ = ["LayerNorm2d", "TritonRMSNorm2d", "build_norm", "set_norm_eps"] +__all__ = ["LayerNorm2d", "RMSNorm2d", "build_norm", "set_norm_eps"] class LayerNorm2d(nn.LayerNorm): @@ -19,22 +18,24 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: return out -class TritonRMSNorm2d(nn.LayerNorm): +class RMSNorm2d(nn.LayerNorm): def forward(self, x: torch.Tensor) -> torch.Tensor: - return TritonRMSNorm2dFunc.apply(x, self.weight, self.bias, self.eps) - + x = x / torch.sqrt(torch.square(x).mean(dim=1, keepdim=True) + self.eps) + if self.elementwise_affine: + x = x * self.weight.view(1, -1, 1, 1) + self.bias.view(1, -1, 1, 1) + return x # register normalization function here REGISTERED_NORM_DICT: dict[str, type] = { "bn2d": nn.BatchNorm2d, "ln": nn.LayerNorm, "ln2d": LayerNorm2d, - "trms2d": TritonRMSNorm2d, + "rms2d": RMSNorm2d, } def build_norm(name="bn2d", num_features=None, **kwargs) -> Optional[nn.Module]: - if name in ["ln", "ln2d", "trms2d"]: + if name in ["ln", "ln2d", "rms2d"]: kwargs["normalized_shape"] = num_features else: kwargs["num_features"] = num_features diff --git a/src/diffusers/models/efficientvit_blocks/ops.py b/src/diffusers/models/autoencoders/dc_ae_blocks/ops.py similarity index 100% rename from src/diffusers/models/efficientvit_blocks/ops.py rename to src/diffusers/models/autoencoders/dc_ae_blocks/ops.py diff --git a/src/diffusers/models/efficientvit_blocks/utils/list.py b/src/diffusers/models/autoencoders/dc_ae_blocks/utils/list.py similarity index 100% rename from src/diffusers/models/efficientvit_blocks/utils/list.py rename to src/diffusers/models/autoencoders/dc_ae_blocks/utils/list.py diff --git a/src/diffusers/models/efficientvit_blocks/utils/network.py b/src/diffusers/models/autoencoders/dc_ae_blocks/utils/network.py similarity index 100% rename from src/diffusers/models/efficientvit_blocks/utils/network.py rename to src/diffusers/models/autoencoders/dc_ae_blocks/utils/network.py diff --git a/src/diffusers/models/efficientvit_blocks/triton_rms_norm.py b/src/diffusers/models/efficientvit_blocks/triton_rms_norm.py deleted file mode 100644 index e6a3ca76a12a..000000000000 --- a/src/diffusers/models/efficientvit_blocks/triton_rms_norm.py +++ /dev/null @@ -1,191 +0,0 @@ -import torch -import triton -import triton.language as tl - -__all__ = ["TritonRMSNorm2dFunc"] - - -@triton.jit -def _rms_norm_2d_fwd_fused( - X, # pointer to the input - Y, # pointer to the output - W, # pointer to the weights - B, # pointer to the biases - Rrms, # pointer to the 1/rms - M, - C, - N, - num_blocks, # number of columns in X - eps, # epsilon to avoid division by zero - BLOCK_SIZE: tl.constexpr, -): - # Map the program id to the row of X and Y it should compute. - m_n = tl.program_id(0) - m, n = m_n // num_blocks, m_n % num_blocks - - Y += m * C * N - X += m * C * N - # Compute mean - - cols = n * BLOCK_SIZE + tl.arange(0, BLOCK_SIZE) - mask = cols < N - - x_sum_square = tl.zeros([BLOCK_SIZE], dtype=tl.float32) - for off in range(0, C): - x = tl.load(X + off * N + cols, mask=mask, other=0.0).to(tl.float32) - x_sum_square += x * x - mean_square = x_sum_square / C - rrms = 1 / tl.sqrt(mean_square + eps) - # Write rstd - tl.store(Rrms + m * N + cols, rrms, mask=mask) - # Normalize and apply linear transformation - for off in range(0, C): - pos = off * N + cols - w = tl.load(W + off) - b = tl.load(B + off) - x = tl.load(X + pos, mask=mask, other=0.0).to(tl.float32) - x_hat = x * rrms - y = x_hat * w + b - # Write output - tl.store(Y + pos, y, mask=mask) - - -@triton.jit -def _rms_norm_2d_bwd_dx_fused( - DX, # pointer to the input gradient - DY, # pointer to the output gradient - DW, # pointer to the partial sum of weights gradient - DB, # pointer to the partial sum of biases gradient - X, # pointer to the input - W, # pointer to the weights - B, # pointer to the biases - Rrms, # pointer to the 1/rms - M, - C, - N, # number of columns in X - num_blocks, - eps, # epsilon to avoid division by zero - GROUP_SIZE_M: tl.constexpr, - BLOCK_SIZE: tl.constexpr, - BLOCK_SIZE_C: tl.constexpr, -): - # Map the program id to the elements of X, DX, and DY it should compute. - m_n = tl.program_id(0) - m, n = m_n // num_blocks, m_n % num_blocks - X += m * C * N - DY += m * C * N - DX += m * C * N - Rrms += m * N - - cols = n * BLOCK_SIZE + tl.arange(0, BLOCK_SIZE) - mask = cols < N - # Offset locks and weights/biases gradient pointer for parallel reduction - DW = DW + m_n * C - DB = DB + m_n * C - rrms = tl.load(Rrms + cols, mask=mask, other=1) - # Load data to SRAM - c1 = tl.zeros([BLOCK_SIZE], dtype=tl.float32) - for off in range(0, C): - pos = off * N + cols - x = tl.load(X + pos, mask=mask, other=0).to(tl.float32) - dy = tl.load(DY + pos, mask=mask, other=0).to(tl.float32) - w = tl.load(W + off).to(tl.float32) - # Compute dx - xhat = x * rrms - wdy = w * dy - xhat = tl.where(mask, xhat, 0.0) - wdy = tl.where(mask, wdy, 0.0) - c1 += xhat * wdy - # Accumulate partial sums for dw/db - tl.store(DW + off, tl.sum((dy * xhat).to(w.dtype), axis=0)) - tl.store(DB + off, tl.sum(dy.to(w.dtype), axis=0)) - - c1 /= C - for off in range(0, C): - pos = off * N + cols - x = tl.load(X + pos, mask=mask, other=0).to(tl.float32) - dy = tl.load(DY + pos, mask=mask, other=0).to(tl.float32) - w = tl.load(W + off).to(tl.float32) - xhat = x * rrms - wdy = w * dy - dx = (wdy - (xhat * c1)) * rrms - # Write dx - tl.store(DX + pos, dx, mask=mask) - - -class TritonRMSNorm2dFunc(torch.autograd.Function): - @staticmethod - def forward(ctx, x, weight, bias, eps): - # allocate output - y = torch.empty_like(x) - # reshape input data into 2D tensor - x_arg = x.reshape(x.shape[0], x.shape[1], -1) - M, C, N = x_arg.shape - rrms = torch.empty((M, N), dtype=torch.float32, device="cuda") - # Less than 64KB per feature: enqueue fused kernel - BLOCK_SIZE = 256 - num_blocks = triton.cdiv(N, BLOCK_SIZE) - num_warps = 8 - # enqueue kernel - _rms_norm_2d_fwd_fused[(M * num_blocks,)]( # - x_arg, - y, - weight, - bias, - rrms, # - M, - C, - N, - num_blocks, - eps, # - BLOCK_SIZE=BLOCK_SIZE, - num_warps=num_warps, - num_ctas=1, - ) - ctx.save_for_backward(x, weight, bias, rrms) - ctx.BLOCK_SIZE = BLOCK_SIZE - ctx.num_blocks = num_blocks - ctx.num_warps = num_warps - ctx.eps = eps - return y - - @staticmethod - def backward(ctx, dy): - x, w, b, rrms = ctx.saved_tensors - num_blocks = ctx.num_blocks - - x_arg = x.reshape(x.shape[0], x.shape[1], -1) - M, C, N = x_arg.shape - # GROUP_SIZE_M = 64 - GROUP_SIZE_M = M * num_blocks - # allocate output - _dw = torch.empty((GROUP_SIZE_M, C), dtype=x.dtype, device=w.device) - _db = torch.empty((GROUP_SIZE_M, C), dtype=x.dtype, device=w.device) - dw = torch.empty((C,), dtype=w.dtype, device=w.device) - db = torch.empty((C,), dtype=w.dtype, device=w.device) - dx = torch.empty_like(dy) - # enqueue kernel using forward pass heuristics - # also compute partial sums for DW and DB - # print(f"M={M}, num_blocks={num_blocks}, dx={dx.shape}, dy={dy.shape}, _dw={_dw.shape}, _db={_db.shape}, x={x.shape}, w={w.shape}, b={b.shape}, m={m.shape}, v={v.shape}, M={M}, C={C}, N={N}") - _rms_norm_2d_bwd_dx_fused[(M * num_blocks,)]( # - dx, - dy, - _dw, - _db, - x, - w, - b, - rrms, # - M, - C, - N, - num_blocks, - ctx.eps, # - BLOCK_SIZE=ctx.BLOCK_SIZE, - GROUP_SIZE_M=GROUP_SIZE_M, # - BLOCK_SIZE_C=triton.next_power_of_2(C), - num_warps=ctx.num_warps, - ) - dw = _dw.sum(dim=0) - db = _db.sum(dim=0) - return dx, dw, db, None From 3a44fa4cf306ac81cfc9cc4f86a47df835230acd Mon Sep 17 00:00:00 2001 From: junsongc Date: Wed, 23 Oct 2024 16:08:52 +0800 Subject: [PATCH 004/141] 1. rename file and remove un-used codes; --- .../{dc_ae.py => autoencoder_DCAE.py} | 32 ------------------- 1 file changed, 32 deletions(-) rename src/diffusers/models/autoencoders/{dc_ae.py => autoencoder_DCAE.py} (96%) diff --git a/src/diffusers/models/autoencoders/dc_ae.py b/src/diffusers/models/autoencoders/autoencoder_DCAE.py similarity index 96% rename from src/diffusers/models/autoencoders/dc_ae.py rename to src/diffusers/models/autoencoders/autoencoder_DCAE.py index 387356574867..0513f76dc736 100644 --- a/src/diffusers/models/autoencoders/dc_ae.py +++ b/src/diffusers/models/autoencoders/autoencoder_DCAE.py @@ -540,35 +540,3 @@ class DCAE_HF(DCAE, PyTorchModelHubMixin): def __init__(self, model_name: str): cfg = create_dc_ae_model_cfg(model_name) DCAE.__init__(self, cfg) - - -def main(): - dc_ae_f32c32_sana = DCAE_HF.from_pretrained("mit-han-lab/dc-ae-f32c32-sana-1.0") - - from PIL import Image - import torch - import torchvision.transforms as transforms - from torchvision.utils import save_image - - device = torch.device("cuda") - dc_ae_f32c32_sana = dc_ae_f32c32_sana.to(device).eval() - - transform = transforms.Compose([ - transforms.ToTensor(), - transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), - ]) - image = Image.open("/home/junyuc/workspace/code/efficientvit/assets/fig/girl.png") - x = transform(image)[None].to(device) - latent = dc_ae_f32c32_sana.encode(x) - print(latent.shape) - - # decode - y = dc_ae_f32c32_sana.decode(latent) - save_image(y * 0.5 + 0.5, "demo_dc_ae.png") - -if __name__ == "__main__": - main() - -""" -python -m src.diffusers.models.autoencoders.dc_ae -""" \ No newline at end of file From 55b2615dd4f4822ffd487f606c09abe8895b5344 Mon Sep 17 00:00:00 2001 From: Junyu Chen Date: Thu, 24 Oct 2024 20:48:26 -0700 Subject: [PATCH 005/141] no longer rely on omegaconf and dataclass --- demo_dc_ae.png | Bin 1140382 -> 0 bytes src/diffusers/models/attention_processor.py | 4 - src/diffusers/models/autoencoders/dc_ae.py | 398 +++++++++----------- 3 files changed, 184 insertions(+), 218 deletions(-) delete mode 100644 demo_dc_ae.png diff --git a/demo_dc_ae.png b/demo_dc_ae.png deleted file mode 100644 index f7428ea009a7e74b5344568d98cf07a3bd680c97..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1140382 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 z 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�sE2hU-YjHco2#Mv;gb^CS9h#Bw8p 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 z zKl$Uo+>LL?LtHF+L4N=CX1!i)Z|?7|Zo9s-*4#3C?^mmSoTm^C0EQSXnZQvqwEzLY z8i|qFa1=|_^&NqYAQl)Ihvj0wdmw9sW!z89GAxGO?Y>)f9Afm0Br)(|w+pkk{c5oN z6yy227m23BFpa`6SQky)?QZt>cim=Td$+wC*B6_i>!@^qpbT? zx3K^8i(d}IfaK=GNCM8edEEQyfQEp;dsr=(UDvVaah^GZVHgAufjEjC@*Z%qh7bY> zIRuloserXs2;%Gom7mwj*(dcgD}SkF$w@naWj|b_wQTd6;R0cD3IocfAJ%EH9~ot zG;*+UOseJIBEJf~+Xes{=U3CJ-g?|usgH?@`-+5AeSG*F)DD(EGiIs&#_ATWP$NsZ zEW4_XYu{Pqam773<+H*YKy1-JVhWZc)#7owOQ38lzyhEe6jZ;elDXI;h2~hc4Wd#% z0Xo3~Wa_wdwAtMwP0F~4zDtLzxo4V)L9I(#nwHB93RJh5>f;)=DUeq8>=gi)wy>i* zno|agR!*%1NtB?Poeqls^WH;EJrYNFE?|F=s^Oy;ZQ_CnA8XX zO;h1?IBWqzMFl7IYXPY2d6dGj*#44#5z@LgpV z-2nB!%PCf)wp!l@_8IS2~Pb zRpn@zRw7UlaTSM2+u)J3Q34m2gp@gwB2=~XRdoYHZczCR%34xRQ=U7@#KYQyV_8@P zD3;06ekTiG&CYVyF?v?(qH>Vr4ohXsy3X_M$`obJlKZ^2tCn#UL*?E2pT0q-pm38S zTC7u5yH|I)n&FB&fTx(n1!@R=DW4 zWrGk=^n6XgoEDh}n^SC2M^Z>##9;0+7S+R&>d#c(D}m4|E>%WW%6giZ4!k3L%Qf3tkWtz2E+DsRdm!)iS zK@gBs%tzlqM8beX!qFtZOcW3~KfhQk7q@r!uV23*1Y;0HjG1&4=CLz~g4KnfJ0jTR(qt`kP<>>fim_f9IT=_LJ*|yWRWK^Hp!m zFm!KUUw`!c*~R7M_Vx}|i;Jfh*H_npz3Udh@Z#IoU;Oa%ujX-of9MyEL+}zoz;tGw z{eIjzdvba9`MWpQn{|J4f3xTZ_B`$Pu5$)~EZp4u&h}<~x_tHW)%s+0MOPv4V!7Df zZx^e@`IEC@(am#MECN6TW}asduoe*^#uSSu0l~;1kx(W-3W@C;$AE~3aqc?noK1R_ zLH7GYKN#>qz!P-dPp%t64AWtprwIub!@ypa4h6V(W}L>uezFe5Nc4y8?Jah6a<&@p z=C11(-C`aOD01`eilgrq{kWTBWF#>J7f(*Vd-FQ_SsY35F$#6VxZ6*DFGeh&L>Yzw z4IOp|0qlBXY`0}zQWQ^aa272gxXu#7JkNbU7-PG>>s$vSB)}oY$RYSS1_VT8LNvxf zuGx=<45U)DEX*Dv#2AC0B?gWx034umJ)=tjrj9I$AX48sG-!-X25k(UL-cd>ftgji zfdI2HLP+PEp}2_jZMv;qOc3_PckWkPgTkU1-loV4Y}Z0wG9$B zN{wapA*xS{02YDd+D538ka341Agm*4Ab!yqSXwL5cpY?ZL3A7qowQv{uLGz`Mc7+2r`3L`;F zdp2yAHFWl1O3}{gT%S}foS8*{ImMvU8I;T{DNC1FAcX;v_Tg;OB=aGk{E#*UXT=Gn zzy%;!je)o7KUXrzQSWT0NS-%rZq2=h<4;4=Jd4F1s0LISzAlE$bJ=ZIa{+b#V#5%1 zEv4;%3SO~sawmo?h6}25zcHv2o{+Y~qN@TkKbGD>@p%L20@1}Ix|2g0yX+&ZbDVzr zfaf%IsUW8ok(B6Pd9Y9w9}%v`Da#G|8qvaA*h=5r_vVj+)boqwh%%2}3o5Hi=TRlU z3TCL!V?(t3bamp2$DVHk~N~>+gygkRV8k;9HoK_`UYPR9S zMiPN?biPS)fZ&)QS=hEl5vFoog?ic2Pn?#H85WV8`IC023j+~AKKW0C0k9IK3`9zb zTN-nnqbfJ0ng9IOBI~p1qaDuoKqHkZBNWCu)_hgV9nX@k;>Xhmx^}+ji{o~sY|JeS zFbz|x#4L;R_cVef!dTQu83{9&UL!)0(dnfnY$uvrdtV_@sd?0t`TcXPj7_lE3pF`TSc({Atm zwBKG&o__FWfBuVK{O0=R`j7wkPk;Vj{!7;n=cnh}!+x54zvywE-@bhH{IicvF1~p6 z^^1G6`~1r<-(SBE^K4!3y$?QItWMreG5F}5o8|~69c<3;-oL##J729f*Y4&pPE%la z(fi1DoS6)wIrwQiZea%>e|dJY+1%XSo}6s%uI~DU8K*EGrg3*zEEf#C-yb^Xf-oR* zOvFY600IdNj9@SdhbZIZiHt?#eMDwvKHY2}aPVv_KmZg5F!MBbt{eCB>E+pBdkFJ< zdwa(stFyHgI{`b_`N^LSo11ZT&X7b2GS9OR4$I~CZYvQNy&DfZK%Dpc!~Wm~iwJ1R zm=Gua=<|;b^ZfqJdpC5mpZl(-4))`NpJu^m$x38vdt;pdO-PzC+5t*(Z zI%6y$pfMrxV!a#|i>~h}xu0ST-cQpM=NOsAh_%l3eP_rRheXC&K#U?1Vhn)@w z5KALaq4*6!fsty}f|=7|RD+=W*If8efGAi{iPd5lC?czfx%Bm;D1Gz$2b$^7xf7}-)Ov$ehZXQGB3!cO zB!m8>`7%mQR}!wzmHAkhAu@A}3?dB741&zUF&*%$CrT!WAOOJmP%VYTHk%$;)@ELY ziJp>`bUTlk)#|2z>h^DzY5h$p0!lFfNWQORi~>S)Jax;Tshn7`7ZA(MdBrFY06hpy zSBs{AVYbmS#4OlMIj_S1^i^ZD>c!-~1xZ4!SOAIh%2@!_EvmyjTFn|KfZ~`JU6D{h zO|=h>g%g$~4xpySF-nEp`{Lm&{W!k2;N@~x?n(jEQbvc>W)RIatV>5lv(B};`HMWu z4(LjWIx;-!lY*_bRrsDKOUunXH{v9d0F`8=n`$C86NHs)N?=9%$Ea2(E32`xYKvrR zW*UxP(1dz0jHT&|l(rM$ zOB6FH->hd-o(xk`Gin`FrKUr#5tU?}=!#Sg+Y0N_fwI7|U};?L&7O*X;iJN%FtmE^ z6H?9#zGR#pcR}C&d*4z}K_ih-hn*d2!i0HdMCoIUN%zMX5hT^=IlDYxuh(y1z4h~C ztr0*y*B1dGhA4(aDW7Bq6xKpS0W!J1Co==EHMSr6$Q)yWv=9Wy5E|qlJO^fWoy(Yu z&^Zf`^Fpn)9GO`RApo;502zzPp>)_EoOAbg5B<=O^E9~b;^N7CnC3VdM_;{q`IA5X z@<0FQ|NMXb@Bc5aUcbD$zJB`boTL2a?d^Kq8$^%%{?+^EpMCoA=bycO@!iA2{bsqk zndiu%GxYY&+b7ST^!x2NvUARM!A~Bk17Uxd_WS+fWHl^?c|VT((L9s;+ueGz+28Ni zXDf*D>fP;=v&;Q~YP2>?B;H_Lg7KqxFx#5uI&7{S<%j9sp~&RJ#& zqeqGyW!&x~#}K^$AW>&Jh{-Or#sLy=j3LCdnLP<<1H>SJ6orYbA>#%@0AO~;x}k^2 z76B1W%1lG%5Lr0J7=2`pB0>N_MmRE-17(Yw6d)!qSveg{Wu}0t*CLIpkjF+PHF*ce zC_9V2lB-abwO-7D#wOVK{gOa^p#rLKj`J$N_bEBnH%V+9b*}u7rdN+%{PyFrkk6y-Q`y*YPMz5j}iv^P|DXQE1`4D~C7Lo9Cu#ry>g7Xe*C z7l5i)Xl~QNVi^h?!N&##RQ;>~N1e2i4!%{*sm~>j!jflH^;L})CCm+y>kz7EN3pxY z{PHg);^b6w!d$VfWJYC9FEFa5Nx=-5N8I?+DmSN8%>v9S*ayg|K=s3^8hEl1m^m_w z#b5$Xd)}77Ipf+399+VEW zaII~q(!7$Z%%-kM?LX>7>(WymfVwy^HRO@(csk|_6?R9il;b8IeN$mN)=^YR zP@XLYSv7N@=Q!8u1iHy>9nuW+Di31=+ zlr(^V2r_`AIt=29B4bL-KW%Ir;BaD<=GK=soMt}WowHk)?rUQEM?aQD1^oMBiXMg{*zxwxo^`HK~|MBj2`{@rpesX`Y z+ur&Ji_OaK$A|m7^QULSX8q>P+p{Mp!g2PzzC69YzFTcpmlqeWzk4&!bKhGLK8(}Q zb=z^gyT9v)zH^qH*&e3DVKx@8uiu}aZ1%gcU#`c8dylfcy?yrl^2LkaE&E};Sl-^< zyAG|RaXb($Hcytf@9$jiqCkkz7=wt&vfmy|XL!$1g6*B3!_YZD2edTwCh{yCtuYI; zdVBv0El8B@?yx>vNe}=GKA6Q2rrBDzAAP^+sI!~R`m2Bb`m-N=dAL6;m&1N{01!i6 zWbb8q*xv1TTOzW~2(Ynq*zI-?4?xi{F%ya(1`3n;!H<9V>fM{$yPM5w(iSs

#Q}#T5F9(V+n~P2jPfdAsrHcUEdKPfgp$ji-6V{5+M;_@qU)bWYHie5fM4W zIY6=_ybrS%0Tf0P&RcU zmc72U-PS*O^wswYnN~C%e=>S&M0(T85q51Z7dRpHm+yHev}rApmv9oVScJI3V9YLE zbrI!}wX!~gq( z)02)NLH$7aS0txLw=~K19+L8sY=a~?S&)LLj^>Q%^Ht8_F#!=~t^JpZ0J3n*8ACBL z3&a?OA#E57KEx;yBQoZKfdnYRdL)un&;yX8(u&54UT$Z(q(~`SwW?OiimTjGU@t1S zWai7(QofMcF0TYsj9(j*M8Bhp`5Qgo4(n@_wKEE2CO9nZ-j z6)NPP>3dR?T;Q_iXHmqbji#)Mms74Na=o{a8@yG&~Yf zs1ud$ZIE+?Q>_rux3%$$@?a%Rd7`~kU|H>%)Vp-s1r)rPi;iY++?XKvsI8pcS15@k zU%%-MDqoe}X?Bmgq>8ywh@Lj9NQx@zKoB9-` zswwsk021hS7nLoP%05zrn7U3`X4M_bh|Lfc)@RF2%D_b>iKxoK>&7 zljfH?@oII{ss{}plqCE|n?zK4!2i~d3is5d#3$`u1_+tiI*SOABLF%u&KY5eoX>0p1deQ-wT1+VnXSdh zA~8OMX%VgIj3H!}=pzw|K;JtM0+blT;V>OW|LI4ce*DSi_U+A=AAR!eufKi%Po?o7lh3PN>3pot9-Q8_%hlg>GA$ksgc)D4>-j5e61QB7mzrJG*CySHo_gl8T z8@jj~!N9aXxULTze3%aV?e5_LAd>0)6gDT_JdWdjXB=`w*Y`Hrh$LV9@N+cq)vtbY za9cQA!|A}7_!D0Lu9N21Ve@pg9JmiGl<4mB0{p(07q*G0f`_nq(w-@4*^Le zq9AZcp8gP{h)9qanOV>fMv00@g@FLUWa~MZ0nD6Fpc54@P0miz(16)cXhivAanlHl z=C3TY8s}C`YnCHX(8#G{=ge_yrK9zQ?UO|k0ivGSTCY{XlK%Zrvf=lOyS&X*LC%q- zB3O!VqC!Zms#yVj+PT~8k0jkj3{bRL@tPIaR--6DAydX@8Jl5&R*Jq=($+uAAL?Bt zC7ia8ker`du>C`-=4EVJsHyQmq9hyug1ARiR+6~!SDDV@Mo|OQ{*h{kwYW6>3E_WdXD2RYY0}z0j zAw_bt4Ui)P9ECMQh$YvGNDd%&HbxGSBgYV9j4V;I`OSg=7MjJ-FkQm^Qou_7zT%6@ zo)xzpu{r7lfv$vNcU5R8Ao;{v4UuFlUNA(O&$KzEEaV1}E9}a%kD0c4sfdW0I)Hhf zaQl}0i`0cyCn^6?YZznUxF#hgw^N{BonUO~2@RYs3H>_#jT08y=PL>;X$rMLHEp2D zchk2vLMqR$_PM-E3T!SnV_rf{OBE63d$IOSTW&$(w~+=7&bsXllE@p*jTAQm=-U_B1txP2&o91))xvUPq;#x*xF7a{1PD zTvy)FD``+FaV5nT@^GXQrs0TORt(Cc`Ee?IpMu?lngrJ@OR4ES`4uWGl|gH&ecNrN z6ckO-gvrVrD>Fcom84%+eRw<~{p(S>?FXO6M#vITGYiuI(t*2$$RNckNWxx647zV! z+ftte0;H4JxU3N*DlcYc!hAei#@VR@gnka2lg(lnuHIcSur)Rc5Fke}lx1`h{vpI% z2nbL_h=`NZUbmMKB1aLyX&jyHh)nVVAyJH+pue?7M51Q_LEu9O&ZVM2##oa#B!C1T zBeAhYRL&UZE~w`aJxA}Q?>py+h=k+rVeC3*oDm6(goeKT_Qj{4Jd4cFKYhMC%)k7{ zU*8`N|L6bi|MoxrkN=PFzWMHt|Ll*x``yd!-Tk;dbn8Xmxi>H0tTrci*SAQxTAl26 z4+be3yt;Zg*_@7tAi!je!!Ae^iO$*E+q2(F&WkSiI0X+|WHC=ae)jcO zU#;9?dAcwN>*eBb7|9Yuj*$hCg&(#rhGlnmd%ryC4u^5IwBEC^=CB`^ZV@?jb_mmK zmg~cA4>a{dCqeu?6A7Xj50m#{7zRK4aT@#Hf>382h;*)-r^z#O@Bw1C9PaOSPoJIp zLm+`^oPv+G=XsuE@VouaT4F(GZMW(e;jr5QiZvt%292QjX}UOna`E)}-~Zz0!*Uo8 z({kDMWOodOa+bi_;Z}iNS}+<8Et>4c;?= zvD6votRTVvAMgt_idB#@X)j^wS3963v#yy8mniez9H)B!~?sfb2I zt{Fl{{(`dTiv}+jQB_7+=28R@9*d|)jXjn-*a)9vfnJ~fP<+V;*YUVPeDtI!q;CI4 z1Z++uZ0}KTl&H6~#sxrxN_llrVU;DpQH}%Z#YTgw8y-Ma_K~wPqb5wLMpA%C1Fu2T zU609xP|}=p3>_OA1{ye-(ygm1%zeY-`ArZnRXAv3GkGKmc*^4qfJqgY2@%nx^r9FiHpHm3tcYnUa(=!8RvF>(wXV&uro97BL)02JqaK@nyB z9YYAs@~JF*bTbstp;KAVG%6(1h7gX}Bim7rjid&Vr9YFRK4#y7f}s9=d~<1EVVbf} z?jw~oR^O<9)k$h?Uo19AhJVrw50#Be-!dT!U?~F-_~0>Aa9;aSnYtkk==x}F;POpF z+!jA(p^^Eo2wLr)&P{$LDyGGz(-{*NO4s)5JT%5y)1oeKthis7eU(T}k96iLv{Q0c zb1Ow|^bHLq>rjp;S*Ny0rNRx>{L5})ET&}EC3PR^G0C;x`Gq+*4%M{Cdssy$MgR$r z5ppn>khqxOZOhpwq*Z~c^hZp731$_zWkxl^PzI{-FY$-+X6nvO^dc(3)gEBOnpQ7>!B6nxrgJcmXIK z2o9K>H-u=d1w`wt_a0H4r4S-Q-X9!%07TbyT}Lc}2oBK4fFLnORYC{|5;=qz=HNOv zd$!i3^OH?CEUXC}IY!rae)2@-^mOAxu$Iu!JkFctAP&C$_PfiA^MC&5U;nGW__J?* z`OVGCxBtW4|M0K>{HMSD<*%;Zygz?>)^+ao_GX^uAn^3#Cl3#M6uNzX|MatGD>{u~ z;xOIaU3J~F)pFq_#&Hf5tr#CrNVfNPPo7@7p_2!3Mz-U@SiHZz`}mXRcURYEKmM|F z?tXiHHm+k}B67~{1P{~PIb#sLkGtLB>~s|(#}L>Uff%DFvY0Z>MZl!(Zqd*4&@Bv- zFq0({2_S68kwge_KFod!o6}YBV*AB72V(?8;yfeDVpw$Oi0R46`ugf&bFvOTutbhA zOaVCZ?4ysibBpB=gY0)(07he-!Ep}WdjTM@U;Nvl03uNc z-SWu-JbLdfb<5RibFz*MUDvNp)?L>L0FPn!uniK7BV%#)v-f`JJ4PTR0r3(M0nr#| zNe~Hx4-7~IF$TbNNE300lmK^>&bcTUI9ftvbU=oLKoF22WgwtXURi>WP6uQWi4i2G zDkX>{nEawlgu<8xl`4=31G69yaDcSKGA#}DFhR23HAPu6S}4x1Tn)Pj3n{Xo$cCgb ziezfORUz++Jqj5<>qjoQe*1{yr>o@B9(08)GcdB|0f zHHGrA);2GiE@{>#^&d0jD8E2K>IrX^pf}bRK~^;M2w!12gjaK0Fy~PmN67OV3u00- z=67k}Hut*}SIDoCBP>-wSDNASddOnBpe+4GTH@yi@=T^}66xq`V=}ByKZs0{p9Snw zPW~Y(A%cYdk#fz?OfroFWRmJo>K=j0KiJ@zqT^b&QJs}<5xu0z{|WIkfGHQ5g&D*! zr=rg+k%fg*fR05%q`+*5m?c`~91Y;;DF(KMvE`8#&g@&)Oyzt9dD0LUq`_(x1QdFJ zq+Qi%jzKgFUK3%}bKD^H#P8{)St6uLDVZ@^gwSG=cI`GxSjzT=#Hds|dW3!IoywsA zdTw6LA2@<11%M(}a~2x0kP%E_hNj;L8J9HP^bZ4vk0r^Y(bYd1G=Jo@1$AcY#kOPV zw zD<8)gAAedi4+?XBaMSTC1Q;Z3lSt20@BWcH=(sd%Nd(h~m?%9|SgY%Z(=@BDOWF=% z6a#<=KJfYFMMw1Q*WdPo1BT$)S_0%4A`!7N7#RwIjVYcBM1&NwMUW80^@at6g+VBt z;z}4J2Oo_y0BZ3fg2-XF?fagLN#U!`I?eTm;DfP71Po!hrPei~` zrfIg$-0l2ku*SJ*@`%`VZvU`ftyfQ;p51NliQ(t}@o%4h{B&5HK0G}9{XhKu)5|Az z(fi4xqvxM~y1jcCx7*w6tJ90~^=f$W;^lWQUOszvL1J9jceZ=^_SMJFpKpd$*iT{H zBH_?k?>R`gzq>nGET?5Z`f1wjPEIx)^w^K_K`@h!Q0Rw#GPX(!R#s{s1TfjEHd#j$CKlZhPp5Zj8L$?}k-B z%`=GE-fx$doVEA<;r{Mn^zqZrPrRQOtFCtogzb8{_~ymS#bRN}O!IcJ7!K2HdutKn z>~HTLqQt&;9HRHa$kw`XJN@8CKfK%Se)rAS-CzjGqT3%vU>>?|W?pX=;}lR#2z+vS zx)>Huo<8jsOF&pGdmp3sGobi6Fv4;h-k_7iv`3KkYhly zmY4$(8e<3z5=8(Ju?lfO*jR%gwybCb0pZAiL`c9XE@bm6VPUe7qJ)&W5G6*)yq=}2 zF@yp{0z$%(Q?b>0ppE{9koIwAk(C51vwEGgZpO!QqmgGR7^-1fdHl5|kw^htS>d*V zQDdn`8sT616hW*dwaaBy_pQKDY5PILMM9Oz_9`B-uuVRTOek# zMzvsyb6TPQ5%|#-w9o3PPj{r#3l;b#3g$PKmw}YJ$ygGiYmP(XSV1UG@YWt`Y@aft zwW_9MA^?`jO>(-SF9I^~5uJztBo#<*kUtV(cKRc!B|wy%YXD@@u7KkH*D!DjPvqjD zhz;^DgG=X;>ujiY0>wqSq;*|!I^Lw2(!W}QGh+u%$|`RU$mpLX8{{kik(pUcOsD!W zgM=83Atw^kSsgyIk-%)2JrZKHsa#Nj1hqN|z>zszjNT&yE3d5dNCKR~EvObi&;yN* zn5<_-|1RpcdVWT ze5wcz6+>qk(DGkvov8TGyzv6Nis&k7kyh$@?kY%i0l6f1LI*;ndT%sLRSS z#j&EwqJZ^BU|uSri)?6QFcyRK_ZR`n=Xj*Rf6phgwg>>QFsf~WDf2rgQ#HD^yaH97 zq--dnJoUONk&rn{1l759^9T|Vvarm-UtC^VXWzYh-}M$mh{$z@V@#VpB6D3P2uR3L z(sqB6>`zLpL6}N(5=-ztbe$uBz<@wx1vpiu%a$Y&IqUo!h$0|bW34sD7yyZ!{I5yt z2mlHS86+~5tp%fx=#1@bG8WG^{Wyhqm<6#PI%gdl2{FV`R?F3Vm@UOc*WKLSot&La zhjFz&yT7^q`03^AH*j@z`{bkZ8-(5an}_TB%O|HFef;dz?_Rz9?#<@pq;q}08pwp3 zo7?jrUUrMcI3GAfa-9Po$MN>=?vqbH9>(qA?Y{52hlg>q9=3N6mlqe~e*5h5>2JUO zYFMo(0u!$m{q4=ovUh$S=MVt_81}n88blF;AOygHg&09N8jC3)@52hjqJJax|&XJ@B7L}x+R&mJv?ae6sl1zLRGt-v@U zL&hP1pJs}L2-bB0d>q9h80Qc`kev*Ok(rYq7h)ij{P+om$0W;ybGji2fJs%b0LfaL zILsminmPC=D8fi&SOO6+NQ7*7A&3a4tgT$-q$JAb;3FZDF(|+wAw*4s1Qte(0)8M4 z@NonH0YpR7P(}OqJX17-V$G5~gf+vn`eTn!B{a{%zaXWKzesN^?`?LTRUB1xXVKi* z3aAI6suvlLbNH?N2P(aG}MV4aw zpuz^tr%+5>UR{t|1ELU<^4FMqlOUjI4VyW_TA~IDEYlr#IdTPnLK$T!l`_^(Nj@g$ z_vfVlbOB4AKdF{AIS>t`MAR?vkU<$La z(p!@~Qod2k&n<|^+A-&uE4vpiDXSve`K4-pjVEdC|I|K~+d+UD#>E0J3qI41*X5y) zs?plMTa?iome))eOb`eQ-YpIT(U~mrpeAn}+tB%i8G1H}2YJ+3@2MlL7ES$#{+ote z<0_T*Qt#9blx0;vSUUra%xaAnk($3PZC9`X+4(||d}SLj%h8h8d8dHZ* z4S4}6hxtjui-5o^gq)lexg=RCn=ME{f?!dLY3K`z9w zV=Vfz5arQSsLfUMXSF3VyF6C4)og2C1G@j?=)T9(nwe0S@xSoVg8`26OmkijAx8lg zEXuQOzqXBlIay0U(so$Pg&I;B%~W?F8>)!HQ4kPG{1i@4P7vVc{gvx%N?<^s$Ptk^ zG9nTcw|(Y3p`6gqEM!#i3V@)WXC!Maq2P3whh^U{jGsdcoW+MhYi*2?nTg1f6%j(< z7$*+K8X{vm3xa<3BFv0P97eXzj{C!~?5#20hsAQiPC{fu*4P9W&|pZVX>Z0j9S*~? zHv|}>_wnRpJ?`eW?{A-f{`Bi_U!ATtUw!-4XPU-wlTZKT z4_^M}+c&>^v$)ti{rK7S)!kvg--WH8{TDy{a(n;q%{O0v`NJ>oZf@ORws*V5=@1TK zo`PZQyM9O=HQWFyWKnI7Mo4K=x(pCpFVv$K1{3CuyS4S-t{(xwgth*FxW1} z;5|yT5) zd)RMxrZk~3gi)fgDV?gE@nE->I0p&1`M5c3nL=g!=q5u;e zh=?O|-&^CDArKP+5iq2E!6cfVmNM_N=MocMCo}{?AY{de6Js!AQrKUfWR>#pd~~iON4~;I43DqZ1uE)`9n#g@*@egDj2K$(KVj|$+5yI zNTuuy%u+<1uy7=wJ}@XsC#1ghf77S!UyX7XH~^@bO6qLPC|^_#LvnpKBuJRMDBGm$ z2q2#!Q{9hPnw6A=MfDXrUd)>9XrC8AF;3t(-}xBhm2=5TT2FE3p^iiv&5Id!WF#z# zSky&ZKMMSgl*5q%$*Ml9K9mab5%NY}V~kOV59!ae^|u!MG)AKX2$}?x>cCD z(F#Rjj>OEyFbh~VA#k+Zxy}}7tN=m7c%XArn6}sjM?kOmHNW?oqSCyeQHg?OmMfow zk`U_u>bn|36^f_dQ$mp_k0!@n!*un3s*6k8y4Lb$5rhodO0UWYwD45{gi=A7M!b$7 z?;~_mpln%e4IEdY@S*p!x+oM7E0ljEog`0|_7IP}Bq~eGdkPw^GuN7Uwc+LrraU~I zyW(-Fb6(!wv{VF2dZ@~d`h1b)P5e)z#2*l{^sUNiZNHc(P~O=XjdcVi8eFgD{-X9P zdw*5t)|8Sw)jI!4Y*9%sRTqvNHC&zmLX4OX-bNurE+QjE^vIxcgyfnWO>$Hwrbu$J zrL#7316k8y+H6+`r=(5f#2Si_qSqlaue21X+^_6cWWChybP@gjiBgrPD)&gO98W+F z0sWqK+E0-d`SIdTArUba)1JdTC4_o_ny41acK#zPL|D|xLsDFpM8Zr&Q6z1)>bqfc zcJk`G*T!H7(GbND(P23mKg(O0R{#p zB#sdf2`NgPLR?tGDHYThNrhQ_bk-PSy3VEwLdF^*j*+{;?RE#WW@)?kciSiH)zEcm z<7NmU61dKVD2VX9w;`~P9%ostmt<%>Oi!L)PSf<=S1&IwPMFa!zJ2@l2S57!m;dn3 z7f(*-)pEQ&Y;Sje{#Sqg^;f^Wd39wMZnYfx&K`Dq!1(ILi;qA3^lEx|{qprEpMCn~ z-P?XOjJwHM!}ECX`^{>z-yggWK6-2W7~0Ie3K75W)|T&%t!(t)}RQ0VLy+E*mpfz^!s2fMq%NI2JRnrex4TCag5fv82w-f z0H*r`04$da&rw3WI6K?TV?1~>*fEU5viH-p?uXre=cm~WMuG$%I0iQ?rZL1Q#vw*P zTKxD=|KQ>J{>_UwNVGg(?C$pIEUg&e^vU_@`T1ZM&h{s#XEDTwy9XcUaU6SRSVYEY zypNo&B6DDmY)t2a zCj#4b!okvloCTy1JphnFF_iV7h_Da=uvQl!gK1X)Lc$4L3GwwV{z!GX+}NE|IStvJttzG_$)@DB0+9;NEcQ{&CdZ$eYWD&GBbsEnIsC@3Q#McOIsj)U(pr?A?Lp+t7lXlillpI8&XnEna_qv z@{^^q`)XiS{FCBR0zzsAWdx+!CDrpZn!rP7N{SC58Pg>Hq$ohn{7H{x(4RggJO10F ze-V;B02S?{LPw1;4o3!uQ)hJ_WeBIZIxN8DZiDJc_b$Ccm9;#E&G zdM$tgH3%El7w&wnLp05u;Y-;i1+kWz6W zvufVKlLTFr21f|5;ofY1NagZ&iqeNPTS&iF-T) z>6<=P*#Q~)x6c=Y0ZUz=JoZdjtQ=jqrf8RTNoO7|BW=N-#>D_q05b_G0HEZ5O?&1* zA|MjyxKSMjdWG+W zyIZ0QwD%tgvtm{~g4{a7!ZMDoM(2uHAK^Xa-B8KrcCQ(GX!R1r~?U+RZS;LgBUsZz|2X(S!a?% z+I21lKH1n1qQuY>?e;q&BLddhu6NPLd1m7b0y0X!?3QRlh<7*l-uu<*`rB_`oSdxP z(2WmcjPd01OoYGw>Z?Ebvp@aj>#w^_H(Tk!{Oo7H_|rf8BeFx-ZTI^_zh1A_tB1S0 zzB9MCw`b>P@84gaZC1~pKKtgyx5Ii7_JJ(EySo1DqfbxIRu9`d0t|ELJ2&p9-R<4Q z`I&XrAU@pPKY4O~|8O{2^j9$nu~N7eVu%8OOmhfN z?nYYB!}buuNQR=1eb<}bT5G16&z_!a@9qt_FMsl*-R=IXufOV?wM#eNjSz8ja(4FQ zblI;@FE0>r3e);zIs1d3!*+iUAj{Q4K*o9MjI|5rw+BJl?sk4V^}`@6H#fJzPtNr- z#%a8Z5@YaygkpO8BnD3eu5-rN7^4qN!p8MT+&LQqLy+^ci=kT_{5Z{r$lP~bGDg)U zkkEcA3yujvfkXr8=rFX#NDT8dhB^2-$UL);B4P-wvBD^+61i~5#R&lvJ4ta;0E(a` zOon5sYa-wlun=N*fiet>!L|WTy``hnXurPB4_HxjPvWib0i3P$Q!1lBi$he$@@e zsHsF)X0E`fd<6iswkYH{QG?&|+w(I7Ah~pMMjg$JG>+bCy%a!^v^HU_^H!~&0+Lb9 zjFhWGl<~cx7eL1oKtuK$w?DrMN_E9KPTz{ei-q69_;+Hw5TuV8ATG5;YGfG7E`_#K=MtnFB`_HpI*l z*c!tzL}sydA9v##1kEys3?HQ`Wh}`6nW?3y^%kKaWJ9iSO9PM9L+7LmZXKhuD1DzMC@~Ggg+@UtAS^KD9F^i21TnmO%n4u^RnrDuI zT$y=j*g>Iip`jeV`+MO05%u7hwxyLE)J+#CIRuV$L&Hx;-tfE{3qNMT2T-k#JS%w# z78@W@_SjvL!edo-SDNd7109YaGb13Na1<@-qnd^YW5(mzlb<;w`ytZ%7>c{0oXuRs z5oY#?y8NVp$=@?giOq@@Ez35mwk+6mM%$Iy+7(5F*I930QhRZ1d;Gpn)nAnf4$o&n{SL^w_gHSb$5nnsv2WJ#%9ff4B0$4}nAzA_!f zC?t%S$`Yj0=_Q6}ts!e53Ue$h2(=(xkvjq+F$OZ$Iur(LdlB{_SZn&epF-%2SZkS? zV=k#KEM!U@2?(B%AX$B6Ef8{GV2&(?aGZSKb!3nOcby{|dX{PSWY8HKVq|9L3^TEa z_rW-(q6&3=EF<_THuuCC9YT%25^y?^@Tf;#-g-~a62{^egy)Ap<1 z{@Qlk#?n{6{OaP_Gq>8D#(4Yg4HCN3&33z`$mZ;Hv08ug?RP)vYnl$x!d&JuoM9hG{Un$6ktCGi6Go} z-N|Z0Xb%V9MnX*7UgS#>42qDXX-x%H4Wu`YpCYcR zvZ>PP!|#5-kSfwml{HrV-I^Ci=)ZijxXI5-y`0Y;EuyH=jhg?QbwrXPif!QdPsuVS zJKZxt$`UTQRXFM3sh=-l5X+Mc0f4mSUZcFU{I~hgz(`Jj@En9e?rOipAw1_YRp@K1w>Go#EM9+ zy35I~X2Ze~n5`J*bU?7g$U!8U7-F#HU2X19dSfv_3an~=W|)$9DU|ir@=cQ$T~}&d zCQ>YDMer47s^7Xv)lf!De>X-_W{k@9QnL6JNFO6g9Y%f+Awb&iq-CaBlRQJ~GFyrb znv^^^;#Q?jV*@1GR;HGO^Rx^}!IOZXrAMG4Xak0l5Y%Lf`pU*WX;66nl{K`2fO*e+ zdQ}N{Xv%o@xI9jHDfxg!h?m6sD)>r}uA;<7AQx6{33d!W>(on`g3`Di|5V)4as;@m zpvOA1jR{b@Qwi3Hl9HIJOR$J~H}n^)Io&rUC&KD{|ipFO*v?(jE1`!CNwdh(}#_22*F-~7Kufs?1Fx3{-l*R4*M zoAb--cUR9o{={|H`~B|C>(`%t{`u?ISHJ!G>p%L*kLimqzxw9u?RIx@cK*-5{MDcR z`A<*IPOjd*AC|*m@{8UIhMV`dU;gN``zf@q;faR(Gn3OAdq!wj|3s?M?VbKBJHQKTQ4Aj00#`C_p_faS7-bE6j{zs&R)NI zA7nNLVvK#a*lusnPENM>_a4G(xf<{GUFXDex3H0eAH(xcK3*D0Fgh!V%uSzXcMB?1dM7|8T!uE?n1j)^#z& zel_^Rd>ALoGVb3AVvK=fln4Tm4@}_DkoQ{-A_&g9p&zJQhUlkhcFvrxPh5u&+uQwk zfFS*5Z7f{*pSKod;}3-&hj)> zEhwm^a%~B-nhZDsM>2+h#0Lcn)gJ#|5h0~&oE(3l4;@SY#!peft%{l>34bihj;_=@ z8nN}Ee0<#BO2q7%$vrQKTtsuOa^+_!gv!ubtL_x&2$Ij-(#y5K>Vy(dLqe6fD3&Sv zteZoBkDv{d-w?|7;!IHONvS%Tb8hp+;!GmSvs8hgfS{%#K=$Kg|CgFnc+~$qoF*Y1 zQ0+lPL{V=(Sxw?ML?&nXYkH4HXmi>RlGgf6r9n~M|2Y7V;|YMMNlG<0NI)Y3pxe1x z4PG#9rBCj48X-0G&k0SaRmQ8^t|)6kfwUh05b}w>B8-$(i7-kEk+28}BLfIUio(bQ zC>LShyWGH6%=f;Gk#1l0nV3_*_4yw$>KkR=pO&YJ!hF)2K%5TIf!sNaA>ISsL- zcjea=7k;)F369S4%u@h*)Iz=7a)Zg|k?#*;*xD zsS}5dJyd#~jMD_Bb4PSmwR73nM3q~GE3;t=D&^DISU{kb4JOEY?kF9;BW1FbrAsdm z5r~OV2#Ju1NJNOxSRzkEVu%o95)qab%*1yk@l}$*0m(Uscv?l|_i}*h;yGwi&2%s+*GL43gvI+{Qw>TB-iPEfi;>9? zWLFtw8z4;)lJ~(_5+q~HFbsjCHI|I=-V=ebmVu`!T5B=JH1%pkAxAcb1SEvm5eYCy z5D{w(S`&khK6HJz99&>=*7jh5@|N^|ki+3HO|u~r=3uN91AW&`<9PS*aJoL-?ME_Z z(J$PYegEAn`j|GG&6{^OUw-+;qO&i)e)aWl{_p?h-~Z{G7w_M{d-KzO{YSt2#c#J) z)7jsU&?ZYQue)0Onx8Y&?;;V1I_~QAych}#1^VKJxeg4TupT7R~+X*IPx;O7` z&Q8y--(C}uOyi6WoC$k>ILyoCfQELv9f1`Qj%*h|cUK>M{(PM0 z-R=G6$!0!`eeeA2m(~f(-Q7JA9Panq{d8hX*E>KAQy4azC!ajMdwJIzDF`G)e6r}F3z4@UfkZ?*bX7c^>({CKLL{U$zaILqi2Q? z`S#`(h>U^lcFP>em>4{v>6{IbopVAM=3p&aYkN0D3A@8xI3Nn0ot>PVU2>G)y?7a- zH)OiL_w&Rd4$Gw_gMp2)A`*pBAfh1_K`{Vf13aj zB4i&&#`IE-6)4KC+8hP4mMBEqfr?_Yz(tL*V)+&;s#5>~(6*mJ1eAv|G%N@wD?F8E zC1i`*{d|9(#_9pgIGwO=-bG^wQ??Hw7W|)V0Aq;M48Y>u*S!G^^rsw8C}#odM-ggD z7)oPrhTQyKhKDUJHKn3KKh++r#!odBrFdhrQ!g3HNu}k(!U#Z3f?OAf46?8oAVy{Z zBg{yg%7n7S6fQs$1#ER}idtaMxD1QQ)}}I-5gcKgWAK-sE^coDB+cQgfdFNpbVti| zivAncm5PVzR~eL1!~V&j)U5a15#?Ga3;!SUKS{@I`ktr}DX zOL9c-hC4V zTN+MFvH8A%SLH3=(<`0#(hE(MS0SQo)?_NSjpl|mUInF>ZP-GQtVoV@ipE=-U`BpZ z(IQ2ROPR?QkrrbPGKW+b#iQr|l$8y_Qq@b#C+QUi5CCI3(**!D8X(DqCc??`M*u-W zj6g(WkQh1T=Mou1CQ2%42C*jHRz46uzMxCGesmj|G6{l)Dv!KrP0b2uFE?3@q6*=d z7&<}Uqx;&=5l0uUEB}_wD0zl;fdE6Ayy7y6BE)5PJ^~UN7S3n1NvYF@z*4pbvxsnl z7m~C=a;hK*A})vF=IUxOI3bWI(MO?7Bkd^xOX^1qfvhn|&e<3v01%O+Q-p~Cz>v}S zEdZc(HWzV=K4~o^uh!-nis`0@vB#Ia}CGn-%U4nH_O#R0uaD*xjgxUKe&4H z9xX4{C;#;y|MBT3m(MGJ&S`t6(F{AT~x|L#9*@9$o}eZ4yAwh!CO^Y!WF+1<@;-x(i* zBg+P_-oE?ni_f~Do5tBWL9#%I5fY|>$cQM+hDaEUV2l#x89yxvMAfoH8-oLxM*&0?&w!D6K_r>#{T%4XpAgX*y%mtfVn6{R<7Y2mIZgs#!5E>)e!1K%7fXoo&6`*E+q;DuhSl1DiKB-e z!Z=B^*4bD#u>f-nA%&VmNOKJgh=8y#G8kilh$4^$5e8#`IUnn*nv)P&WgTm@Q$T>g z^_C39$Oeh54Z%kc=9uIO5pv!2i>mF^O^^gY;}iH0JXP^j{S$hVx;3l+^+VMCf%K|C zR}F;5*7!You5GbsrSiH)OO_5Q%q>}%NR1?fl6i9Esna6R8K~s8Ga6O&uU877s&G|N znWAdQh(K~id%OQtw8I7NR}Xi4MM;(W01cq3Q0i#^hGdXZGb8fNSx734N?Urmg{JsW zg7}$-(;fiQXh8ZFfixzNF+3s?nKVSBM|@>Zf2IZ^AekH^D3;O@b(OSONYhMg{;HCSYP>5s1u@g((^V zD?kXT*c>W!DBV+~2vw;odQ=mk$;-&gs^mC9f$?R!p|qq{KxOR~WMWAcY?DrKF5p{t<9h4Mo zi$GY)#ODqJ6*Qjld6jMjxgC=(OSN*J8q)>-fTHCB?;5b){*v*Nni&XXge_**JM}Ap z%mH;inkO^+qPllAJYCG2ly#Oe{ZrhQj4>gyNe5?Ap|t=A3mY&9073$c zL;w+qkVrzzyWR6HrX1d`tat4^koq>s|~bnS2p#kJ*L_eSR|zyQ>H0t^)$=@A1LcSFK$BNv`rgD z1PrCPOk{rY?8(jhJ7Y`~rU-y!tYHzLl!KmiHFJiilFw+2N!?_mj|hm7(-9ELK#0sj zoYxNJ!{f5%v(^lQnZ5U(olA#*nZCEd$H;*rg8*4FhB$I6<(N)@G?uJ!BJ4v-hA^5n(uUc7t%>JR?a5C8eU{qk4;@QXkB^S_u!KiK~1 z)8~D^eD%9m|LV_vy1T!XY5u#v|GO{#@CT9o)w}l#p?Nv1*US6cdtr#o5ZNGjKOYXe z)v(y@c0s(cHUUvGlHWj5bM|y|It<}6DI&5 zgc$)$l3*-M03ya1AS5Q?2*e;l#xgk~4oH9|AEg|ONThr=FekBV02zS+ZD%EL=emBg z3L)G-+$W=3qD09j4g(?xf-sh?h961}d~^}NU;Y&Anw(A2%C$yGwf{c;9BGB)M_M0G z`+Rw8m3#nD0BsgmQp#r*0IAK@c)MUe4l83CH3WcAsx447aBCqhaq zDn6hJMnS8o=q?47!<8b6${NBHx=N9)&Eyo1QiT=Rl2jj23j$L=k^)6k$4$xjH{}>F zBqU?Wq-&VUe%8Z%iO7(_bg);-{K+Lg%QoPA1vDzGDm5d2wRj4|FE)SzNzlR6pGy6# zzyOPKZMgTCN|l)k%$8gqDV4%Xx(<@VD3@^|5h!~C(l^4A{DcrW*RNw?0gll`Vh$K2 z+6EZrlmkg{uBcc|@=-3V7n8_nI;>0!MQ>*aUr>{j{CrjABITI|4;GH9v?+KPN&}*K zD-DRtU{qI8>vpULf1WQ8K;%c9ip{@yX-WomC5z+{%a_bNwF}GF)pW(^ zz^47w6KE+{jpt))9f+wsdj7~?VcESn!Rz;@(>D1Lh#e3PPr?Km23fY3fsg|p5_ zHehN-ja28jvPKbrgv7#x$bbe(5CkFuO4_KQ(LUx>+c+EIWDE+UB1L1+8Vbazx|w=L zb&iu+d89J|q*<~$B}bN9E0puRN%<=irqtPJ6z=x}|MFFiF%}u9_ERmvB;~fF&NYp< z{eUWeL=|GbTx}8oi7`uaLO{yrq(e%_Qdy<5gOq|W2#7JTA&9{*H>+_!2{4iq?->w@ z0dw^2t>ddWR}?nL*&RX zO7M{Yqo0f;Ol7RCA;b_OA{lFvV(*O8-CoQL0&Fe$7>rOr>iZ5!y3UHw|J{H4#Xl_<^cVm3uYdQ=H^2Oce_Cu#_T%`;7azG{c>2+kU;pYifA}YV z@y(0hY_A{QzIglPmp?g7)1JNCAJ#+n?9-3F`^~pq=bW`+om{lmMrdt*8g2=mf)=KS*fetQVa z&KY7vLkL7<=5S!|=Q*y{JsRBZcdy^PvS^~jlg;^)kDj=}{_d;a-Mqi;7TvHMA~G`X zw%f&WSW!3nIZoU^T|7KIynFjb3~bIeu3N;&b37R1Qgsy$FpKvTQ1(Q|I%|zZ06bS$rSJf6!Y*-Uso9nfGDZrt*4WXcREO4O|hsX}W3Kq(7sx>N5L@)rN2osUCV`}n_ za-37tD_+z>gKG+!$D&b^P(@I92~94B;*>HM1y*X8^JeinK!xO~K2Oc?$-8&0wb|2; zss0bzWCRpvKT=a3G}rebB7js=n=l&ygd&>p4{8fkqYJepe6kw=pr-I=B&c%*g&s=x zGV%_gmz)+E#)i}>%Kyj(6b|T6Mx7jO}#8BF^M|nSh zA+(09H71yVTugRpwN$H&3QIiFId$%fDR4CADzwW~OZ(OD{gnA=KgEY%yLWVp&P=+j z_EsV*0Ot6P-UE#ts2d(~KU3fo1&kp?0AmOt9aBV9#9I=|Y5P}Rh%pATcC%W)e*LcN zt@qv3a7E)h)oIwXZ6*ibsxfjC3}G1dS`D(7F^Z^n{v3ixu! zkpvJBYpnt3I?K%72S59+?+7V!3=9IYogOTbqak_@0AvgqL&h2lG3^-uK%zb0nQ&$t z1qK2kGW+}eVmSb!WeH*SA#{B|&U4rG^W?{QJULzeADF_YY5=oy9O4?B2h5Lj-^I@Bi!{{^^&I<%=JDZad-_wm19V{rY!Lo;^7nMs##@ zfB(tnKl*R)e*XT|%g?{~?Be|C{q41I=oTk&8W)R&_nw)Jb8+(1;n1HrVR6<@<7kZ` z#Hgp>+ihNZ)m@UcCZjLkJO^vCqDIa(;SxcXL0_^OGm%x3{~^ z+1YYAyngYrUv^RC{`L--h4JM4|9 zUC%zUfuUbKd-^yDql|}x1YVw;_~26tF}Y5720&+>K{2u%=RL*&^6D(WinT3&Ks(S|37_tb$X_pdT37ldMwEf;z1W zGABi5_0GpVslFlAyjn$F=Shu&oXh}KKV)OBQN$HWWC}DG0P;puLI5Z=H&c~QMev#d zOGE}u&hAMO0805h)|iCzO-}MLdC!;8^dC&ouGYt&k$;B&fSB;Uew{RR{r#9|#Q+dE za!Qq{On<1!S9s$X)#cSy;6;W709v;?9SDHw=;O2lSd#h7EQEOrJ{e*VW+IFN#2iI{ zg(%tfA~y9#3Kl?Rf5nll0jz*8e<$r1P*9T^xlsJL2%09++@PB^i;+=igcamB*sem( z%!o?x)FUJmtruG+N3nLA3(Z|AQwBLZE$3;Jmo=iM1Q`mSR#d4=C(}V|wdBkB1P)DT zYvl&kmL-S&OF$)o&AJ?F^r3J|lM4N)9yY-zan5)!!WRX-;8C%JGB`kMBmM3xj6e%y^? z^0Zw@S5d=Il?&98YWj&8#Ot`yKRPL#0+E=OECYjpaMbN|Yy~B!1}4GB$&*14QH(K` zB^WXS8TAoGb?THJHg-TBcA3`JDpY}7=en_Pj;J8;n8qLKy+;v}JV7F5)-#cQZ!1^@ z;Ss;q#2kJYNt3{Z73=xcUL+3*z0c+N?56&8lV60&l9|Mx^UZ-4ol`{8~yEWr>3@zdN7J(Hl|JdQ}lSlaK$ zZfODYsh9?dAXmz=)})Lp3DGTw7^HIs2o`U;(0+RWkZB5^e)P%J^^4_dy`RSI{T2yNH>W4(r_0rP9LKM}{zin6 z=;}9D%hh^%_3rdyZF+lu_b`u>HSXfc(~~FXhWS_j{OjJ?p>vz%ac+= zfAyz-K!#p?^YWXozWelxOKX=u{(~RB{O=2`OWQj?c_axTI&0l>5RedqFcScgiJlE10|T=m6c!>v0l^uN(2xXV5RMFl zMv!AVH3=b|B0wOXxBElC8gTN%Fm$dvOb-k~mK@X3FaaDTQD6p!F zatr~AL_ifGMW9KW?2y{kcyQz2_&}0Xc=A|79!oT=zdzDI-*+!khULixp2TxGatrjO zr5tCgL$NfPO@fwi2|h_FUju-c)s_$O3{QWP}OR;VA-;_8Brp%VGgAtDOXc8bdcZRt z>LO{DPLGv9pxBl)TJlmiJ{L=@IE}H;xpbz` zrU33T=*Q^)dt_CEeRcGi(~btM5=BbtMq>sE=-O?pl|?QNg{HJ`5Gc)37M0pph{EC zb!kSB9Tmzf)${V$!f$BUD&I08RgxV`v7%5PabJ@=RorZ9$9}-YW&Mie{koYp%*txI zGz9=rN|IWQ&q$v7JV*vXjvDi|7$tIo{E$=i5CBnPjKeShUEVKAI7(+upoSb$bG*2U0vsx`? zAB;1E6qyg>G&pmRXbjC$7*@mXa4=*5X;}2j<-%H8)5$mvr3RZ@>BO)r(i3 z{NRhf`ak^jfBOIY&(~LXh!`)BET5ghhU6Y zXE_R>A!9-+!Gw?wYvvfi8X_F$0GR8eT9oN9ia-RO#}N^y!_*Ihgs|V;EjFhiGDqnL zivZZc{p%~|%rMw_41S(BtF;Kn5Dw#L2RG5fes{QhdOA+?uUWF<87~|#B^XJb#y}!Hv?%Qv7_uI|MvR^Kqo?jk(yxZ*# z+udOvrw~5-^kay!8y|=qu#DqqtzEAdtJTW&!^8dkc6(=>8+T#$*TxcoNQB5@Ot)GM zLBhAceevzL-#vf&?598dlb`&_pZ@X}|Fk|?ef#yR_t&qjb62l#y55Blgn?PS#Q#5M zfBIz0lH7-Z?j8}Dd6wF4-R14w4S)@TLX#jwkQxpknZAsf#>PzlsZ3@Xo8{9OZH&@r zG$KI~KogB#UU$Fc?zNpIGa}r5KE!(J-iA0+&)%(5c_JetJv=;q?%|6nn#C}ysuH2K z1gIQ?_ue{dteM8i4g<#=Mre&e!l-Njm6b?s)+z-6g%#AOphO@r0z}plgCJT3WhR3O ztFWqoj;oQQT03sf&Hy2VNPvnaotX(LrtAlzO7KXk^qAxnO+S)My_`lY-p88H<~wm$ zdg_c|J>LCYk4fUKmsuSI>dkdkoaMc^fg^p?utAH0i!!EEs7N}uNJpC0kXi9_N->Z( znVb%&*h=$tDqu{Zq)~t_?5=FFSx9S%1ONb}dM~7}YRFpN#_N8Z-ly0Q6Z9{R+2u^8 z&TMs!DML-#LIK}YqjlSlshWTxTYQ1K#6CpSP6@D-2(!iFk4R9DdsBlx6=)tHLRP)X z@j$n6*5K*_{SnGRLC1BuEJJ_cF?37pMioOA-Zl*kwT-MCO)F^ft5(Xs!jvinfGVY& zTe0QA{P-1b|4DF&e=?|KlGaWUE#_Rw&O)XAPRAY|6=1Dvza>tx^8n-m54> zl-VbL!lFiH+CVBC-i2L2BPG<9g&|61^4e);7b0qn3(t3-px&Grkm~o1)$+0|=8Dq3 zf~Y#_h2t@!r0(X*$K_XN5$`eYhd>v~DI{XCn|F*-9OYXWY>Fn6(K_@@=;V1+Ylls2&f@aQL;v&Ac1hQXpphQ3eMUj z#M0>p5pm=Y;^3?s2QujAfMg7sVX~^QEPlOS?RUpvw1_4I4~i@j*l(sSfH9WFX+ zbhVl6IDx7`T9#w<;o@v#SF1StH!ojby?9EbcX#_g{KJ3ro3DR)`}Wo>26%-QAnGB5M&{c*nj zpE0Zl=NUF+`%{Jm25nTcXP+m*Z-jcL!q}klgRyUtBy>f%Ee-XWf2xyt{pC zoE4yDwRVH^m|V2zn3Hw@GMxL87T6eF+Ko6C!fFTVP6vpW0ruYa?I`Tq7s!MXvw z530aXtuu&baDyG}xLT=-UwjZr&d}p}u;j=YQ5fBj0xGRB1PCB1;tUy+3eYKm60pQ5 z(aW-+MDgCwM~zX1RXO-*iBy+9Wll=Yx zC`J7?jR1&D0^2p?XI3sUs!T7MUB9U~9`ykLP-+77V6eXXV^ehZ+K8RoPuh|aDN9&v zVZ{;>Sr5M(=jG4Ik4+2u1^_A5?o&!2fqcR&Iq(;95U`}rDyqUF0Ql#B{3C!0;X$N- zw5Vq2ugU&azpCxBwopEFs}Xae)=WAo2V3=0;`aa+LFv9sI4bxZu$8jQU$qGN`lDER zJ*#O|ZFr3P%LRV#LbhWRV( zq+3NlskUidGd))BCD3VyC$JtXZAl>q%+k4DNk|j`P(+M1#^B(bG1eFZpe(2=f!T+^kz>>-?0sB( zJkH^`gyRx?h(5*`IoYxw0rk8^RJl_r|DjUUQNC`RwVgC2r*D1oQ%?X+_tc!PslQSO z*P6CD?wS4Zg|xcMP!YZh-6XHe}V-(IuMrq3fMNlx-*uffOn4|Y`7~J3n7Oq?IYBe5@ z%h}o4;cyt&(=<*hV2ovss$!f4kl=Z<+8pM?GB04v*>*z!tM%HA!+bb8;|Avf$FG0! z>tQ>rrYSD+`RAVkn&a~Di@*8#YP0(C_r84n`qj<*n@>Ocg1!Ic&;BFW@h3m|&o=An z>uc zr}cV$|8NX`Hr8&oXX+>6L)1|K{*6GKFVaA31?=bP>Q-Tid7iVM5JK7ICd zbgP%&zkJvq21o1lG)$8nMpEAG4l(NP@XdDms5H-W zjDBz~dY;3ac6hSHkz){Rt#NjAP7FrB7;x9mpI$$?dj0Or)926cZyv6nUaqEd1=t<; zckkaF4to(KV^^EiG>p?~6*i5150zlbIG7>6a6HKCVt`-H=B8?5|0H&;7pp%7A> zP@8A4MgX0*00lwymis({-keXARgv1LNZ|7P-t!!(GQ|lend^(=PD$w568seN zKN>PgRcO_JQ&!OK3?V1_#A^93ehGKg9;*IDxhTsxy6|IMwsP>>EcF05{KNELmz3kV@}g&}>S}qy-h0o3j@e^aTr{ zL*YGb>%8M>%gP>DC0vmw^~UzA0M|M#SPc)Aqp)^{#cw_fr`CU)zBZ`3jyrweG0sMS z8d;_7F?CvVv~QOfEZ>J!DxAD~d9kw0DkTb^o;2w0dWhol&fU$OEEQ=zMC1Q@C zNQj61(OCPi+X3Km^!xiGh@i#QY9&#~Ik$3l8s6UCY|l3iaoNxBUcFymtnP0fRu`)m zpS%zb%Hi_z$$$PYuiw47K|^7gzx(#(^Ut5tV7~mrFOT=fU;N!KlqDX+n^$js{6{~& zdANW5?RS6sAAfprak1U3@apRR=5~8_{_^{mUw!%cIF9r2m{*Sit6&I@FhoW`LnJH; z%Ax>d5DkqBt05-aQu@HE4A`>fP=#aJu4?Qh0w6(u zUqP`z#nzb~lw3!kf?3GAingRa1qD=_@zTJuL?+pddF)v-Pn6xs-P zqH3us2o%75O5=uXO5Z)pLWxKvg@S-jC#Pp&D9&qnXw-3V-*?kRiko2rRfRGYr&rn0 z5x8V0z}_f|r;VEUXacT2rjvM3fM^|hYf>P6ZFKU=g*8t)>%0}K9;UqmPd|$OX-(Vh zIHr{NYIcAI)c_zB9;_z@#B4XVs zv}In++ehJ!)JejIRm6A2s`HMMu9A`}i4b8jGmA0+kRi~dsS6MT0x9IfUP}3YkR@|e z^^#16;t(tErQ?l$-+}`870T%cLd&$>h=(2N8}%yXq|M&n_jB5!aj`ybRd-4~<*m*D zh^-k^!P1n>{8g$`da}2rn>EY2Oq3kVOCT&EfOR+x!;#s?u->e^_mr}=vLJ%B7C}{s zMO9cu6v2?G8eMV+%EB2XZL|h}K~aQ|IEpa@NI()rK$yrz7F39V$(UiXXXodjz|71X zLUP)U93v>CYPHtd5aMdHA|h10x!nQ6I1Q`S7z2m6SZ5=%1p)+#lD17|83qdg>uFR4 zjyw(n5~<>#A_&HkHFi0M^~FSn{Os*OG!7xex4(WnZl}#=di9&vm(MSrK6`4NefQ=a z1K+&5y?J?ad3`<()0?;VXWI+1JZ&ytTt9#MWcTjP`~Ab=xa>n%o}6C<Led>lr%Z~$Yl zxH%`r5HN0Z(ffHhT&ymV?Q@wukQ$=sBM7TtWbsQh19I}Ob1;pgszwO_z)?T{^pkJD z`<9$D#_sO+XaR`^azJqZaKGR0$-%aR1<(HDq3VejNk6dHG&AY%Vts_xtU7g@#1&^5SAz z4Tt^gIqV+p!yL#ES_;Q7&wjg^rfIcAZ^t19o(8jd_UzNozi^X%_5Itw{p+7U`~3Ol zZ2QeGes0&BufF=>?fv_AZ{LE@n>TOA)wEh|+~|Ns6*#6mEyMwgHE0s}0#UWr7-N2Cj^n2yUxlO;~diRDKm^T$L^w|BN*6^z#7%w9ra z@%{uo=^wk>|DImJ|NlFgY z*i*`TK@UjtUro6vLYL~rJfBiV7$#>rp^P{8)(vQcdg zkPinGs#i-13CPo1@2>q+nm6c>=e5)e%OC-;Mgtd8L9Q;EkzNWd%!?!iA5zK+l+J)4 zElR=?>kE|Y+n_*-0jPeY(?GKXDxF)PV-NyT7?~wR@gdAhn0=g=F#9ks!G{<{3oACmLkFPiYgR3^&`8^>o$R1x zA|Gv$?bYFg>}4jpo%S&smpSP5-+m6dF+v;Pqo+R73IST{Br!5BFBXeZS%$FjiK?jD z!8xSEygdKp>H9bD$&jdm2(vnC$QcAuRc7JH*`8pq7$?yf%7i3k)|7rn1vKs4DNBaI z1o6{h@;D4`aN{&0QjB50JH!|@*Fr)7Fowt)DCfA=T0|5UXYDYJhD?ldJj~0o*ntpH zRMx8r$=H;Ck%*&^H8BJ?m}QRES~uDdBN17$WQ-31iH5&$jE$bpLQrP!t*0V_3pqt*FjR z@G)9T93|~WXXj^w8}4_z<8J@yCqFp)yW89Qr!TJVZ}-fyT94v+y;V3Kj_WZ- zh#^{|tN;X#5vTFu>g@jA!`a2T0Fdhbu;akS7`GaP0R<7wv>uMf!)QlqZIJMAIL70= zKHscX)A6vZHY-)qz)zoD57xeac(}WHd)ytBaGFL!h^(Wv&*dhz7q z{Q7#o+r`<(WkJHrXIJ;H@6p1=lS>h~xxXjC)oN{wOYwHw^NVp9ltfw40D@6TDR+QT zMTJ4x`xs(6*iKshK!k{F^=uf=?IfxZSYwF1hz}eVLbU+a5Qk_Dj>Z}UAac%HGC>3o zM{7rCykBnLzug`79D+tT9uBh)%FHn;iZyn#+5qCan;QZ}L-i1~K#db=0|h*NAb|63 zs9C;gvt3kope#$uR$D=OZ=lEzZaetnEug=nd+rBKvJ^WpyOhvKD1g2sp3xd(N?6kZ zRV4u^yGa)~)p@EU^Ar{Ln~bJea836#&0?W07@wUtRJdpKbFG-B*4C{*)P>EXOKiaocA$*>iIvHIKpS&8N&l+2o4m2*Uiw5&7G)9N+ znNZaN(4t^8(A$tCTBz43I}YxtaKg5oUeG8B#Y4IqO|FAmI%u6K)F{>0Y1qz}f zqRbpwIK~j7r21b9Nlm8|QL*We!V-bBOceBd6#f zz!D0aW;}a9VST$s?K&Aft3o3u7BO@}nEt1S`i<}>^Yak};L##Fxh-2&%6fS;$n;4+ zd}goY7R?+$1wbZGbJzfp zF(?2WbJoLTGGJz7j3^jGF>*R0kjO|hxM6U^Fb&oiM7XTS6klA}xCNiKXAcXe(Y-5~x`|ABLna%mx;o)cqhH1LLd)S<< zQ7MMV%%agag8<&M1XTh%8dOvzkg#5FLJa3u7Y2rTnIHDMBOfovl_iVTgrKX*t=6mk z{;=LoBDj0lANTWiJzZQ~291aPVvQMAqXDx%TS<(|!SD9_-TvWhy9y!@ICvgbt6^}$ zLW2PTHaLL0dUEyo4?cVI_Wj{74=WRW2uqxI^SE7Y&o{TPZUtnHewwDU?b$G{rg89d ze7L)JtHDqX>%F+RO!)$kNC{XNRE|DmNTdLUtg+S@OGpUT5h+NF5}6PTFteZv0j@@i ziq4`zG(?lL!(fpJ6ha6g2IfUW*xlbR^D@tS4gnSC;}Thjbe=sDfQmD2dwv#tyuZJP zBDkm~^6z9x2RHibCGA1}qDeY!unL<#(5`i7;M&B}2_$P$=tGE)-S{$~>b^M@aN6Qr zE0Rozg^Cdxs+s?^qEW)BpvB`qm#jMR$S+w@%EkORt+rI?A_qFWpCE6=^m&I%TQ*hf z)Swhp2$8ZN)CkW!5^C<{8DV`Wz|;Ez8k;=*^9g`C$?HirIr?V}AUpS1%Kks5p#6Lb zfF=89Q3(p}r-CsF5VC^MKxk3Gs`dpr1?Y(aP|;=~UEbpJ$z(YJs0u*gw$xFkMax*& zC{mbC6aD~|x|=D~eW2R0$_LHiy6I55K>mjPvjzZC>(VGFFho`S^FRJUS};|K(9X)A zpOuXL$)Z`(U)1bCX?Qs*SX#lRasp6Th3dbMa{p8X03ZielR@bDuiOp@)g!C0d$G=E zU836a%Y)KtsZ596WOV)a(?&JvZdF;6nu`ccxh@Zdyd*lH481Pb+YG85y}~IikryWb z=H$l85*Y<+aW`owtnp0up^B~isMA)^kD`2sk5_4F(CZOdZ$Nwu!^)5W`i!X9KQy%} z7W?jI%<2ZT;D`_9YWMR&uh{8PMY(B2JMFDZt~LpNO1i4XoQ|QkJ5^>%!GTJg)Pv^r zTTTFkQpT}zNR>Ap&6>6%zzWEMpwLTjvZ4gdj2L;qRTm%DbmTel%Af zXcgTweS`x#m7@+A^Olv{Xe|q!cRnaW5;|F~s)mSJ#&I~myo^5F-rgEZD#9hhMr3x@ zWpDnJrH3`d*kB4MA~K6L1PB}j3CS3V96}hJ+icgy4yq~~cMk^yNeNsn<`dGutfGWy ztw{k4$r+|Do)|evU~5T4foL_3!!Q8R@i_ZsL4z>_05rDn9wHeshQ?vadn%AM4iK!f zhvU&2SQa5?Hp4V+rnm3j`(-hM-E7wLVHsDGA-lVOSZ&tZi*tkG4`H?591h|A>o;DH zZZ$r8^6b+WU%Yi5nr&JPcVZ@>TUxI0W2LkJ5X z-M+suNJu8cc-SAVuP=8GdsX@Tvrq3I_Pe_WKq8xb!HqJn&NjivWu8^k7!uKO9E>G@ z@MQ7);_P^sIYw(u@L{!D0RW3e=6Rm2Odwuil z#S$L>cU8Tq?Yij9Rqbu23lbVHm72?{42OVTnt;dUAPx|1i&fHMz^HC!jhn z-p4pP6Bb=Kn z6M+Z}q9s%U;pmseFLUsV-yK;c_~meaJA1Dz!eR*{t8$DS5fBWHZd|Wccef9oL-Bqg zZCk|YUQrDArwTx4*DsQyTIf$T2dsT&S=lTU&BW85Sm4=$$X%pAWXhI6&L9Vh$^57 zx?;Cb;&f}MaSwkp)av{xpng?ut_JT$wuIA&C>OCYh?wg65|Xv19s;DID8?AXT<4Gg zjj<)<7s;f0UK#P54(n6ahpInNA#cU|g$(VlM8-N5CGNRy7oAFw=BIo>#ge?CZu(UX zz!TsB#gV;ep51AA-JP|h? zIjWr22qGqpH+P#CnbuP^Q59wY6jhGVhrp~M1O*^tKtK_bI)RAJ4#pT2AVX1^nZ4&2 zIK(*n=tG!&n2%u&(fbfpnUikbb~QXrM{wfH^AR;5D?5Ni22@?5lDrcsB=rOD=e5Y+Ds;7~25BZ#L4=F2A_7PWH#rI#INzQ#i?!zc+k3!> z&R|M>qzIs>Xq`dA5=GYUE2aU2{V9T%@6#u^Y9Mh9r-;}SzSyV%B{0I=Rn zho3(G{MEbfzWe^$ z_ix|(c^RfbL5{~|7zY(O&PO6tW^3%HFJ656-OCu`Fb&KxVLE3W62=gg5G)Y_tk1R* z*e{D6tQ#E1n06^)7$yfmsBm27AZ(DB#X6%3<7%9S@$hgE5&*P@km#^GZZ9_0*yC;{ zOCmZSkA{c?+sUoAelGeTowkF}Qgi!YBOQ@ig z0y=sdX*NyQqW}WT!KoSFm&1VqT{Y_l%|TjAcEl1Qe9}IDfC_MW#~*+Kexcm}-R)h& z4ny^qiaSu2+#jW9QCg__`51#l)=;+eV+r%E0RSnpr^)GoY)$}5C5dP9`tQ8_J58X6 zh5h*e^bx&nI{I6nk}2DsOS<@WM?pJS^2t`ycj9f#N-HfVd&=nw2GHC1t6Z*6Y~0^J{P9aZ zA`O-UwMN{>YpdRe?WxT_3ETNW`M!<>AJaN-7hQ`?%(5`bvvM}xB!P{|Wz$lw_^O)& zV$}mgRG35L7&&F~Pb&ckg;hip#gHL1*10s%%;H1jC?Upq@gd6W!@T&#^Ae&DQ534& z_+VZ>_`7X|jeKRBh03%YRiM)e3VBYn!{4n5R4ZM%>2%x0-`Ti`+SARopZ+|qcCC}+ z(AoORE2XeD1yAp&BIEG!aP z(-Dy1xEh9G+^pBje0aD&0LtRMwayq~5km+_92pdhF)U(Cc3({=Kg= z?g!SI5F@BsYg4%<5Vg*3wrhiyMWS$AypMqlgb=NAJpJT4Mt*qzprq%Q=j-)0O5EMv9rwrW<@xpH z`up!*-rwFj>jZ>7le6edT;ln~<_BMXwHeokMZbIbn{U7QmY2migJj0l7()aUi5f$= zxIA-Yzkm70TC!x+fQk--1w{ou9zB5?qSe`UKFq>A43@|Uvj_tqvyOu^#vJ_;V@xcD z3dUIxJv-lq5d9KF*$vJ)_i+2LK3fA}Tzv4+4JP_%2FFpxaTq6ec$h=raXpy9s;IK6 zC>j#c)oAT7F!Nx?!{Go#&#tdS2tLdY_xl+9upY)?J&wcu-7ZAGUa!u!YawftgyXPU z9sF^3d$%0pxE*hgpSN;K#yUbk9&y%0K+tl<3z?fHvpnBpsKsW&e0$MKxmCkSwsj87-ZoX zVmg*YKs#7#$Qet7%#lb97>j6)8Adk@)>>;35P;*tegPH>$PyMm0}BhsWr?#7@p#-H z=Xuc(C30YoIieB~D0rU|^a7!=v|g815nQb z$_YR+))#~>+2OdD=@mpkMFbW9yeI%w!zlj8S`P%$O3UW}-3dT?V!H7Z{TCRJbh}Oi zsLYNv%({L~U?=+pRpzD!;+kjk-C2c)P{T&Cl-_6Q0tyi1v=Hkhd5azdU z-tYH2jyyQ4s%~_C_Q~d?0LJ8~;^fdGB1o7@+oX!WA`(Mn5#tP&6Jh6U3^A?KTr~_4 ziIS*aZ#Jkfu2wOG82r4rs9GH$S}V68#K!465-8M1B|fPiCEz+o6H*=d>t zbef$z&iNZPk(xU_x|DiKBzpoz6>EM@_d}*;y?N9+57ho8pE>q^>!6Q zw9cv`s4R<58|rGcUgp_Y%JN(k0HTPfuBVYz{o<3VOzC`&j5D-3-yZh|9|9t6&Nln| zy&DP1#D!T{ghhl9-894?){-a^(KHSM>KBiS&Jh}ei0NP`ZH7LCVRD~7d;ap(8y}bZ zqkp>@clX<1||LzxcKP(VZY-g#ORf!9CdOw<^rlHM+O2FWo1h^O)EvX zyWgj}du7!=s_dJo3Wtk>H^gH0wtVUs(@9+puqG;{y9)FRj(ctL|WTc{|q=WU>C$&Hg2lp zgYK*DiBPxs^0C}oMSH;{pn#AK`PL>&e{%3Q)|jFI#oAGCf;-&geCVBq18l&6w2Jq9AA#}xR6`)0dHu7|Ev>H%5V&sWyKoOzxSO-8f zyN)9?w16G2YX$uZ1$%43;LR>yz<-VvmSi95kUmI`0r(*xw(|iQYC?mjryemx#mE3FC^`)L#e7-fOwHMX>L$UNMZ#()nZVM z)E|nY4}Y-3N!Xi98;EXrzWY%CXaVdE#dg+2|0wHK|&5#?D} z;)YKw?CtIG!@lc6DbKA->@j`1f?xSXQ6+J*v5z`TYqNe&LfXJz_i1#6x{C!{_;^O1tqo_s} z=#|WdqN`x8?DpZgQzLGZL648bt2TruRBzMuh;(qmo6s5mi-5~&d9O*96M!;#AF}ty zl#MzZ%?EOs2qh#VnHNM95{i?oh*)E-v-7+lVT^(xo6Yv}>SA}lyS=$53q-&I1`!Za ztx5$L+#m{@v(0*3i^PZB?&0=+4vTXZ6pghYX)?fA0|2Qq0J9{klNQUFNIq7jWEV3A zP=k-NKaOrBGN2$VZgh~0HJEQ9YmBuLSOKPKU{-7GX1fkPvTz7NM1-S2Ht29*G%3iB z5Xl;2$6*)-m1N#?5x`(dc8crGYMcgCyuaHI(}2eA?ssR~39J#-`EXDW>)d)Z4R$!r zdk|Q!r{i$}RRuom_xs%r1kcaUjkUY|ewqFLc>L-IU;NVw?f+^DD_vd$qPD1P?kr}sCzcQ4-ujO)#yg3&7? zZqC=DN`iJ8gn1lCRYgNFilRWOEp46nD2R$Okn;%ZVHn4897h_RLG;U_A`+uA8%yIb zSTbZ#g&i4dF#3g~0*XOK0Me)-GJA;8&r6JcKFkuA<6)5)Q=;_Qdy#021x0HO2j)}) zEa4T@(T&F0-Tgi?XQ%42;uDg|`)mW*b-5QQQ@?7Gs^|yW?k#(7+i*{$M=w`OvgFfE zS*uVw6@smwW|F8d5fDq+uTq$lsvA#&BPLr$vpqiLBFF0gg9xDJgETee(4Zu$%$Tde z)!tFRgFgr*O-=GvFSh@Lf6@S4+`oaN=o87mTpRV$l4(lDXT{MKbl8?XT{(g=L@$qSI}uGS`0VE0?HrCNJ-V~!Bgx?^Z-!wsWJD##$Q=9K?CTVF@`{C*&h$b zWwTmcKYQXmE9m9b#XQfvcsJVhW*a#MFY_S;D;o9w{ll`2>-DtX?ToW`w+9JqEZyAP z4x>BH%WAWlaQM~Vef{Ru`|Ib|7gtw5`0rGhvVLzW;o=xL;T!N0Y8duhi*H52J<8as=A8y}b zjAnGtKe_aW`1;$|ehCawfvzqteF!1&^B2#5`LkcM^7V_${loG8;owFGsKz)|vDSeo z7$h`H^eT#s%$zKyhh-TkkhLIU?BK>>vUasvjc#Cx%e*Z6B?{WrsmovT0lh>Q3#MN&}G|bhO^wC)^7Er>t4Kc60U*ikNni_9Et=@ z`)S&#OTu%=Zaf(e_rrbKyS36i+VHIScmA=Uj zuOj{QoHi3KkH5C5ggd!b(N~uEn&5Xv?J0?WI!kTHzMy}~X@7Edpw`AvN%f!5d@b}_ zt^q;y0?H~*$w>6k+dRVmHB=SK2?=!GRgIXKruRgTf(FbQTQnEsj;pYM zT`VciwentRE+sz@W`iH0l^U>8wcK`e#QL#l)Kvxq05g%vzZ|-PxLhL*x`AVm(rD^HsDSxg( z*$ptlGif zP9zl|lsTr@{^7AX8$dI%gaXwP9>%7lbnjMlufkRRSM~jSRQxEezgYU~`YByPuj4dF zxZJ89Sx}d*Ui;fm-{_H`{kYg|L&dJy$(6@HMeWShR_YmVr{h+2t72G9ZvELeqpZ_x z=Fdk2HHq8F>M7@CTGU5T&0amsF>(koa7_haC7ay6` z#~34v=IVeAo zS%pHsJRhxyehRI?_OJZ?%Rmkuz7(!{B95=;gugc!s-Gptsl zBBb)rehC0T2Awl8qnK`5oUMnigaj|4q+i{wv%TKO%@9v}bpMCc1 zZ-4f;$A`n={$YPO0)QJvgAfJQ({^>Soezg$a>pe;y}I~EfAITr;9vgqXZMGPyZ3kF zWDm#V^`}qP)A-HbednB6pKs>laa;`#4+mA=ZZ; zIE>?Fdwkd*_Xh!f^7LvNCjof--RraKb78cG&d<-+XY1eo=C{GeAO7&m!(o2^?#7J9 zxnaFp9S-w;_ptcj+^}A+rq#+?GYn1@BS+R~j8RcQH~Gh|_9XjpMW)fzv7zh(ZQZR3;_kgNVjx5R@bPCHPs{1GC29=OqNMkts2BdCNbZr2kga;JI8`JssV|O@!kU|-Yjio}Q z9{&{FlJI^HW3e`_Kr44satc*AUoDQ^Es8C=Fu#9B{!QK!k+nAY|2S*Opdn*TDqxbJ ze@+LKK3OtIm_o4ffk0A5vqKP4N%c=v0Wg(#`Cp<2JR3$VuLTX0CRx~nN~jS6=`)l{ z2#pk4l!RvQ!j8+7IqK1@5QA&u1!Gw}i5);e($B4o`d{ z+t(c`YXkle(w9d(x>OfOsfW;MJ6a~Gx8Hp5rXLKq3Lrp$?w%5k^GH`|w1h0YI|!VA zOY!!BS}aC1*-y0ibr4`Vv4)zoHw`ImN@?Axs3334OM@9Oyf+=dSC!h#Z{Z^ z%$&b_dJ37_v1h#(D*tq2$un?z)YE1Pik&OXVr8W4{8Li6c892ln9}c9N=cTCu@t;7 z-uaT8N=2BXTwPv2ee&Y%?VH>8H)Mp!q;P@|nLtIwkg?7JVDyZHNRWkUF=zmQh#HgJ zAW6%5ORnnm+`0<#gV$o?BB1bf+q9KF??1;!10|+4m6&GB+qgjEn{qL?oTFksItdI`3IkII@Urx6?8Q8XSlQ zADG!VyWXroz&K;b9FL2!xcInUP0GAPPPPz@j0o%P_Wa_)nc?p4_V)gkK`o*vt~YB^ z6j1hRo!Oq9ZMR!9xQDxY=ZqbP)ifM;$NPu782HJPtM%FD`|say2fBmZ0 z3(AX~(3^@?A4~fGN7Qd|=v5aeDp;ML-pY^d2Qq!T>FU2bX_=CaA=EZnc)jOo$XY>J zr%>HHirUcW1F57dbnBpsh|XK6{aNQR@sMV@Bv=v{KawEzX!1l2=uv1ztqo>Z==?}2 zIF&%9ab-wVEh{`TKvC~2S>WUur$2b|>2y$;Rz=z9n&u<>Qykj&q^E!8k(RO50ToP( zAHVa1i|LsK0H28YOqA1$(5EUo8GkY9*X01oKcQ!Jd3>NQODJgC@-w}WQ#C)&cw*h&?ldKI!)`h@87<8ce5UB&`3zu+7!y2>`~(|uongf zl^7+J9!rBr?2_JrOs@Zx4wDEmiP@3~BhO~K%MvMR@Nv<3gmGF=B9M}2OHQXQNzxKg zj8P(6XAlq#0f4iPj1ff?7^Yzu2R9hailrzE89E+jYl$NpOVRVPEMZ|g4&!Rto^8kV z4UJZu!^YZrHo7dmI8l8Lb#nbP3kK@`ARlZwG1feLVBMTn{nkcxN;R zMr#HnL^7)EgRu7z*e_8<#%Y{Z<1jb?0}964(HXL2t+8mBLkv-3Bm$Kn%qR-NRwa0k z5`lwo2=gKwB{C>$WKacR;S{+Pl_eQ~BP$t{$b#T~Py|(W)(y`2$n(5pfrQDk{IOh5 zkO#U<{Aq1Hvegu{R0LYR4eL%Ok`tPZ?3)Z63NBC|Vd zc*Vy>wgEzms8+1F1&Yp;&Hu*Q?Eml5Ie@d)7+cEyX7pdO0HsKPg#Jwn`GtHckku75 z)%zc?x|ZaS04T>R)$Xs&tbAgm?miUza}6Txw)ITjLQyCt?TT7EPxE$$Qg*%S5mKnA zMPGQd85YY-Qza9Bm&`sn4}n54M;288ByU@0VsOPm> zg95bp<(JM%k9m4d@g-t=e$!?V5Ja)05LGF|=#0VT{+jI`phUhZ0H|QokLx3#1GuM- zca>+fVE|Dpo2_`sjVStF1zBPyI*F&K+yl0Q>puUZFB+8LrkHpht{VX~QP}Ydl3s@|l<*Yv(6u zxOU#~DN+&nF1UV|}2;fJh`A!3RLP+*pnf1D-9SmoJ(6Zbd~B}(MPY7!ws zLh{Xb-)>gh7cZV&UR;0w{dc;s8f9T&KqQG0n3vf*XRWacWDP1PtK^{X67847u_2?N zWU(4q(ho;Yj;wVBvpV->f zv_?k?vb%pEW7EmGA#}r_0_*LD0D|`%Wjzg>^;Q)bn3<3JLu5A2J>2g{=YIavpO54C zT zb|4z8dfjd=o;`iCpC2CX57TP8y0|_+JOBQ--=Nqh*H6Cr#W%xtdh%qmyE_2Gv>JmC zQN%g|Kx2_(GH(elvN>D(IWP+m83hECsMB^7VGAZiHb|m^M4;kIb_X(~0$~YDh}I~P z35!33!`XBOsBUm>aLx^WiQb32FAI;8(-U3e|R@#5*`?%i&^nTFAQ_x+pmi_O!gmnz}S_isXEH`4vQ zgcyJH;}!WlBE1s##T^ZBUl<+&D~?#Z&OqG zBm;k{?Ul>MCZ&dqF~z`7`H-a8{ZnELsDA&&&4~&WrE)~j&|-(z3waO{=;IHBo$wbn;b)!@Bt>IR1lGQRlB{w0SuuWm4fJ zcMZ1EU`4s8YoZ{oDzU0!r6t`BRQHLDdb>1dm|LDK&66K&Ps=_JkF}1uzC`$(lID8Kbo^pZBxf~E_6tWHhYC8N9fBO1lY3-_jl)0Wx;cBr%Q zJAcZX)W*NNU2T85KP2lvBIYc)O~J^so4u<6^8Tbv9nVWjK|#6s>nXDaA6X>CxGZ5= zLX0u6B)HECA+i84OAMTf?xYA{)ok@I&MhCLw!m(WZ0b&%p>E5nXOG2i@plucE&Pt# zllE|m%c1%06b}FB^n9RUb$?({&>N3cF<4ub+X$6&qH8TWNIvO86p^|MHYx#v!Z??XAPQZ9LO075sd+)W%kCBu=L8o=+4iV8}XPqu_$ zz`nb=ef##c_~XU)OhMkid^697vnS_o-oCY#ERh=qW|<%M#@f|py1Tz;7B>t8=$Dy8 zpkY{@Z4P%k1$E95>ay^-8kBkG<4C}f0f`I>t0f~K9Ca8+YtY9iqGZ4jv8Xa2fwM+f z>NY0AT3A~E0Kp-l(t5L+R^ws6EWry$VYZVEvo~&#sLwuorVJ^;6e>)sNkNahqmS&Y z8OL$G+1|W+w_dMU!%>#-?E3kS{^1||)qnV#D9d(p zhKd?hjaqArwaz*gBsA;oYFw?YGl+^nsG!PZO<>;L?>L0OobZ)30~rFM&9t)PsG!0y zjCS$f7&AJDxl}gBD57yjJVPcRRkZ}hq`DOWMN}eiVDDoLVV)r}2y+NA1ZJk><UCa8&^?8aGIb+W2_ z(sFN82tJffbu|Bf{Aj^B0A#S`1Ep+i&MDrCLw~(kA%1ggFQJUB4FaUpbE!dz!9&Dk zm?`G!rY%54>b*Kqpb>P@k_8LZ7TR#>JfG`CEV9o(VeEM6f2Mgj6Ou(=T*k6x+28+ilTKd+ph zK&kE}Il5F7Q!!dCMMrXbP*7n(0MRa2mq>E!PfObS7$S$rK7`=o5<-j|qC}PuIEuu; zQ6L%ClA@l9{%SqaXeUv%HbVJab<=)E8n8auVn6oQJpnSAJ|ex!f$!hfNmJEMRfvzY z>gK7_{kj~sb-g|wIab9@i>g{u(dDfy1>lx-$0CNTwZ?mogqj?IvcSnbi)P0mj$xWs z&#s<*`so+@P9rXc$-P&GyODs}Lkcj>yO3VLA8|)jF+Lo6QP@ zoO47r2A$S}1PKzXH3TLqvuZfb(=_^dZ;X)`*VE?i?%o(#!ck-V;;SDb#hdqU5AW`; zUOX|@{N3OD+!`EK^wYomn=iijd{_;U_2%u(=4=aA-hB6FwcU=Z(eD>v5mY-4gg77O z_1P5WIL}^GR_iIwK?#H-8A`!BMYiR%hKqeMg! z7HcT7I%|!y>-9SLMFkeWL}6tP3p;1W^{_qLDw^AOx0VRVitu*364qs2tTWfwSG(O_ zL3n}HdZM*?_1ibw^YxSG&lL3S>-VeG-~b}S!+v*las8kFvw!;U{_?Mua4>FIjSj)6 zK=P*EuGWk9Y``y(3;=*7V;x!JmN_h8Mnl4!jAX-VGU!&Tl^a)Rjj=`o6974zHVIL6 zmW;6o%EE|7q6~voi4KV@q6m_zFmR0C8&H*~!2|O$AEWoA0xTSSj8RpDRh3Cojvk22 zL?k(23L?i^4PYD`8rtoSEJ7(ZolvE@lwg)-z@>O;S)09}%K{@U_9_oc1E}_#*0hsp zy@)#%Pszff{hojy4-0O$_4dI6dosYGl8-WntwKZp3HoOzAF7BGk_{XbbAhYs++Uof zTMCwf^ec#h3SKMT=`aqSf}#3F-K|gV>H`4!^>j*sqPQi+kDPPPrUYhWZSwplXRVUf#pNd{09aCjVqXThMNV~}ps7a)o!dF&sWo*@Y1v09Kn$6-7`p@_sGWc)d0RW)NDFy%m ztIvO0C&`Y9m;=|Ot0tOr|CeW#Pf(u*MMKY!yYOxczR0XeB@{hjdFZ}MM+6O>SKeyb zfvSG?!HtO@vpP}T-8z-6IC4GG_WBv_0$(cYKZ2{Z*B z3W}cbQN^c?wGHbetx(@f1*`2^8yKE+{_)d;N3{4IaQM^MnMEQCfUq+2;)C}wM41;qFFvq@z#(vo`ejj8VCHlxRS<8n z{g?cr+7qu4GkZsAx8ap*fVJp#=G7CzWJ!b{Ii=}HcOu4q$JPk_u=*VqK4cU<;f6;# zVdG9MOk28W!nuyD>naI>rtV}(Q{3^Bw+~0eqBS9~2m%s7!X=_=ja3l^5yh`Q|Lpwi z>M$SPy?b|ecRvh9P!T~GP_uTIHYVq69cu`Y3=&d8NGvfOAf&S+A_RpPqjeS#gw+s6 zmLxjuV2rV%N`PdE10VOZbrubhK}&{=1(h^xM6_s`SR71i?y+Ccl&@UpML)7_0{FS z{#XC6&wu#I?c19-uijpN_EeX!-mZW9^{cas_1C}t^=F^G;2>^rNcjHU-IHfm%h9J& zUAu<|@8kL9g)uPiW<_NdW-){aWGpdrWW{tI5(EvXsm!G&>4F;%&JUe3F+eL`8W*w-G2XYoThPHua?6R z5D3T)gE4gf?tVI(t}m|D;%;~Ej3H+tgFnuzVf80}_NTx6`kTA^x6DAo{E! zQAIcyLjvf?0*WDP-Jk@Zno_j^k}+h5aTrJIoV9}}T4z;toJLd-(BQo(6`7FG0;SYR z!{|hWKvdWn134RRL}ma*5#SIOkHBG>IRs!<&Y{2(qlln_K|sVP%*>iBUzCNO2qO}q zT04m9;do?LO2sb9L2=$3>+Y|BkZPEUNIjEJrcEg306+vO(k#2FBpLWfVwLt)COno% z`HZ<4NeaG)6NTVJc;%k*d1b*J#n_J-&k~q|o2svWw(cVm0-6N$TjW4O0ZlzXMAaMs zQ0=63yTY1VrIPOC3e@WepiPBOQjh!W@tNH`oDAg(6VWj?W;k`g3C3#;&hn5(+A)L z`l|vLlOz7cPkyfy3sdQj5K1l~=#+>G`T@GqVd`t z_Ud@COlQ-%y6er-U&D*bL>E1^n`P)DIofY5x?7o`68BM=y!BA9Mq38OlRg_2I;f)E z;!l&7Y3V?QixSj@dKMmHTw^2QDsV_3EB|_phB6*Rq~?^X+H#TvHTQ$uUhoSwA^_74zhM;`6x zr#0+R=t;wm$#(4fN!BSTX0EdO5>=@@3(IANWW6cnx6=j|LIl;w8e<Ke8MbKhHh{ zo_&mweP96)(Y&8!JtUt26@kzZ@nfXbUaEA2hK8s=c;^#2l(vt@DWm{;vi2m+@1FZ_ zU7fV}dw%M~oU9xuLvI(GE1*iLRG-&rzC~Em9;*si$|j`kszke_TgX~Ut~lwuSy{N~ z;Z$}NuXFlRs~gNwGOSb zX&xhU(iI8OSOW+gv)DCt^9NEEv_=I%by^RGEOROW97Nb!XN+;qE@W_w ztdeTfph1LzEGbJ&2jXOgm1EBcIIhQO++07uc5ZsO+aH(XG6x0Np08Ky&1SuIZUDl? zGe;RG3kn=LN?eW}glTZo~iqJY#iU+?uO9~ zVA1k-zxnpR{y+TJo7MDx|G)e{zWU*dw{LI#ysX!&vy1hw{`MQUa-w0F9DDuj_n!a! z-~L7o{OFIq{O;>l#-Lx0uiia;_0@B0-TrRB%(HQH*v$yIx!ST1?|ryHqo6>vi@O!9 z5Mi8#7$k-;u18~x1U=4+9Z;hlIZVzX5-7NFz~pSpl1kf(u(4_XKw(t{=L`S=naz4Q zJ3o&i_cwR*VFA#y%T4s6D);kpv0abj7&%Db^=AA0`P0b$&C8qJem^>EC;RZQeE!9! zfA~j#^zz$RZ{NMLgA0cx#*lJ^4Wk1^1EdB(l^KjP(>MU29h?R+hV1BuaWckP=Kw(g zS;QIV#tBgn4VYv~1_g-BHaljcbFR2u8^jdgB!jgI0?fcnpadWsVh9+cYK+1A<3U0M ziNMS;2JeAcIJ&{4L?lsIB1BF;Kd7oPq^M#@;Q>CxWmy1oaD0+0d3VhFcT#DvB)~xt zWf5j6n|Tpz1^8!oiT;qY{Cb>7u6h@yJ8BlVY%9^e)gwW7D!TfP^PZkSg~=l?%0Tj9 zDVF}4)uvuS0Ho|eO%3L>C|<;zqZ9ipg$&ra4?&OP3x-dhx^URqs@Y`QrBYL@3RtLr z72Mm~$I@pa8nXT0x?Bg$IA<(bV^YGO90#1?e##SD5T9uofe0~$10!fN{Fhvy<>i|v zPl=1xf)Yzw$n13jxg*i6Qj)sD|lkgTWow-M( z+q^2g@05Xpy%XApl37Hvr%!g~DVaV&vv-i-U;OcpQYLyR?)}OgwC}+Escunv%ZsY} zzMOOQ;5(7N;`QpFPaPdA&8gw|wv{6`7pz_ZX!k-+ReSP?mhU!COLa6lnd6>ut3J`- zer1%zJT?7)sp5ng_@0=83tUMAKUoP)d_2~YJ84qq`vlx{7`ou<=GoEYO~%y-`B0+b zn~JKNlYAO}9dEw7KDEd3m~lMzF!9u?(P^W%`I34CA8Wmjp2(?y{B4F~r!J&39keSQKvmrTgY15~R4v<_m zL_}D8j3Ki393mfQf1H=u#}Hy*iBS}QlfIFes_B{CWa0_kI*LOPII1VqEHB#A1pAxo zv$Qf$N3;LbpYrVgpKp9LMV&IxZ@k@>*N^|P`uVuuI+G&l)KXcUv#JsUQ_2$GSRKl; z%~MWddi5TY1oL6t=~aELsv$8ng5#;4D(jkEW6yTB|l+HoAGaav6vxP*uXtr9xt#?cM5 zEM6oSG!WEGgR|C6YkxQf?*q%U9yN+}1PCz(j&U4}brd~Yuu3|N1II-JBf!dlSG>Q! zeRzL!zuW!6AO2{y9{!jA=fC^MfBNHhZ|-7@EV4Z8XrlA0t8aes+i}`le|q)(Z{Pg! zpZ?LWfBwt6n_Z0aG)?nyxq5p2{>?k*j1PWZ0+BhtSl{0sB1bf&A^~7cM#*sGVKf{? zn5SV>0%lDawg3%*kTt3)?A5x#MfSmm$chSR5K7Hj5g>!c*l`@jX%v9t{^%Dk!pU7{ zwOOmkd^lR;HW!;B% zV@MH+i~^7)AY%|riDEK<)>l0%)n74qDWjq^d4A@ zLxU*7KKS4xv!ukeijcBU5s|P=!^kS$2fuhAEa^_N1x>n`-KGm*jygdA7KwpH7z{#D zAh45Ks?{3P5T0z<6^P(6QI z&Yx;stxz@lN)+r=plkDVFDMECT9%t+rKPEWonQ(jjUK)j|*uqLz-e_Zl>*=p{A21mCl74Y2eyGYU(aSu8KRVWUA|~bkKpJ zN|++R5CH_V=su7K*MwaDzwfU0ib_hQORTTkJr)q^83<+$Y2$;cp_B|$P+tgC+e?l zRe{zNfG?UF}R_vGEJAA1vB*_?v_njAtj@XBG(};Fj7DP+zr-9aXHf+FypXZ;F&Z+% z;CS|lUe38;9NoCuoLvmVczbsc2`Q1$YP}j)o5+0J$0UfxX+$(gcDLK@_Or$~t%h+J z*W0sc9Pe)KjxXQ&V>}{#`TXMeuyEvI#25k*pvvwccpvr;^DxrjoRR>6MYGKQ@c!=n z>4wm}`0TTb!~XC7?XSN0gHQhGpZxf5{@pMC+yC~z`Pcu`|LjIuubvQ@^UL%1=eK8@ z$smn`^@l|TG|H1FPsk0&*{%;(&2+XRGRNJXMbH2l0#!03tkxP~9j8>t)N<6j+g+{F;H&-%Y0a-_4xeDXVbKL^ZM26mv6|Lv$L&0jDi2jzx>n7_4cp+@~1xR z$JIoUowH1UsMcClFr#CRZg2qUOahEC3L05`@C>jX?Q-;P0zku{97K^p*^LgB=EFkP zkWnH77Ma0XX9vr|vybCo92rnWQ#Ojs|H`Zcq#_|OS*H?1j1X7^>@aWyM@~W%*3lZ3 zh#;T}fi)E;&NU%WR9Pb-Y1Cn`X+g%wsgh-aJ#7PTyH(3gA*{?1hzIK|88g@@F+_%x zVjGJfmx8XE*sPeOR|kslD>$f=O9%j{m}?F9={G(UQc#ClmWb?mn*K#J$E=4pf_}Odwk1Fnuc(?m*zjPf|*pp zx#aYzseY1wKN>4uwM+i#i(2qBB*~fteu73D*2R$jLC2NmV!^QQv0w5V@bX@Z3!+HnKct*d~IOsS<$@gyYH zOS?!)N12XUL=;jX8OSF9s8lTYfB=G`SnB|&p6CkD6o&kFO)n~G06C(#o(Z(`fCASD zu@vzw{}NK8YdOQI9FNtBzmPYPwxe}f6Gh9*)6+cFx@j%7#-N306b7%;*jP3xwa{iP zHG{GgD|>4ySPP|1S@ndJ^Qd-_0MJo7`{6uC`SueIsfiYNXs9}zsw z^9DhaXFnFzq`Jx=bmumYZto>*5G$-;8EF3vTJsg(B$HScR07;0EyWL1SdRM!Ad7JXO9bvk6&!>>RS-fv?!U~0d zuy|OVlA`JXK4nNrGB8ag6gMltWLwh8wyE2cSx7`FS=0!a;cUD9{PQoKTwU*XhqrHEzk7dk zIPC3Uj3Z^>m=1E#I%BOBg;XC(n3!3{_xoXS9_2tw;d zYlu|E4Fj`=5I`k{h=|5IKsfAX<5D0Vi5IkXz1?ii&o|rkem?_1^vnR8?P{FXhRnPi z2J5V`!?-fe2C!-xC*?)Y$bd*__lY`4?64giB8ktji~r@{{IC1nUR1-p{LxST(Jz1Yi<{fqum0eNzx?Z8tfir#wKht|7?PmLju3o60zny_Bec$rgk)XL zoyZJ>vuF(<4AzmM2j(@J!CD#zThhO(W_aZ$8|Uc85rL-7qzvPF6h+}^jS&^Xl&y?W z1ObgDM35LgUu@d1JFXTJtk=G9~+@_aaeM9qec2+V$&=Xp+RDlH&kWe`-f#*iUZ z^*$`#TSP87OsaS)rvU{|S2+YIB1mYAP4H1cgO4%B~|0j*pYm1xH5T2YWvsw4matpa^P zy)73aRVZJ)8>-t+l8JrnWr{JQM+!hgP<5Bik}3UC$?*W1jXkOgMC6=v&L(-2QY0sZ z*x5AmluARGlnp2+1tNq}_Lm-4{>nN2O}6S+XQ2uuE1oCJn`M#A)lgsG6d~bBEkvsn zOBEzbt456q9n*tUv7EpZA|()2;pWL^tQG4v=Bry-VXA&-uLl7g=BOaNBJ%9eUs83} z1fQUgT!PZ^0RF{Kew4cIPY6n?@|Mg5G(-RXOabbX%85gQziIf1YpLe+K`6Ogi&oIP zVHH>pwIUeS2`IW%@ruh+Mo=d<|KHRA%`2!c>~PY!XWu%Jn2!eXwB$B*d&jB;=J8}r zq6mkS9yF1nc=a?5psxQilhxXw1=1JsP(*~b>F$jcCny-Q%Fz%`0X#j{?nGIOMak8W zDuB$Aq66`@v+~U;k75~q)a-l=$yYO@c=!Ypi@~-=!+lB*@x6GW9k=RhU?vV$H~;C1yCkFSwDIbjf z+n;R#B0w(JhJc99T1^=YyJ9P#8W0BsRZ!GawO(=zy@KX6qd)*E%Ag9Le){71ix=at zy1To7{qF6%*KZI32?pmR#p-70j>G7zwan=<#~7`(VF>_$DSVZTuq3bS6wd$vDV3gr zh7c8i00Zbi##j?oNYPEs0FJ`|1i*UqUO|~9EipL~|IMeLJ-vGI^qXIP>*E|zbdl#@e)e~N^)tH}w(IS0e)iq}@&EL{|5yLx z|NGtdZ#nY$)ARLab@TczavTOX&pyFTL?l8VA_9z)6H$)JDuEdR4PkQWTThc693kG{ z?iDy0tpG^@3}FnM>zg_!kz?e@(K=E92|~sgGAx1ssxpjjv)w-2J`mxP7tgk5>sQ~r zxxc>?mCbe<*W39pJ8S;Mpa09(-@N&ozxwNGW9&G}%-)9-#j7gT4a4Zjm|<{4gvJ1% zbp&9nv2JwE4T+tswTP%Hgho-wI77x*hsF%!XsrQ2BuIh3!b%1azz$ZE0lh?c#^6ipr|iSVIPp$dHOI!G{nt2K+!YRS}i3*GDmY*(kMr z(NZjYY$vH`uAPt928J-{i3BuhCfdlwOh1;+NufU zeWiiWLg`GHk_@EnS0{+7-}Sm*4S+$}&Q2`vnX)}5?+k&O7fv$QOFl+UYea-qIt8F? zbt=W0pEtSOuT)EaJ18g!q^cdN#dzK0^-Q-8**Ep#n)G-%^w zGJ9rkch)&?UvyUh(pE}T{rj5&pwP_Wm07C#+f1r`KK^R2#iF;B+0}|A0jk|VOFX~{ zVmrYmkCXY-HCx0WfND~HDh7f)#^SFJpoQQ7)f$o)FJ{&B5%4Y}?k@BO+Ioc2MH=)E zZzIN93Lq_}#OC>#H6)DLtub zDSnew>snho!To$ZAR2`^riAb+EFm(pdLLLdL4P0F`{X~ zs^(O7x;FSfB#AmsgHnE|b5=z;L}n#IV{Ht< z`+&wcXCW1cU|p?;VHk`tq8eieOHfcBy(MRz1ptmhUD3_JOf)@t{$#yfae)1P7htQ}$KdUD~9(T>AtEg~U^85{zjG0qIe7-y#0KO|3QvQ`1d zVMGL0AT-WeGg?1;1ejKn5~4w4CyBD&tT8z+0T3EhX3t~{0gAF4Mr*A=(n=|E6pqGP z6;@GW&={jEHg!k{%mzUNTdNv{3wQ$P)zZ@xkzv^{3ooR5Lbt5I&YY~ z_m__e2rCtj>f#??2n_uRKo+A|?BY-)bcc4E0)$w-5}M&g3pBAQ0)4Q~I%9Bf&Khfs zwM5Q2lMZf-A;c60KsoByV0QRvkpPfAZ)yoC%&!cH85|}!M^!;eFHzqsCF#zl;-W`E zixfq~avo9;CZ#~E;)w#u6};2Iims7iR3m<2mHng4bP7OK3F;`yAON5<^H-Q%C#udv z7Z6;*dFH(0MAQNKa&ATS%qHm=l$H~eyUL%L(HonVRH2Z!`GVjp*69_#8o!Z|DK+%c zLw^LyNf;ZF(H@5sV{H`;9jwn6(nudW5o!xCmCjG5vcgF(RV^v(QaLK4uEu%|M zjP&KDvA*qT|3%;EAbEp3na-+(b88kOtt`M;^-vfTv=px``Qr+mYMXW!R+!rur>&2I^#L%s0EvolE|ixXMp=p{2}2Z#%z;^0 zBgf!lWLcKznU@fKh=C<6F(f@AukW0D6al5!)yM5UE^=d^(ix2DVG#}>8*>-Yn zcbG+GSpsvMHtY3jecUg~f(`+37$+jKV3Q5WhdC^JVF^pz-R}XF1~8z}%d{R4>Fi<^ zgM@jplxiTT#1JJK#SnPjF9Nz=4|jL>Km5Hfx2v<4FTa0(d-G?1@=tfW`TCQKU;W*0 z{)>P4Pu|`>+`fM6$Xz_Yc>B$3F!1Er)9-%$^2ujUuP!!!{nMX)|Eu4gJ-hycfAGV9 z^?&^z&#yLTPu4eYAFQ#5!!it3R6-0X!ALsZS>`|nt+PZJL*yuA>}In*9*^D!K$u3m zED;Hhd=zIfAB~D)4%>V^YQ-t=|&@7o}aOzvKmW-HU+{8KsnUMgn3F@b!V*sg<%*% zjAWe;fh+(Z2q2IsxN$JXrrnKFoiFFyVBO$`VMuFZzuQ}De2mJ)s;D|nL)vRs;|QYT zXhqc!B7h@E?m!@-AtG^H7LJj5Aq5UGEJtPz^NgC(hQbm&2!y~0Fs&z0@gW`#2M!`E zhEM@g!J#DaswnOS!s*@#Y12&B5^J0xW1R&wF+?AIhyiNOG*Re9&SQH+Rs|kkDvwJC zeeDA1hjQj*sF>R&44XiI!uKZoOO)LIm_4SmVvv;q&E7%P;7y3y;()7Xeg#X^;BT?6 z7Sx^{FQ5T1X#04P&;?0UFO4d)=gR^APp`|m) z1*jVTP4fHCHVSM-0CEkm66uS@Z>od_bhy8axB|&8a-rr1g|t?y-%bW9#fM6@xL09y zTK}LpTGhJh-zU^-*Ye(1sZ=d+`Tv$Ms_d85Eu^&XIX)Sr8sdlIrC-wY6i0qQsV+iE zAq%4T7eD!7G8|4N$eoZ9o~IGYz6b zPR5k~%+}eG4ya78ey9Ls`BJeH0X7g-O!%2m>S!9K@4Kic7TS;h5eUkFwk>|mryN~8 za{a%V=PTsO?sSQsz3*g&Vnt_2e^NPPEraRp2f2SeeY^50y>&LRm;Ms9ix+&sqz!`B zZ=qhP3#_a+txrJc#?r4s=th|?C9N#&yaNA;TwQp8$EWA_<8vP5@TM$uH zFeOD%?M9w=J19aa@fZ>2N+}4nSuX5V8Ad^bLCF}Sm{UF>;MsP2d3E*l*>mUIes{RN zx!E5N4|n&XI<5v|$QV!nWh9fLhk->wB-Jl-&L)ueJ7^{OxbQxqNc*tFONnAD+K> ze);tJ%{MQn&3gCXfB1t>j>{6m^0$BUvx{ff|MZXlCKz>KmXOQoWry8v%_w- z&ZV7#42duRBB3E;Eg55pXdInp978GzE@eEF0C0$+r9KY>492)|1O#ghCw>-IP>liv zkxcHO+$+^K8L)IXowPqSeW?gMY6qv?QRX9c@)EHbc-x7*M0s)c8i!1>cfMQtu z@nI(%5d@V%R9IpRF$gm|Yuqq|5D&YZk3kt!gtBj&7O%U!s{7n1c`q$TdPyD>k*1KBHY?y8A;-NI1t1|8 zDEPM41jseQ5P_g*2pQj}{P)@5of0#pt@g1$MFLk94d)!dMO&a!j;Ug!q5%}do4TmT zzuo)zcQdOfKn}T1+M6+CZT0|iB@2+Vsmg^-8G#ICz+Xy$rEmaDF~L~y28qQqJWu$28)D}%QW1*|tSeft5G5_6c+hl{cWpkxq8Pf40V2heg2;JQ_7?K&}g z8D&8oB@caB290UTf=RE2Sb`t4K<#`T9)W6rdJ2=Dh=tk8WOO~}O9d54Hi{&&m@=A- zBny{ToJ7YGdt#ZE`S25GTb=-Ya36QSLs%5ffIBSPcM4pUdpOstFn00Q;Y5cu2YgA|OE}qaeyE0N_K6kt4H+M&`wb5P4ZbWR9G)hLn{T z1gc)&XZS1e1k|F)_>aMD4YW%%Hy(YGU-l%-NP)Z+e#b#6Q1 zsC~zcd&*d|8lWdFP8t;%QC4QkhuoHIU2LVl(jHE2DWCvUJ5C}oCrDOSP7*v#bWefG zaVZ64J@QNpn%swkC2RSBpyHep79wSqlF}NE{G4B51 ze!qV>?)UrMK|}~KrWhxK)*_(;L~E>o4sHk`5Lx4ls#<52Ap|cW1lGyfLlid}JB=a= ztd~zN*PHVY<>uxtL|JbpBz*Do8m+m%->){~dcD2Bxm}%2hy8wcf6qRO%*Jk~^Rpj( z@r7r(zq?~#M1241{%X5{0geyHuq;Yo2ZIVB>XYk>xG)ZmjJbSbhG~Q#fFKh6ap4#d zoSWRRbs*}OWxKlYX42@DA;x%iw!VC_W{&gjc>DIjZCqT!<;7&rS1(_`S)XmMFQ2@7 z_deVoKmEaTKL)pO?cSI7dl%BqbdU8D~_0eKf|5>ye1&<1DJlJ2^%+gR{n{>a=ws@ZmU1 zWKgi9B{0SkDn*Sdy7&O9WJyuU&@y{t%ruPK^9>rad)V8_u#dO5cOmLO`0?*OfARFM z|HEJ3+}>VZZV55QxY?{?WF_?88zuxY7SR}kWR10hQ9%VIqR}}-QXn9(XbFf(?KlYY z`Pl{miAV_)PytkgQW_q_=!2*t=st=C97lD|Nfc+t!4AXdtR0N83}US%KqPBPML3xu z5RI}}W77#Ga|(=BA|ngfVT7pjAp|dEopVN+l^KvhBZ4so$H5t6LI`nLVvHbIsx>P> zu4&cw#a=#Wm)HWDB+P(7kx+dI5W=*Y0Fa2radP8ycXOwxB~?n6(oj)azs#FQ2A+-p z8X%|w0gAlQ^1Zfe0LA&R?uZ>q#WL_R{?to}QOVG!%1-?M^7W_BmL*4iAm;9|oOABI zZ^_KcT2NJJps;o~fCfmQ7dFvsN<)d8k&;X#ho+HHHfH*uulh&yL1r@9e34`_jWpy) z)|9M!I2^Lu$Yzu59YAA8RRO3qE3-25ZTFrfBHZ;M!sEn!S>OdK-+Skt6DJlA_n&+C zLPtI=RRt;{R^d)=UY!UE?r4B67P(e!h}ev(bW@+z3?~4f$%)#TYLI~bQ>~LZ%!X>cF!OLGhyis;fxVcUq96?X}v{ zYTwe;X!V133G?z$AxEOB7_QTWDs9$DY&9p9MhMXQEEM=!Rp9zJ00Uw^6D(v_EW=pb z1G15n5QR#-VjBd^pw|BUvK#=XkpR`wzv>pNeo_8B65rVcN3}9_$ttldlqU|`%s)`{ zC~7q=ta*w-ztYzib!(&U_mMcNH^GLCDtQ`rJWWxbfCiW--eH&;&fA3_Wv zr5IC6kvYV)EOCix2{EJ;1INUAJtcrr9H8>mVo*UT&gErNrP5hl`@-fL{#_5C>I{mm z*E)BN4$ypVQwJUqBTLgiIHuFv5&~A1-D(eb^j5v_Oh2Ce=o02RuhJX=YW7T2F4<_d zRhAW-Vdfq=d28*2fK+Z%b5RiEv|NZ%z)^`!9Xz z^VYZ@e(w$H;q3hUWV5-rxP15BhhO>fm!3R&B!oZy(Yt^1?|uD$_?LfhI2?ZEYhSv) z8ZVzb6-aNr`<^7U&LE-d-F#RCF(1?+8DR zVap(rbCy_Za^O#@1*8$l5XVG@VwBC$5n1OlQRaLvBudF2@XicARyUXfFfH>fd!2<2;lu7fWGsDf@G}qKmcTN za$;{SkqMko&^il(cCf(WtRte30x<8kCjh_z43cZ%8A~i2mte^n0!}O<2Eh;kq?i^X zLPCa0__{M@p64{rL;{i^MTseefFLOb<^&AJm>APxe{(qOLrAEO1zZ#OR?(>zEP>U8 zR{6dZvq&-gNY(LC0Kj@TbORb2QzApxS2wvZ9Eb=P0I2MuDaE6r^N3lk{OlHwtGwg3 zu&!MJ^-8b?5$icX!A4{XN6A*}>H>s%k<@pmxIZW^D&7_=0y>JQEJ=Z+&AC$8ReM{7 zT2L$F7WM^I94jwet=+I1+VFVD1sNiOF~<4g|Kpvr);MErt_EOi_WsW&0M?Y8pScDw z>7UuoudYDVS4Z45F%*tU|6SF zyP%&&O*p!w=`96@qr&oIpkCaMrFb6Xud**|i2qs>f^dRr!fEUx1diTZt1j>_z9Z`1$DML0dC8Pm%tvhh8;NZ6#O9g`%PUZ(Wj7 z4g%yT*dTuetLm&BE1SQR!+@q&D{xkQAfw*;uClqYpx#^PC0nPl@+(n=KtIeyPj11h zRFxD}!^#`DD&Y#Dj~({QHx+=EDZqNin$HoBGz9Ib?)Z#-apizbL@5GFQS(qWq7}el zZk7O~o_FQ$Qj;=yeOD#@W&n6JAE>>nldWo@wqLghHq%jAdY!N4EsZ{*Kp1KiZ?oQ5 z5F6DsElP9Ah6|uBKx+ViFp(+kN>&51*(-&ZVodYAEK3L}g_v@-pBOoTgviViVhS@YR@R0VAgRJdmg0}1wfbqA%+MgzffUq#+n#Yj*mq!-dg8ba%AHT zA$5H>O~DWfa1M<)Ip4kV@mGc6_3yu#mT7a^qak2O5&OXjpf!X@NCrTV498@wK>=e8 z8N&(47y-_HUo7Ihn-g0@2GBWY$RVO}1Vki=#vobiTw=~S*+sbP2Inl~nsORp2_)8- z7=;K~5|D`;fyEkH!cq#gvH*dA7|6!3$Q(Lr3=)cnq+%M00Ym^eEephGkTG!xONhZB z5dlY8rs?wPYF?HUBC1V60ewaDD^R-4Z0au7UAD>qLCGu{*?HIb!FkWj#@NH*aC5!a zI6gg07evYqmKFc%OV{@u$=z0{REeUOTHaSa8Rl4Z)H2oYzxV5sFoX@8e z3(N2+qx@>REdOOJgVkMH0|p8{CdeSQMfX)_Xpp{WQX=KZE6-bH3aXr`m)AweP!Wo& zq&3#(BEZIa=dCrl09dY8p2Gk%@2Am1V1!tlfHcQ$&Hh8!V!Bvai5)i66?#LR}D!Yo+5ep8_ zfU*GiHA5Z18WYTF#Mg*m7S1sMfT&3dSBPH?`=xrYa77o)+46X-39Jf0rEgHJ42v#R z%TQC%+H?jR&5PCki9!OTjH4hXJ%w9$Tm#M|%N*1K1?`?} zZ>jJav{6-u)Ya!0B&Dq5G`r>aHnuv9%v?+}EezT!HEWqg(Nb9=a+9@d_$ zfKu;#W{AyplA5}Ho$&VU$0|p0(bfS%1#TS*JAK$8I{HS$oCVHL1+b@B2+8br12CKvE4&ZUKa@1(Em<{nBG1AHzl^En`Mc1BD zt9nYa`q|k)aeq}+8iG9{Q71d^jEWYvqL?plPLFDMUBGEWe|?6ED%h=iE|H76Sg z0wrc+O4jQ9D$d~`2$qborXPB1T)*j@^`!A}AP`cFVVRd`jIj=#Xlw9G8CR1R@G8aY9Nv+gpGizxD26f3d`HeQ|Skw&|QdIp1P5PcAM5(pSFxOY;(+ ze)w=a@PGaf|M5Tjt^X$p{ou`Sf9Xqq`TX9UZ~e)4U;E6<+mrk6z4`k44?akiub&=# z@4Pd@GEGZh>AWL^kk|kiYkfBW!v5wuEDIUSS)WfrBxuN3144k3QmSMw!ibp9ke~_X z%c`<5C`qhy%xpV1-W)`DJ8YkO{<+O=^VaKcAEtx%##kFeG`<_W10>EC6OqJhzz8rJ zA|OPRT=@qGk-!wUaqm2fY&M(3Y^)(H-XporQefz;?fXFloHHz7yN&@RmnSpE4n9{g ziZN!ob;eld1SF-%g2K`}2bdE&lEjFJK!6M>1ds$QeeaARNHL}e!jd8aB1h(gAjm8+ z3P(r@m_rDNLW1KsUS3>|<5ZYw;%t)7JFmne)&sPv6R5q2uBTAsvp1oqM0*hDd+b94E$y)rs+O~^) zTSaC;L52C2v#$&x^Y_j<=bX>~+MFym7c#Nd8iV9qsQ^&?g8+>&O$jhU)L#_+6@>^@ zC)fVh!8WKJ5!Dk!HK^*vP<=OBps!6GVMbiPZQy>HfTCbj=u!ZZ9w9{38M}>HGi=x7f@~U=&)?XAZ zN?|0WccpnOcdRD8vbW0}6_C_LY`||`xspaqr$k|H11HPq8;wAu_=F+k=-oA$R{JuA zbIR19nCErsb-~u@s-Uhs(#AYD%h?gTM)R;ryA`+B`O?4cqQS|aC^3}w$_q>PIZ~-wwyR3w#V@eL9d@8 za+{ab4l8A>Gojd^S+CNEBKgYYY71FO_V|Z3f|>f|L^%7C>ZdnI`5SF$&nbCpx4Z4`?94b9BhQD)5S^axHruU;nWiy`glV3}!!^j6f#I|R>jq=pc{glM z5=Q|^A&#S*p87G2Pd|Jri1Royh9?*Mvu*F(aCYyEm*9OCo03wT<8t}lMGC=tbNAle ziw95NAK$Ug4&D-3qV)WW_jmo~>Ep+b9$wvl{(QULPUH34@4o+YAAcFn@1EU}Z+!1h zhGB@yeDCh7z3X59_7Cs9uzBv@$DTfV^3%5;oV{@R=&c9N(Pq;dz{gLnfMmPtmnEcy zyP@xVXPsG=aP{<>2%Rx0CD(ai5d(lAEHNgIfs=>}F>vmS|zGX$mhX=b>_ z0s&|csCa8riU2@ta;N~3Dfozhh*FA3v@C$e%AClWelvi`64P{ju-10I%l$`T0b1q| zIaq5&lCw@wymJ7Mk{}}(OiPGML;^$5b%1a2#G{y#vEQx1W62; zzV|7{d0s?F5L1XqC`b%Uux@?8RRrjsY~^bM)>k=D<(gU+5CJeHzS&=IICWi5#>Nou z-o0~ueKSrIU_D%I%n;JBKRn`m*vh?zsU6={zf-TE#)yysh8mI;c&>7CZB`A#BAS;b zw^9w?>dK-muZVS()`~L`)K44qoptsy?k^&^g15ED1wH7+Bka&XR3M#0%r?qcW4t~_SV~2Ju=;M)u9X%lJZS)(UdQG{pbF{YO2MmC%lv>9y)gh}Pj&&Ij3W?p z)Gq*|V95%G#j2>(DV2{w(Y%jT*cPVAdK=cSRvBImU&Z31U3ddV{UZv+%E0an~`UX5Y55PLD<*Y!5y3U&}sE&MHQ@nML9Cb$4 zhxA#|q8l1=3&l!YL9(8KDMBues`V^I03|1{7L>#x#h5sS6jKUIOsT;8B(i$^#~cZe zeg4((&&8*%u2VS;FMCyIeC>1P@nsKv1gr-^Wf=A1s@CRtmUTsr4fXBJgBEiG6%+uf z?Pelv4e*sJ+r&X_gU4^FOD0Dbs-n@{t>%+zBPo1g-FY>3rA}qD;|ddFM3CYF#?9c> z7p~2-3Rz*#RE$|!;DYNdweyiTF`JTVLj;O189)jNAOWo9$vJV6i=9)Ath_cyRnBvC zWMqk1b>tf3QBR+Q7ZxN+H-Y)4>l~5w-7wiW9WJIY8|S;7bJmBzAAWG@I=>w{B8nl* z^CF3jGa`KF{(b8<`^!DfGXiWjn|`}R7DO7y!{KHx1SHUHwx@$nA%d~p&`pO~j9J10 z5e(7Yd(YiH**^I2@nPCehl2Km6P;e)_?Ck1*jUKmHly@U3ru^X^NhPai%RHk)k6@G1!xGmQu$kS$e6CHtw@O{=y^$%Vi{ zI&V`v(+D1h%hD2t|V^Sta%cFw!YtLys8YDH8yc*K^Jov75W@~YUZj=2`J>}r+&WhfOj*T$sS zGNjf8QoK<>aK5p%!>s~(J*aPRKnr^TO9k`xz<iQHr z;1Q51n?leiG!x`vg(@O3pKzf7e*H_YRWnzUzOdRm^+G*IfW|dXzb$_q0jUzUk9tVC zeyHlDu&$rdbdjKDRY0hEcw zsz~eal`Pgp0G07&!;7pKsBG<{r38Sru2a6K=(=vMijo^Jzar@sWi)u`R*#x5s`j|% zB9N7o;pkIW0bwl`ruQAOC8*YY1S#G@%A1?xg;w!_<6jC|DsRdEHO}HkjJG*zP$Vd8 zW7-dBXS=fRR?j$w#d?4OwY|(Sl*aQ00R&D>N;<$?`4zFao2bdTY!Qx}BF{0zl$Iq% z<`ferW`US^329zpNG0j#5>tpNadG-*hDwT}aJ!uDRaC9y+t}B!>E1`IsVY125nmtu zeOq@pZl{^ibxHx6y;Zu_INY!7qBM;wc~nR*b@ia3onyBjh4|X|dOnZkjq8B0X%h7P zg+ev!6qFl^N=Kx}|CN0=L(i*_aS}AKKv=?gTS;G2IYTfPI9IFB?wrb3pjKodV}M9R!kmU~bNBw;e$!7=nC2NlrZL`q?p}Zx zrnud1QubL9G=>o6upjT9WW?F2C@XK5@9(&xbhd{13nJo$cu zUVims-}(NJzVzkKfA>2-`MZDfum7vx`@IhzKc<8Hwg2f~`)B{J-vXBmQjD?R?LPeQ zsX^0qjwQ}h+-|nrcJP+ofB)flI2eoBA{mlEHm>LGuX3L`Wf8!MF{giJ0R&?RG>)8z z1cW((pfLbK+wCSL7KD`Icr#l|h+w@%#1s-BS(m-MGRP+YKx0G_A(ecOh={0hDP)aa z1a#i9uycM1OJ-a{-y3I{#dn^Cz3aTUWL#F0UDpXhiV1*x?}?1D7SRBK2y)8VKW*aV z$Qb9GbK^YE%j^)Jr1_=oDYI<0J5KDK3p@*RX4aO301zd`ATbdDr-YmY7&#e2gW|1) zBmx{mxVgNVm+^3zymQWY0<#})E}mRPo{5MAQcO@Z+}jp{y3Gs1X~lp7{`|Al5z_!g z$p{CzA2yqQFwUeXNHi_s;>iURLqPTqfWq4|Lu)gIsf1c(Oug}Euua9phzL3PP4)aK z>FzNnPuDy+#VH7=92OTiqygZF0;ZrHDAsjNV85cOdb6@lJ?>P*oWIE(Bn3z%?Clna zZL+7RL-H}mfcll1&hplV@98Qc%rvr+3x~tC$HDwzh}|RAqyD zn$@O}V5O%j=Bh5MI1sW=PX;J8Dxg>*6qYN77d2f%2@0^~9RNj;U~RkzGsP3DR-M;?)%j zm&sE=uXc89el)D6bo+?F+a4m+<*7@28*?d=!s--(1;dG29FHKsY8n+wuCsj9ez6>= z)=@EZ<2%#bR>K-}eW4keA|zcvTut<( zpi5t80^mp?SFWq(2CO1^oxLJ1sStHL!I{Yt5n62h<}!cH@g9Y97G7L*#e8c@jQKf| z#BpsiA{ok?$q-p z;5h++b=LH~cYRDUjt3+X!LAzs>F)hqH`p*Q%d))v=IhJ2^xN+K{qys?cTZ1GIm%(4 z_BYqlI4;v<2RrT$H<#BbCJ;EkyFEWY8^;+UpPlcPB*SKY;f4E$X}o%R73cKwOCK{E z_nkj`^Q|{O_{y(-)+G4BU%b`tPJZcEKKH{v|0#O+r+@ryHsFo<{`X$Lckj-(zVic2 z#sYr%*M9lm|A#+LHaKT59_^od{_L$cetQ1GU2h$yG+l)kUVZVT_wPP<_;?%>N7LK5 zL;%5%h>Wo)0!XUvCfJ>_SOcZ;_fBDi8HR%QqYJJ9_=Vxbq8m;& zf+!}Y6p#f$jI}9-Wm&>93x|bqYppA1BZ&ZvF=WshlU*J|2;+DV;dxs2S2ueEARIRR zrrUk&<@-06ho?_314rX1o6+(i9n_uNaONTjs`yqzPv%7+>M_a1R3^m-m&U^gDQ!l&X+fF6PQ@4npWvq zQBM_{1^2GFbM2C%k;WKZdRH)Kh5nU0RV&8IGu76|)5D?X~b(mCRf7NMGCfp5Ql`Idu9c&<3!p7j8h&P}$~~ykMN##-hR^oC>1XYED_Ch?og0+t2#J+pY^s6p?=DhwVww=5~)%--2CEGN6IwFWI6_RG!X z<#@gCH}3rIotHlT%FqoK?bWn@^62q=eS^ed2`tGN8V~a{hWq!=Pft&~-ftZqV!FD# zjuVIJAcS4#Z?3Pbqi#EFyW!&M;`#f}eeoAw`>lWWuitt5oxlD!e(lqr`NV(qfBb*^ z{eS$o=d1De|Lwo~?B`$m#-IQAKmT9+(;0(!=aA57IaLBO&LV-eUYHYb@4C*P0L3I66C(klU6x=yUIey; z(fJAxzHMu5*OMAmhz}B`{(qU@dme zq5yLw6oY6D5<*%6r#S3LK3!yglN-sC&Ml!xwyF8@ArUW9Z6yV zkpzG_n;ZypKI~f0|0=#$1py19Ej&}81mESuxx@(&Hp9?$-LTt+g^4gM@$r)fF%b}u zXr;?r9He5kEVx!Kd+P^Q`Bh|lK4Z**+1Uj?R|L!E?)Bed(I-W*3Y5T*R_-E1fSLrc zTEjI+7O+X1l9?t|L1&d8?dnn`tbPdYA?3C014aRc7aHkD84b%FPYBy@k3P zwY@z|XkojW=@q#a_*jqC`%07o5LxgNGh5mKS^ZJ4=^cg;!KV7mH!y|0c%HxYnZtdE;UO~`oc z3v>$uA1x55$|RhP@!ZmVJs(?vZ0))LBIaF|m}7`3B~Fm*edV;C(~?4pA#!&3SrSiE zSVGF4|0xy7n^g#G%qmhgzCex4X$W42-`w4pcJ%71Qm#6dF6Gb0&9aW}BebR}-x}N4 zvr5FVE?6GKbqO^-3y+rWcyUmVxj?xgc-5uJe6wjRnGKTsE8DcO3vOAui(xfWC9q*m+6h zd*2!F{4$M<66eKvFT!bwZnN2KPsVxT6vlBh#&&)~XpBW*7^g!_F$qJI)4L}h|G8IB z`tIGwmp7N!%VA6@c<-$v@2qp(G%iy(AVS~uVOgGhc-i%iP!89l0Uk~_UFVr&PPSu6 z9=-bnAltJ)|Ov9gt){6iJ|CySx}XQUIRj~P?o9$oTITNNx$i> zv*XPn31_X2GqhLXLTkmVoV{lS5Sa-PkpNgSkiCoq3>ijt#u{ro?@05g z7g7hZ&H?~hqdcS3gF$7~B14v>d!_3b4jLpbcfPiQyZwL@1 z;uMgKMIuAv;eeQ{IEk|+C-;nToTu3!cGek0L&zLJ63000$7P&CT&BY~&x<3N=YW9D zn{k|3*cfxN-R@3yVTq3)J(&(8dCEw|P}#r*?n7mdD?SCqOe%2K%Q>!%FmGpJ5Kd_` z47-z)e%LO{B8bfK;rox6BN;2g6&QaM-za2o+g#BK94LY^o6U3Luk8P03=w2ZudY4_ zh7e1gV5sRqQNw&!JVii?e^AqgqUP!`1qZ9aJHveQ6{KU^D5=Bv6Hs3!pe%V zNNTJ@Lr@`+uPPKMJk46?oa?-I&RJ`{b-5C-AU92f)O6tv3juon}X+Rqs-&p$zs9<~{~|GIVs^ygKlY%GD=fcmi= z5k*-|P{OTkD@`jGUqc2nx~9ydo4sCliQ-=cT`Pbo8=x2wt82Kzf{M=aS)^uhYCxZ& zQ_!td32LPgg?&dL6jp;cs_4j@do^%2*jMxygf)7xOl9ew{wO_Z_d_PAb?(+r?N^<) zHMm`Y*m`e+rq_q+1XtdQ&9~BORJYJ$zM&idb6DaMLX14kA&2=!mL;YorfG>w6B}n@h(s7d3M|OrhTa*!j8nhy!otAb`DKYn;QD^I zJN@v%BjYfH#TeS`wi3~H&KdLJ<0ngqBy@i7^o5r{#t0AJc>pn`n9vGZ?3^b6OB6yl zjMKa<5+pmZEFnaW-7rj-2kXcWj^{ZoLRKU}VxIOlFTHwyo|b70j}C`dpFjQ7$3OFn zpZnyVm*4q+|L$M;n}6xyTkrkJAN<)r`rrJ6-~U(t(Rn^QKmXcSf9XH|$8X#@JG;5w zkMlTAH^XlD{&(K&H~kkr_o)Z(Kb%we_$OZe$xq+?;O!@$_~grh!^4LkghK!{r+2pk z@Z{kIlNbO)W*mdDv^(7_O9)fQP~TW$7Um=frkJ8CHxTQrAtEwMSU54FFpDviYrR?T za>P`&$)O<;Nl92ZCkrcq#UKbsrlc(-#KepU86$}v!W%NikuZ=UPT;Ju&KgtF${T9| z#28CR#+sDac}Ij~3>vb|BapF%$bd>&X0X;7Yn^pqicFoxk&Ly@f`|x#NMu1tWYA;} z8ACA!1c)R%>y0yjf+-!Ad1JvK8AFf~2y+O+JdQUA!b@1@IZO+uG|!7IMR|dl=MVtJ z5~4L{+tbbshyC>A>En=sF=!A|N-bmJcGt_w?ivMPJ(sIOM5H8BVP;{ry}x^Y?z!*@Pl%JvNu09wzjp|TV0MESkS_Xfzd4`h}FNJvDMitB%g1fcBPUrqo_PMAYT z#UnBM#jL493;#h;<60-u(m|d%pTX}5eScEmlAGSZRGPJ58z{+haND$@g zE2u;uB{mxS!=8@)?~xKaoImC#{lI0LlyJa0g@X3saXA6kB}A8QQK$A zbElZ4IX9@IF8wcNhv ziK+m!7AX_IY911@ewL^ z5H5!XQ1MzxRjbylvMxrI&U&8J+(xy&MeDYucT!az0CWXGNm#wXsyUx3UDR2|^@ep1 ztYm^nqJ9hY&rgDuW0ENHcwBLFw*O#AwVIg8HWS~LJzkG5D#aFxhgDq2!i%E|^TODF)y zNm5G85>tvPg~VZAa_;|-cnWC_ahl^2a{aFqm}4vvhFqOZaRrJBkrALI|IHPzs=fhg z`fev}htLu%@DRXuWnSQQsXQbRdsF^P%tWl@3vb;HZk%bX*C zQESFEQ&v)5PTQjT87QA+w6?D%Mv(oVi`6Y z0tkWq#!G~L(*qGiLE^(aN)+QAG8%8u5CevB?z}}~ob_l;oDsQx z?KYbb7C-d&UwHm-b94FRnyiT-cDy+AAndH61ahbEfN+_YZQtk9Bmhn+7y#=GvVbH6Nhzind0E0dg=Ll$C8ZS7JdP=) zoQcSgVPS(f&2vmlXb>St9DKjsY^-zhG(P^|sZaz1%m9oal9eP;6}@WgWfKBGljp9W zoQ%x`pd>&S0bog;Gk5OYANoz=1cLKCK79BdvjH;2a9$pKMwG0gU#j__%J*u)D0&D> zhPBp^p$Dr8W@ZALJh<(TS>iziq29k`gPjMFrlbftIvN68mr;2pv5MiP)_ewo6@OM zVAQHgDhc(@W&(9eZ(V8(QUCy=s&12FQDMOvZHykS;~-Sz=4#hgWM9@})zfkvyH*7QMfs~5pkGy@#3OYU)Flp71FZ92 z-_tycx(ZDLt72E+f;X0ThKRnlC^^ zky|AZgoa2e&Zvq(zTpT8f`Djtqxu3V{!Y?FZr9zO?_1}tc2kE@DO_?Ctg<_7G?2Cf z?X=}StQt-^!&qUMHeGR=!nNDeeLU0f>2$dt$kz?^EX<4j5 z@%|~5fTd#oV+Qk#D9Tr>4v>e@klw2K94i3rpC1AF^|Y^%gH;-S3F9cy}Nyh z)cY%RN60Zbx4q@GquD~Qd{&1DD)_Mq|8`*cO{D1^5J1mkWE~}9)(^2L$N*BDiCOLO z!otFoU6a+y-v&ozvx#ta1QPYu0AV0Yh?tTfks%bUE_ujN5RemZcAIYKjkO{2xF17| z-n)Jnj5UTRh7^`GY&+NWmP`oIbzVfQb14ZRI%`6h=Vg(UCQ3WIHQvW1Akr}ONGO0| zN!9=v%OEMmWe%Hd-@7iQlmgH5Bq*Ehc8RImZtk9)jZ?U}zKKL9!?4{B2(ZlaGSB1n z;jrHu;HzogIJ3KV3Y^Z*@61aAG$}3KdrQN-9O9BVhR#xqv-f`7ANJ#ovtrTTf9VA> z%rQNGe*fL~-vI|NyzsIA_Fw(euYdm6{_fxY8~@Ee`~SW4%8Q@=?8pD`55D>6@x|AF z?U&wq=iS{faOWs4|Nf7EaBA6h-4}l0=fC;wzj*TG=4)U5(lUp)-hJB+_UiG?lZTJa z@7&q!c4-OEy>xH9ny<&3&2}@7)AKJr=LmoN`nv#fa&}^@5rAn~;u5E66yX>-#h7vu zFhc7rBE}_(087eV%vG|45IGmOBDB^3G9kt#S#PteQ-OyfLsYVBD8WS=| zCgmM1`$ay8AFLVAseKw^XKPxyz%e9_waIm znW8vL*+T`h6%v6;9M_uPgr!Pd6_RTCXAnf<;@2n4l2RNt-Q7EPx^Cc<2+hUS^~J>p z3?2{+n&Q-Z>$tLEdCwlK9^X;%>MS-s2}I98bLioF!}SKxZg!Bu=?VdUlPx-e@7Ks4mM?_B4s?VPj5 zI`6F^mn(spg88j6gqSk`X$i2B6-gr^NHHYoDTn$$l~H73z!E%Btn*YM9+t~1_Ee-< zz&xhUhTIYbel1X8R9I5kI?vw5hNVx3);1kFq~b}p!dRK!vtts<~QrG-L2 zHCC2iiZUw&LDp#9f?*247fu3#zwxElikXp1{ZeLL4+Jv3*0e#;*8Q!g1E9_;#b#MX zRGrVNw+_)d`(;+CwfZ-YG%2ex$r?rX>d{l8U|=o1R+nSd35%YmsjMn^UzZW9^Ks_C zRC#K_Vkp`%#r)3#t(Ej|E5R$WM9E2sj(}IymvDXLBR;6;x2gtf>)Ms$zdiUY(uD8ThYDpd(FbR4-l5$H+;F|4)qb5|%9KLYn6o zVp>uQ|$K%REX&OI5YA8c^1!PWwkqMnfe>f0W&-sJhH% zlZN$YP3F;sj{@-(TVpx7YWL418h>E)koL)QMKc!uXRME0H9rLRgjM3 z$AyKONabQaQHE0XvM_VWie1zH=YJaQw+c^#I2nT_`bjRyztW>|MdR(y}K{m|HhyE+pm88S3mXg=l7C7XxBbx@?|u2JpMCu=UVrD^2lrmQ_lZw^`rH5E8~$!L_{|6Jy?vF4o0|oVTtB@cW5UeazI*iGNjI36UU`1A-F*1y$^))NuuWT!C!fFx#!-Z}4F_N+l*ObjR} z44j0cFhh)zB8QMt3QNcuW?TYG0(GNePAPG&8b)MY zk4p^EcNP(hrChm20Emcr6W z$5}4})hh~f%ko8?cvlA5GN_hCLV*N`Xlf8}IRrqH4}7R-dPX5^j)Vn~awdSQGf&B$ z10}7nT34Zf;Curifaa>!qkv4fYYZgSs8sJtvgD6_QpCJe6A&Gz>p)tlf z@4fd~0kGCPXN+;im`vY9&XydYWDFr1T5ABCocc2>Jtek5T|lZYNI{QfKvWUC!oC^; zj5T+2c1eHM9jJmw#A5W8K6eCnD-IS#6NNpL&K&LP z>HvN8j(Tgk{0t03P?_F-*Vw$ZM>>Z!umH9H?Z}mlP`hGzk(vc49Bz$((3dDNHd83d z#@Y$hN0ft#s?j$F$Y`K&=k z@6qH&&#ZonL;+yUc)A8vlwS+M7v-=FtR8fz`pqCIN5=s(M@})t5JE^iFCnrlk+bK| z9OAgdm{o(FrxvtudsNLOM)A03wp?c&4g8X3yrrJwYRF4-gz z$z%s0BqkQ=d+(gj2frc3oBf`JS=cydtg)SU%3 zH=E7l$Jg7<&<|a=9UuuC={g^lFkWBJhbc+Cy4(wJzv<3S&bsX|jw1^`e)Lp6V1RUX zzMDhjak+PPA~D`v-;DE|5^@xgNJM_<&o`SirK*0 z_Ax%cvojzszI?B9?#ZLaZ+`Dh;~ZKyuW;~b@Fe9NQN0g9I*r4|* z1m_*cvp@{ zIF2!;FijjouF1`mv+ZQofRL*fBLadX6`i>H>>+{y0yO)>jC67D&K*N20C&z$=V{*G zT#+}`TCy5sp^D&!2Ua~`WkVI%RsM#}lUU$Kd1?iQ1&|g|i`Dep!1xSmbqrZd*Nis^ zpoJr_X|JGTg;^`CJ%VX9v~mSwMVc0TT;yYYRpG!Z8_!dWgg}rj_vLt_Tqv$gl=T`l zt?OwAAZm32^jF>FWBRc2|*6p6|@tt9eaw*GPpX)lkSrN|h-7 zJac(L6i6YU!kFyBuYyfhS%$?{yaJ;lT0jdjtTK+&-d};s5gno)PqPM!3XlLZLMh}H zMeyri{AAt$#j0Ow+%QOW>ler|#2R^6PZKl@INwk;mX=!D0Crss&7f4*6hJhoRn@}) zuyno{NVC4^8|og!;_2LwPu--tok1b= zNaq72_a2O7^g5U zAtVlonY9Tb$aR0#o%@WN{V~ukLHV*mZB)ZXC7n9rBk;bG4c3Nr#h!V#)fV)0;@L&` z*`M3Q(_Amj-qIh`zON78IxDJ`CR!b{c~K?XG9HaoI-=quidesBI$CdULX+#IoDEEx z?&aBIA!F7}-0V$IM^9k^_4di?0vV$`tu#bPC~Tc0W1V+Iv@AJmRD#4IvIvu<6xn&- zb$#bMCKTpnj)b(`ZZ;>|%ZnQ%aGnfWGDg6rv`qU6fV?L+bV(#d>6{agVc3vyA}NM2 z&odw!pcG{|*~Abns_Ez%eB22$-jNo|oy)$C4DXVd%L z+4g!mJpAB;O}7d25;=K0eD({U9_;4zH-0dWqX6s=BZwG-EVzU~L*~TNS60h z67}XCS)7*v01=rv*PR7~6jN40jX}=Q9RP?>0)2t9mjkCH0ETFq7iWuAJD-;4&~T1o zy*0*4VkFr1XN*fsi9twDle(doT!&ah7>USOgM?vD#t@JtBOq_(pIqy3MfCNCrj{|d>P=_i8(RI;Ec5fQG^q4k`PH4 z5fC}WSc0FJIR%N?_|C;inS~jcSwxcL11koAm|_xG<{09_A)fEf`_1m%_dgh?o6|eH zVc1$i5?n%D!V>2&F3U2`AtvVtNQ^Nxe^=gm%4jv=G7C#dw6fdwckkXqB(i3i!lTC@ zPSa$`sK_g#P#T`166siwD`P^f7nH3wL{wq`hzKK0D$rtM+SrCl(qyVuQ;2g&p}5;2Y7U>`1zs+;inR8u&`p`Wa@;2x34pB!;;qloOjg>g zO~LB5vd-Q|!S-hM+kU}HC!$p>3N_a2EiZ$*V0g4weztm{{`;kC$6Z}@05n0%zJ{Y- zR|X1eRv*;Vfv{>2M`Wv#cb37cTe%r;wz90Hc z-}&xvJ;oS}C1lZuVi`crw=SwgU?u4u^aoPsVZ*a+a6y==$c=k?|HpT-O_8 zmT3Zk6eFSxyX`bB&J8HkcY`0g?b!}M!u2xF)79mZ{msod-J}$J*Pq|HbMJ-c#+zw8 zOh5pftaH2F&H$n{lKATK^6{gm0!sqyoZa-D>-v7^I3^)M6cTc#69_5J%N(yRpKz2E z_;X+Q^t*4r!vcTn@BC*Uyz}UVSI#&7?63UNZ~oSA|JO|L+NWOr^KX3r(_i?^s~>yu zxBuzC_^W^CfAsjl2mjqa|J}d&_x{>U;M+rzrQ>@xq5Q4*?i}FKZr40 zKfNBd+s)R0?A4bJ^Z4FdA3T2a*bsI@zu%9;ZYN9P6a|2s^_{H}5Cmh0h?qEAK#MLb zNr;d|tTl=>K&_sLh@2S)b4-boAadaa+27k3YfX0AvDPrNF=kl;bK=Bk&>4$_EZlXQ z!FAIz#h9$MNMyb7){-$X21y7A#u)32BqW0&B}pknFqQz(JLkOJ-6gUYZpmipuNC+`#)o>`@=lWER2B8TQp_MGpi}7c=(7gBk=j1^Rv?v zvIfzNH{%D79x)_B(&O5OxngzkRlb=2s`;6-u?eaIP<+5t0YGCk06>4yAmCLWAS{MV zqmC;p`Y&d4r~n5Mjk^0+2#h6u@(7GUL0_47uDU@5W1!z;$*j;HRf#IroRvT0%A6&a zzwo|uo%gPD-Wcn02>>!KX96Ote*b7z7a%m&kRpE#gwE>F>c>9y8YCKc%CtGpWcRgN|V z0J5F3L98BaB783>kd5n6w^Jb zd(lx)J^+Ad248h^SS_w=KaR(C1SBhbUgxP8@wNP|Di7HcT659p(*iZ>s?J#px)lP} zzi*GQHBdK0t64|0ZME?t`UtI|PEnf_9~%u@fqkyH$;`qaiucs(i5nDKbdP+$<_V24 z#h8{kr~FBWDa;{`b6R2==P)mEoWs1Ns5`0Qt4gb&bJ9ct2vn^D>tf};RTcaQb!$WQ zaOET6JTxrmmJZMo;;vHRnjShuT=XC;4cfInMMm0)~AmhrH-a6*XKe&7BS9PV>zY#Mi$}3 zAYcsn&I2Hlv1FXb{eDiI5D_@VSQJb^j4@j8a{Be{>B-P=$ygAvV1lhwDkq(Cm zF>W>+GA;!sL*ul}3xx97&wTRaWcSj`FaPfU@NfR+fA-hD`-9hCc;)$Tf8z&) z+ztIte){fbzVOM52Ty+Mpa09h^Y?zEv;Cj_hwq)=J-xcTWSKYp@Y-iTcXGOW>#etc z@a-RRieSWacG^c{008~A73jir1HhTkSA8SAsAq3G79U@Z-2nrLS zaV~=tW5|%ruK)AA=y^M{aK_}ElJ7c6Y@OW+6lRXrIv|ssmuAEc zanldJ@0@jHFa(ywwzr+}iIcSsM2vF)(R;@sk`W`4gi*v&26iGTKuAc;AuQ7}9u5c` zra3GN0CVE(r4VD_6hn+4zyd_bAb`Lr3K7T10wl<2VhY~*m!E%)41fQPH>dH&dK4CG zO^kv7WXN}Y*Y|zbZ8y8l`k2E0dVhU&HBM6s0Zp#1T&-^?IfpI^A>6-r_w@7(08sGB z#pRQyAEGhHn2+4)xH15Kgb2FL0YU2klptWj90QQ^ff54MUx=uI_|#MYFs2|DQY8VK zs$QCWWle|Jr~qnd1wbulRKLT@6fxVX*JOXVN^9k-RD6I%|80>_W}o>8-8tiY=e+Nn z^En9ET5HI*Cjce-mr7hj2>{3$k}~`@dL&XKfHSfzqtLRm*%(X!qN-5=eIO+wv>p_| zEl8eR;sSD z9xoJNiz^&I>W^9?u<8P}7wxZAbHEiIic)wT5kNjCsf|~_t?+84;ers4m?Sn`Q;dZQ zB-gpqsjjnC^@VjGRX|zs*^2eowFQ1&I$b@zn zx&(+QAw**h0f?Xo5Sr_on_<%d7~lE01S%f#5Ju*cvy+q46GRgt6BAYtul9!+&QCYPc9T-t48zk$kH?$C>1pp= z_oXlV{I|dVJ>S{W?dIac>ytaXZ~f7C|G|Ipw^PL3#=rmGgTu7%+;E7?r$7I5Klt`f z{`}9s`&a+km%j1uet2@fd+Ejd-}}yw124b$i@*5j;rnm?=*^ct_VOn`_1ar+|Mcx2 zzh^Dpy?1_jbBzE?3>?K-!vgahQcQmE!_e=q4k94PfS6)JL{54vUKpepW2%Hi$O(Te zWMt2fIAsaP%+?ynJ~m{WcVP(vJTD6;HU>NI6Eg_(y_@DG*9$O6LpK;8axNxL62d%Z zerYUOZ$W^_V3MoEJ8Qb$d*=m(j3vYr5*j41o$tsJqDNx`j3{7@%~I4l9~SP14vCDn z2oz#KB4Z7sZ~_G3B+fYF2#BT-9T6b)-XoIlU3S`WmXH8hjKP#5q=X_wh`>g2T(3Y% zoKje(WgaD@Y1%LIOn{g(PsPZbI7>`GB20+^F(np(#7UBf#FW5vHiSh0p1=3}os$=S z^7c<3J^8@*4haYh5~P%XC5lKA5GG5V@3!0Bw%_#K7KIPvbhE!XOow@%goT{Z(?U#~ zHod?1+}%w-5D<&J_x^)%no5q~mY+76L2t7!EKPkq$;XhuMAbc1vQ1VEL9n@^3!Z01|(~Z z@4C)=XTA5%l5x&iBC8sJC6muXiUNQphYJ{EP|v6eM@2;aJ%8#kMh5H^;w#u}!h9=k zT%n)BNHsJo22{9TaUxJR9;zC!DhAmRB9j7rewi)C2{r8x8MWD~vQ?C&g7@KAJYnt zcO{gTtZU>;q4H*9WGI^9AQ36FSQiQ_HU|Z+D>!Slx2mMU3eI%h`AE-Ofpm*#bN^&@ zpjVuuI>E|t6jEc|k2N!iwDeV~sq1Z6cWz}|McHq{160q?IdK)B7LcUI5QI7l2stJa z+SXg9A=O){g?h~vfc5JZv>x5DqO|4+1y;Y4+e%IS94Tgi%t@fs!6@GUb<8NOMRj@0gOzTeU05W&@zYHRP7j{sWtpeNSR!MM#jqqv0wPGpca{^AL1UcjyJd=<^WDbpZ^pyT zboSh-BoL9!Zs(odPlvDshqT+BjPr8XAG)CfK@lcvt@SZ3BJ4`i9yv^Nm}bB6o6W{p zE6j&+Btl0<1m>9|Ga$Imdf%a#v$H$>FeC|w>zm6bA70;FEn$Mhr{^ae!FK)b{8WN~ zh;!Z#eRfd@VY$A#+~17dV7F%{BxsFu*35G}T<@oOG(;(cW#R3vHy%mQc{k5Xit*(1 zB&Ex{;^MQPdG+-lzx(2IcTUgF8PiXG{NuB;(_jD9U-|A|{P3k$p5OJS zfBMIN{^ei&;_KgelPvuD-}uY_pa0wM1e8zz;-~)o@BD#18Ghrhe(hiX_y3kGf8po9 z*lmVyf8*QJd~x9L!Do|X_ouFbVf!CK40{m{plSlByn4S|^4g0W`Z zO^BSh_YQzKiSZO!yftJnMX}a0h_TKPdGBLj>&ba1EJ!9ZY3rOZ&Tl(mK%y8EP(m^& zSLAQ7xXGKPU6<~+#6obm=?j+E`$B4h|8fkYI^9#Mt>fgvRTNip!U#Ce&f zF-}vM=ImL7%u5K&Df`-yApuFLgkB*+j0u5q;q(wVrX(cubhvYN_qpfpKYnuc;Dd** zLr7u_A!15wi3E^^5ixO!Ddi0HU1z(#8;0$6*bq<%ah%4(a#-e=LI7eGIoWOR-M!m) zJ|-Eb@xl8a06_IT`3Q;h5g!Ct&E%P(7RQ%d`&M0mi~@Q>G?bkZN>Ww6B#Xq|J; zcfQLRqO8p)0HqL^F=UM;B5O?s{W$|J0vgTuL#FX{(vuE?74c*7q*b6ugrb8LsAI0- zrn&q2ZHxI4HR4u>ujsWp^y{qxtD6dl<^ye@Kh}8P8si6$>xiwge4Teu`)XC8@{JnX z2^B|z0zAn;y}$_(5y?3#M3a7IeP9g+;F7WsfNk!$)R!w$sywSC9I0IpS$n+7$STT< z1eNM3zJjq8Y2^74^`nL6dj3)rcb4jJ9v?+9*Gg$<9a+(oS_i&&2!$|wr}T9wVU2-w>3_D4aE_3PGW{Rn^Eng)cr z0*WasG%L3Vs8$S$mGWr0Qe-S@hQ1zsv}LIhw%~bOXSxtc zo%^+&G7~j*P{W>i{dLvW@aQoFU_B))yO;CnT{+Yf&FKyToH)f8Vw~q?iD{g|w8U`^ zA*68%;~b_XF4P7fZewTG~5K6XiR7JknS)}eBRq%`39%;-O5HU;QWHnv25o8f&jv z4V#|Gq?E$EOyeSwkPryKh=@%4X?wOCdPj!(en^qWX>yjl^I&Lym@FYWTBgX%_dk9o zjGRQezE8|ohtV1{9S;6T30!}f3(ug05snhtT<7<+d2bhq1HU0uhNhEAS-ct|OPv~Uba21VS~CQ1@vnI<0w z>*&RgJ#RXoRs@|XVb-~7o>KKAwx z-gu9#y>lmh?XQ02-S;27{o@D!+yDJP`r|+PiwAE%{#*a>H~*Xe>;L_^mtOnAFMjTu zfBMaPuim+T{@mr&lZS6UnfS(R-Sy33z8P=!2V?!|bEnf3taF>*Up>7NVdotJcHYim znGX>}zyOgUpd<`R%7~QdpOYZzwm}4BWg+Fb&=^z7&+2|7qLd<_;4!_bEiIj}+AkNe0>L};xD=d!=TvP3q{%uCo`?}uT)K;6)L?`-c< z5)ihw0~BVCQPgynZHu{7wh$2l=hVp}0GtSo_1*$GgVDLg`DK}M<{s-@j6pQ1x*&v@ zQVPOAWSBCaMr1YwD3U<>ZhN`En#1zK{g<_+k)|?x{?J%64o;|&IVk~BMQBzpJ z&;F>@;+6<6gHSf7V5P{^6=dM*r+|t_SKH+3I#G<#joH55nb{r|7DubdE)u?6I07)m zpSc=DOIo@H%}Es&vUW{c&I%b%SFe3k5MR`k{704XrMIg{tgu3*LAi<<-`|?%V`!>E zs&NQk-=YvwBSLiva-tV#BvkIw>e+v^5FqOLlimF@63vYeDxOEE*-45ciB@LSj#sr% ziV$xk7OuXgQq$Us2ALs2uAnWf-iNGnkfSlBw8{(sxhMjGFcAL67hfw0!Rtp8{zyFm z$R#$^!r$Hu0`&q^7oa+CYgMme%g?$iVB>|>L}ujWsXl9pk@+Hh!^v(VNybkCH6b7ooPF4LrK70EMAeA1m`v z_Ws)225Mr{Z-iP`SPgve={<|U+Yj^iB0IZh!S=6D#FIm8f{b7^5zHM?S9S!s-_pG>of@|{(+ z!!~CH9Gw+NQL73y;IYpW=q!BH^c{b6#h>}&8P#9(>Jb62{Q({0x;_=WAFHCzeso+% zZB`e*qiJcNfBQqXQ#+Nn#t5J(tLwzqLi1ITkzA;&G%El=h$SWp(Gcd79qq3WQO@m? zr_nhJK%Mt29AaXQF(w2s#t2A^Dch<*kdV6V#ydB3o2#3vX+1t}v_J^b4PBD7j47wwX2Idajr)Z; za*ROaoD*h4M#v;F7IAyJvE;~FF|>?_$B!P)(-`N43=MrZY){Bq-)+3N^Eeyl@7&o$ zhDYyzIE}M0;=JuQo38H;hw<{sB?`FS2=fva5tf*`z9VO1V#+0!*q)s3eCNh-6iEy+ zUQFH*c{^)-zU&wb%@fAR-^xH%g>c<}V?H{bu2-}uURzxA!F%lVhS^7D@$JbvfhccX-P40h-# zVdu@T+s$!8f+r83a+J;4=499&=4qM3VLz5Ku;mz;1@eKu`haE0fW>r}lXPX2BO;QE zH)nrAjmpY|CL&tmS44mllK~Ly`p!FVt(m7V9!5kF0w6R*AYiObO9TT$*L&}c>*i^S zA;uVXXS=i{BpUi2tpQxRzFQ%I6h4AzaJ`$j=emEo|JF?2m^A(GZnj04jEFA}|#pYqlTE$%4w2!V#&Q z1Bg-ce#w&~ppF$a4j52lRI>}l>P4X*yXpkJ0)~qJq4E1)*{kwTD9JyHi78`W5kVwt zZP#_)duMFdd1tLP)=)kU)mi{V##poF{?EyPOvx3RgGUhz87LtQV8}p)=%7Q+e^%%T zYYNl?{Nbp06jiBI+ggPbA~nhWq4E2#YL((u0VuvbP;bcSreN19#u^nOYgG*_DY!5H zQ7~hHKBCEg%JgPSKOlp$pEzclMY7#Kzg(z@6ySyDK2GAr9Er(iE$qyCFuPOv8g0B~$ zK3fR8U1-3X9Te7EGn=S%A?0lqYd84i86+c6d_~GuR~Lth;#5bdhb(Xm=F3~SB$sHL zt--!ZAy`{nm5GX$@zx89rMs+Q8{H!%miLHX>5LF4Nv>=l>%FV0BlUiOYT$2Df3DeU zu?1+i=B^pYI^RnB*xXYn?P&UCeZJ22t=DMRn@|niPRsx~)&)Sbg02c%eJvtM4XIBO zV+=7aF^to)gmg15bKr3fhcWDzxF4sKAp3KG&ie|O0if^}RQ^-rLz>JH)y93~+_WNX zS%;-p>WN5YF;M6vuRx2IKjKr(D7p^q$-uKWw=H4iWqL`VBoxNl?H0)EtLlzw)P-i< zi%LdHzIFVfFTJ(y%`IvuS!W0U)Je3y0xR)lT}lOs1{>t}N(n0=G=_?UBm*Hp$@oH& zN-Dj+@2s&oW5P7fDaM!*r^WSs?hmu{LuZ_g3vYK@>zyIu$m1ATQonIwNsuIQ+U_=+ z?QR<9B?Us{7`yE-jmxmzrpV)TAW7HP9_s$<&7|yQnEkp>dD2j9E`QwU600!p!WkB z=bg8fHbXzBFkatGW3&b~yWZK(7+ONOy1ZWI$#}HJh9!;r(Rxb&+tV!o@e;ePbDM6k z9fIADhY-ePS_IM(6A^evmrpJb!J<7s-*sJQtoems_$;D%^5KVX{P3;Ii;I_Ee&LsY z^DjOB(*3vJc=y8xPyfk3`Ct9szxwYd!29>R-~ZQt_~^mY&wc5WPap5!`O#0m{Iy^D zvp@Ux#l_=pGx*LQE)Gf9_3re}T}Kuq9B!rv;q1;Gl}Dp6m|eygk|WzU#LeiGYBv>-x>s5JhI@s0)o#rzC*-5Le5CCY@ z%2DPYX&Q&J3gv78Dy-K;PF2Y(jb!3(QvQR|a_%NH%ME4mDki>_`UC6!P=wbYwH7?d zy7}9wY8Drcto}+JjX|@4I|3?f3jM6DR8X~cP@5=xss&lKiHtEpaW?`mW%igyq_9}g zVND*Yib~}O#em)nY*ldE-y4;i@H!mT5^#Oj;?pc;(fFuT-&Wt+2A% zmB1ALw;vr}A&{1aikhx}tokw3XO5@tBd7G)m))N3pLvTsbGe=qHV|J{+CUV6%(!)? zbs!({mfKyads5dIZ=rm}{jD5>hANsfODyrfW&4ZpdWKdAG|ONzrkX+O8-z1I5rekt zJ2W&;6C%WvQc47vld&TaC&}jqo%ep|!jd+-Eg%X@T9#=JfVkcEhr?v8>xK>)T<^yH z7!wb@k1-9K{_1i(y|ZP;>&r{yOc&A7k0+{a}K%VM0_ot`=4Vu;2$KXhc= zcIdmVyS%yLg~_1rIs-OI49ha@$7!B8*PK_@VZ9?m#u`E+44ciyTEi^!IHnM%Wi|+s z#Cgg-Go435WZ^icle?Sir%#Nvg7U@B{lcAl&)>Uu^6=54-}{|E_=PWi^8D-+egD$) zcZSXGjn`lQ{O3M<_ujqV`lr8rdgo5JvE%;m;p3-ozyI!XeFa3@?M4KW2y?o=-Vc2@ zjiD5CB?(KM4znA4zp;m#(Ry#t5|T64Sexf@oaT9&HBzX^LJ-M@+DvwmIF~jhlPe%0 z3#6D*40-P+W@}6)#l)QN6%m6rrjTNE-T~5Pw=)Lk!!k`1ncPAewgUo=oq+nzz3b;2A|Bs5|W1x27Ay2L`cqOc)DxP(MVA{Ze8!{IRZn~nvXBkP>+x0}r{ z9)j_v_uc07L?RuK z3?Zb1IqyCLaN;3V7leLJ*c^3CofIB*b8lVu~D@h{ky) zV}xOe(<`sMN@9Nc)?3yaNC^#ABaVOw5aiU=B7mh(PlkupTp}Wb7!xOmg!IyjFK#vi zkvSa3x88YI)6Xba_}L$oNLZ!0fRLpc1YEKJ5gJ+*fbvT%4giP#Vv$kZJ{>=2WbzLj7&Em!i55mvB{5wqNcjyn1E)@mdxXVW3tu%~6;FIr zX$4g)5RiPBross%!*d2GmAr~TWRb)Ig24D2zw{}nD8HKfvmq2#7ohTm+WYfY<(xo4 z%6bHlhfq#S3XWG=1w{1+!XsL&K%CZFL20x^aIATnNTI))1yxrQy$2C1Q8Wv=lEC^m z>eLtFuC?6sCa5%07wH(@g5m^)WqBGZIFq_e4GWNhne#DC(_jl>D%!8jV397_qY*3Q z7io`@R-=cPH84x^zDTOnu4ec=dG#M=kR&O^IfM{-nwKer zX^w|EPE*{EVL#1d2r;Sljii~f);>$6k3y1_N}o~qs?Og))~c<^(Qpc|<`V9c4?0&p zq0Z5IYM^WKtZML)dI74bYh_L!afe2O$uoBS%*={?UA2N5VqTQ?!tK@_QLfgflyU)- zlGiRvhVHz^#jh%oUXsE9G;fc9&TI*~2p~3ZRRqjg`G{ma>MZ<&nVGX=2w7*zP~UgX zxcz=i9Ab=NiN@tB7+|gAm=a6hbzrFLyUw`~xa(YqDJ`70VYlgkC@rDuH#vsu>f+iu z3?ZJJ?v^E5Ln%VP>0(OrerAq<;Cz2_dh+D)Q#bSy)Acl;pY+z)xUloycnbn?30H@C z;}HxH*)Rudt@Bn0IRU3c){u}zGwinHO_-*6n&&VbZf-E9D6%;@IlF&8A5!PMbB+vI zXN|G*G$M%WJB!^oj|OSnAI8I;QGhuyTjva*^&SlwYn<~rhi&IPGb}NU(>~78qRdkO zL)*=8ety~y{%{yk_}=q(y|ME$#wk30@?pTZe{ivk^U1xtpa1M9KmCPIg^@2GUjD_m zzWZPP@BYER`B#7V(#M{A@cw&W`?X*G<~P6du~(kEzFt0f_nn(5e)Et1Y#FEfuROQg zZZDo(J$UEI3~}2#*Lgy;&Vt1_hscr8gn5Z9lo$YGOi`lmoUyi0nIHpJJU!(qQaj3K0c*D=D$$*FVR`)&z~CEpKy*L6gg{oJ~~o2NN0OXRpr3!1W@ zI`5pdzITQY84y`mECOX0Xc10HI5}r9herWOc17dFF~)h??+^2MlM-8FGv;%~<-BVt zC1#G1$7z-%iK7Ul#LP^9A;y>z5VC|Amsel;)Hsfh9zJs3Fmv9ylH=2I?Jwm}E0;w8 zH6$|w0wiWZi80;1dwTD=d)7J*{NBSySJ#)u*u2zhZ0tvJPW?snuc`ppZ1|_@1w=$( zGH@>*L69-OQNL)d3{bF4#!>mY;-+jt2L<$+pHfo^-Nw5B*yP3m{bfaED=$@cx_+rr zva)5ZmRN)pfpM<$UFSOQT<4uJ);Vjao&Z=Pw2cCw?my+UgN#8<6GH}%kfVnAHYXl= zaMjgY?Z2z*Nm~I8p}Ll2sj5-JL|S|q04aNrm6+gK5?FL!gRVqbZ7SuF^E-;L*CZDC z=3}6uf{iF!+AFjZu0f#dzfB@=QE%p~)v`)=fs8u1)CJRHfdX!TSwL*|W^C}7Nb@p< zBchzGBz{o@SnaAuPeB2;4I0hgP>D}0yG#n6RS+RnjV{hHl8yIj5XI&YO~rG8r}a5p zai}ObkfUj?z;`v{=h2q|Rk(l!z_#$WMrEQpVdvh~!M6Af8^x{sz&f}hEp(o>T_~Ig zE09_lhz7sjHV7*s#JU+l5tkWcuvrhzd?7tb$5vM5ALu0@~=cm-~aCS zmoPqj{PYJuee=yXUjOQ^edX0pztZjK?VmgXgjZhs_~Q?sKxZF5e0uTZ>B9#PKl$^o zUBCbOX0R{4`g14S{`K#?B@&*0@uV9(C)}N!A>o^EzAgz8ixAAqzIXk0yRpvpuJ7&1 zVSaLPbrt6&aZcxNgvc3#XtINUIWGd_#LOHer>!rQn1mULfH0@`an|LkzrwOCOX7qC zn2@Xi0mBeu%q~WV76fBV<8&Cuo72kTXemS2Ekahlaw~0fp>&)|E5}n&MFfZLPZG6euYF`Hq_15e}JZ`}3M zi+=F1JL~%a5pVY65|TC8_Z=DHL$KC4@3#GRnL}JcN{J;IYgjnWkr9kFghB+YdVDtF z0ueJyhT6y(-Q`Gh#C`xFfN4AkCq}SjlO!?*)n3L7)?#E<2E+y-3L}6sW{QD?oZI~L z?H_;Y6R*wF+2zHB?+r7XoXJ;_Kt??(!Lz|@jnFP~IAcPBX_``GZ%Hhip6;%%u7tTj z(0b1JQJ+=bzzUR~xm6joplE6cIOf30nUpbO^Ru|%10o`2*alcaTGbI(O+^(XRX7Tu z&gey;SL~FbEVUSqN1b2of3OXy!z+wdC>b+W~t(eR;2B5;9lJZ{< z71TLMOPN&Qs?m}~l9%HEMJlK!57ovH^4ZfG+KWY{qpF9gkD4lXP&82e1wl(atocEq z1ZUHl!m54%G+F@bkJSqf)~|GB%0*Qo3+AW`OhhZXXs*}Yh*QDf=87@Y^U{^}R(Pv`ntOr@pdYEC9E3Rp+p2b8Yw5r>ZaQUQ!nzQ5w$W zSCxMts6%8XwInReA*7|C|2Qx4W}K&x_TzGx<9-Y`#WZ#O{N2VOWlO4)nE6p8tAlNkRg8c(=T0Hl@;C6u-5L)bWqZ#Hm#La$Pt^_rdyBZ z5FsTYt7S(743XNG@AG|Rp3B(W(jrUHFo$0*q&|pYu9uM<4GKUzGM0TAQ zYrA0>h8+ny=Qu?}w1n9ha^8X%PLen-a{z*Ae?TJu=!|t;PsUpBViH0DffQrcdm$ns zONI!IwcdJ&xTHBjOd(jp!#Em)&Kd;lx^9`5o9oN-yXVu*+;!&O-IJF-_H*}M*!{^L z{_#)Vczf`)METSwe(qDBd+ksD{Wp!nU;E9!^5bv)=>10z&R;tF@ck#wnx~JS{H0(1 zCdJnsJ=t zJfGh?k4rSpZZ=yY)4SgH{gT461VFIHE>k?eb2^7K^gT16F-WlA2Wu&%V7#%`j?-wZ zVaCmN<2s)LBT<;6^Jdr%h=@RBuM^_fXqugJ8)~YR z77`I+V<<-`Re@Ki1+Y@A-lDD+pcWJn^|YzBTvaVH1J{G+EGCf18SA^QbH4MPb1u96 zDa`c~7GZG{0rDXh}DoLCiC;zp6DTnXfaj!gVSh|0O(t z)(PI{FgORRME*+&7cs2B8kct*8N^L zw(bFeTDY|8OAXXGQUK~o*KgPJ1XV%=DpNvK&lx?Ps_=<$ed*fC)x4|rV1OobQc>R! zYk4ERyB^43!ST4F;_|5Ww@&6d9;^e@{-Nrg4PIQ&BJ>eBnwf@Qt{xq=&7(~Mx>85i zbXVz>k5B+IRRaJd=ENxFEAr?YJd~Bjo{BQ$$s3TGrA0BFEdayuH$;{;2wt_ErZ_Nn)K&fm()h71;uX7?kU% zcMx)R9WIVlhycFpoHfR{#GK+XO%pR`_ih9rV^U%=IRhLyZ@aFy&gaOHd7MKCUFY54 z$rwXcLNt8`fa89TfScWxP%ba7=6UJ*zUw;!G%a(8X|o+Tr5ID!xjDu-GXiYSc9M7+ z58Y-nA0`p(`py{B4;=tZ(-M}LQbH8t9H-=*v)&qOC4nF#;5>)TX1m!A!Z1#U{mnkk zQ(|_GQes2a_gk`l*mTaBJPDiLML;40g8Tg#mng!3X_*!l_MPiGpW_UTbH-&5??sa9 zymjvK$yJB~kPKNQ;slm(3BlQ1gO7XPxz2CA8>e`)zjS0a+a3|UwSwu%2M=F(>As2Z z@+V%k9lZbc2k*WAAcQ$C!Ed@>|Es_H{(~n51X8^J!b|VG{a$kXC%^YcfBzr--8X*p zlka`&JHz(WI=TGt;{5s358itm!`ux6fFzVS$LVqsT>P+g-X%#WV#p+xu*4-si3t#l zF}`!gSO82V>nmr^0V&CTjgloNE+U1QGdwY9vU8U~5)^AKAVLC>lsE}OTvB$g0+E!2 zg`KrIe`sV}rpX$5{)Oiw^Yzo4g+q*S*mUz@HjX$7A>O@zFNC-pW+3o`CnP}Whb;*9 zz4v`D0^?yGhR*jLCvaUCBlmrWM6T};F@|J1^XT0Vowp$dA_4*;Iz2z{{5GXDY&O$8 zCyve$qBSViI|SoBk+qPsfyNkPOfixrM+IMH)IEgTpG$jv1;7 z&wRfrF#x&nE!3I-m}7r6^G^Z&CZi_IN0B*N0C5fWr2>#e1As-thI1&SWD6`d;E7h# zQ*oimy(ERRndjy-eR=gV(kQ%F9Xbjgp@x$KKuNzOWK5|7;CyGjcg`5&oinyXLFf8k zHvcR|vI!AOL4Xnk4J8t|#zU{EjVhW~tlt`)%Q%3l6v^OTG~8JWypk4rLJjK8ptaO{ zC|W@F|55Z`0(?u-Pso;2b@wl^0aBoU5&LB7{HXX@)xvB|sKBS3cR{fsB7!h0u2bM5 zRR<`@9w8g+^TAl-7sOmnwpc_Gg5Ym_=~FpjP)Tf3wxR$u)xJd40;qZdt`&gSs;R06 zU{2AxQWZ8I$cic8imtNGs${v|R#A4<*z^V{YFJ)AtSZ`?I|vaqXt*l3je1Zuy0s!0 zs`j?R3tjOQ*Ix|ECkm416l>3`T!M_Sj?Zz+f<8a-G`2TDIIP5w|Z3_GugKP6;D>ZS9wrny|+Du zn*Ohd|3CFvHy9w)-L?Ls6b><^yv<6vYXLGQzar;%&ndU(C5DjZCGN*%3Tay6&0)D2 z=fe_0WL-RhsuJs&PaRIH87h&hN_G^ouo6c7P5FXqLRA;i6@Yck%Hak873FnN>L}ZM0&N*jej3I=SQV22gfb6krtxG9^ z2oiPPJJAx1c<{aV&I!Z*X3rto-tSI#gfJcE zX^z{IP2?mgb$ve_#uy?P+MevJv6qjZ`i%!bVDLkqOZ_GgW(m_0Qb-~8n-0VnL)JM# zj42WsLQG5A>;`8XSPXO6-|R!2IYjFSiNegj>utYr&TY0G5@C$}ZWBTXOCWOdv~c3E zOe~TT=KxUStRn+N##kgW#u7qGJk8S_A{%?sTjx7#JOHo+jw~Q4CL|;f>nz8(gk>Hh z5)8d#jtGXCoq?BM`q=gL(>Tq$JG-#Vpa1Mv)T636uq-ZlsGLhh8Vpu z^Bkk3?ERI^l_|s|3?gI@fdqiafCv(lptvdvvzU{Wz7dJFDp*Be87Mfi#u;HrF-1h_TCvQv=Mj&U9MRG3vX`GYDy?b~1ZgX{Uy+7;){{Ni)>8~tHk{^hfnY+i5nJ3S= z`@L_gwQFHFn;@kosNswt%}AgCLI0=#K^ka22@s?qDX^(#4_WM`_NrHJyYFsi%Pk_@ z%}gKM%_H)@S1n?)>YaN|MudmExw+ZT7B?3kJacNCPt2idH|zD7((dj}XxENh*EZyX zBaeU~gm&Gp*Xv;zo2C&~1z2w{RMn9O=ewp!EJ*WId7LGrZSUJ(&G zY}!TzS;Y~FC?R_9IVB37P=fb?JUQ@$%#kF6F3y3`d=7%G!(5_-K_wdiph7H(Q;K68 z}+zxos# zc4eI_I;SGV3BFKsS$v7fH8r_DPE*%+&tE)i+s=`@y}SGTi?4!rwMu-Ecgq?UOHq1m z0Fa{+0jLLoU{9m~#gTq;K0RR&D;M=zCnzr%2@xgi90}ygOP%8h=CjsXT0JawZ zv6e>jQ*&jL&u1Sca&(Z*IDCf`7o`k#N+sm_)_ju_NG z(STTn0az~?oz8Bs46|%wEOcOor-se6s=18vQ9(rtv(AVg0CEW{P!+Q+Bxm(xg-5EQ z`M?@h1fNmc`#w3t9_7`xOc$J7Est4^n;y1bYQCANe#QB#oIg-3q6IY6>KlH)*bZ2Z znPnJTT2*PynA6~mCDK)+Z|2i#q*O}Vh(Qp_&LCUI#hACwXg$x$z)*o2^NO#?ciH!4 z;&*j+R(Ln(Zs|M=GsBeXpEEUe-X2ha2>Ux`{s_-`Sh1Xrm9(8#;Z85%nIt&j23&BF?r?qswDHE-ZNSj zqtdgftnIvKT`V+l9X$e+7-qg*MBdxCtO~RwqZZ2npj053DV-%?4tt6!PN;z#A%Y5! zBNc^mQWJ7y@5?s4)w*{?;}nmFeM%yEdmy6sq=3$$_kN0rllJR2xTfnn=5*ZcBPT-F zw9W0jS_3m^$2{R&f zeMhAG`<-i?sw#u`p2)cnM0glaDJDq_ae@Pl=g_(_Ta}Y#{HNRo^sCns^-3;5m_A>WZ9B z96SrMHZ21bU+kb2u_3$BB7Twj;E1hQjOl>6!~z7&biGx97n!={dRx2 zN1?XEZqr_Wb^puwiy!~lkAL%bzy4qSH~;j1`>+1HufG2Bw}1cJhu?Ypy^lWr^#IvG zCcn>q`=dYqlTUy1yPyB{FF*YF!*&~f{G%WI^iO~K*MIf1zx_{tyScnT4~+8U#k0`3 z6ytt>`rw0)zWBqZ%-pwa@NTu~BkS>WN-<@)>O!sx4w6I>gjqO|b0`jpT=vr`AQqD{ z^R{~{fs~ko49DYY)i-UIB;gcK$G49jJy5{a zsvCxJI*#4CODQ4iNZ7P(M(V+P)%4-VA53E$jziOh@o?(bEk{mC7yyYv+lIDHDFHy+ zvTqzYCn9Abx0K=YjyU)SM6yBBdTAjw4JOr7;}^cgrPi1=87^e> ztnanF=i{+W3%mc;5Dv89H4K&*`lD7e%;^K(H!af#ADEmvY z1^B=ICqDq4Kd{LEsV4wHK}ni}1B)-ruBe#5L;!5y0OZah0P}8Zivwha0EMiB%S@H5 zE~`dWihJ55no*mlYgrq#Oz}LCU=}ahJupu&Ec~uD-v|ni&Px<47ni>k&XN!oD|zN< zQNdC^ODoE$;N}dg&AS4Yp9;l{oonVp<@TiovREC}WI5yX#USPnW?Y8(U3sBZ^JF&G zmSeLw&R^m@99nMaUOM*6ncF22p-Wh97Swy=pCRENb@MMQm2baeK~-H)&S;y5$mQ%8 z&haq>Ue~~iB=X(FlJVj0{`{Ou7-k+w!Dei~qa2jK>L-qi&L{Kqf!vuC!EoU<@ zyDHxA^~^H)_c;P^-opIPw@_g*ZZ#nOEd_^53&p-WL*#V|@%+|rC^LKGdlxGISB71@ z?YyH!tspI5Z+WJOIf+7M^9Q~`v$Nh{*4hdnAR;;6w{R5E+zC}ct-FzgMYHHdaNY&- z-KuLsI37=@;Z!A{h&I8w(4@qw>c}Zl2!6Bf0T31TheHz1Nd_VKcD-^$<2X&jH!|1z>cJ z$a(T1G|m$sP186|r|~#Aa?PseNmuKRyk}JrQI?z|(04sLRD?Lj)9Emsrr;emA^4yy zh>oaf+f}!2eISkzP?184({LI@Qj8H0oD1HErfo!k9C`BIJMh_;=~Pseo6rK$C=tpM zlP0tP7}JPCr{g{^G(r>=BJf1xcmi-;8@ev+_s7HT@c8kgbUeJfe*67D`Odpn?>Oh_QUm?>vq*Xd;a`>wh7GK=Xtd(|vH}%x+=ui|Ab8xO}n&U9GO+yY-VwTjn_F}skPP{+dcYQb=2H&_O5-0iiqYtK-?r!eL zkt#F|#H8MPWo_51rfF5=!PNs$yn6UBMs|(s`b|nnL44DA7X+m1R)@n;7`r~i$fzt{ zB(Y4%w;?oLb|$(ILfhs%Veim;ud2+ElZ4>BN1hUah=QYXfDD4V60uiDSRDVDgQx63 zK?PNrImNi&9S-~b6bFy44Nd6U3|~Lay8b05PU1u`qk*GC~njPVw2Z z589^x^mm_zl}k|rQHGJGnwHMEA}yCPP!(c|4<0^z^ypFWj#+>I=^v(X2+l9@!@}+P zt)C+4oO9ljBUeiRIm>p>wLaZk40I6+KtS6GfHY@MXV1Q~wC9q1K{Z5xR6YC#iO8JU z7DX@&Ja5!2QnsoL+aa)!dQSTRz;e9tA|?Q4LJ*m9UjnrEX}D03?-_jndGC91^%fwG0AOd?l~V$8_*>L0 zSuJPaspcC0zPj8C-_{o|@T!`YtXsn^jRNPM)ik8iL!5ys%!?``5H!?U%jg*3o{`CH zgl7q{xPAUqlig5a0Su)r`wJIHda(!#NS={Xi8(C6e9aOtTTti6D}@vQ?OaM&mFgw=ms21M{vFfi&?;B&nugu(Ra?>FVQ9} z6t%g8TFwWH-$5-JV^a#t$T$F2*lsZL8&gx+vD{Orv4FaESG5n8U=q*hQ-yL}FclG( zy}8-TkCp>xofRNdQDN4|9Fs816w`5xLrkZMPh&is#?zP*E32JHQir@GVu1vhnd}U= z+QOZa$d)oemqhq4{wz$5g&LX@TIcr9pUT~xU%ue@Go?0%!IqDgRaV%oy6DXvvJe^H z_WqgQ=U-|_0rF{L^4<}YRY1%kuSF-TR#HIl!6BJdjCJKJ&w zPRHS}-%oMMQFj0ok>EW!7so{2bzKvh7E}>*9EUU|mQq!`TdkTlgvKBC2}xmhr@k}sqZf~o0UvDjiV^HU6T@sfOj&+wBBwG_j`^KdY`5U z08QU2fU^2FxYo;*j;A|LEQyJzTlLc<{i=7tCzffNFmJ6>XuBQ}V~peJIK`wXA-cBf zy!XRt@|_1jaO7KZ9yz6y7?H+tC!AuM60`F@G#vtVo1TzD2)2z*MZo1ec*G|71mIAw zn$?k~lu}A?*dHXxB$FgYLPyZFErJFYRER*f+iglCa~cNeS{kHH=s*11|MY`D`@!SK58l0b^YGc~V%vTE!HcKQt~M9jDW!`?tMzvE zyTAX#pZ&8xI}N9=UcXewfBUPScdg&wzqx&N{ouhva`g1YBPPn$%;s{tXnn(UvyCl0jRp+NHS|PUgKN zh#I_4Nf5>5+z97__oGfRM)J@#K}1e*>iTv(j?Oz59BPwT?(gp}FE88X;k)bGZq;#O zhlmZ{+}u8W_VlnjG_9Xf%zrqk~3wBBOgHUJ`VnnLgZkVJSKy>pFkut8NJRNpl! z!YN^vx*!0Ugi+NY0s}dy+i#Fag`og7?-bS-8$`UnNimM-&_NTLpa7u>(>Q^%1a?AY z0YGvDksUcsoOh0*XxsF!Uw!@4AN;fJ<;~%^%dTG&aHbs2(7%a3(=iIFh%rv0$^hu8 z3C(yqfiI0z4ZnoQ?|;zF)HxTRXOOzeKPZJMs|K0%S9MN;E)*_UCUlj%CZ2O0#)|Px zz4o|`4Hsjqgk133JTb=AmD^y+@Yar2l9zd0Hm7>Vz!i-x zmqF%CEJ;HPd!v-fnVBRH8P5^wVxi67FA(NDm-%rkNRDXBRTojEn#QwCXVAqzxr4gA zTv56;bGH4rmNzrWP>oLm>sgfK2Mx_508rhxR5Mk;mY*tsn0Tq_)CMtUY5+h9B&p9WT1%%C;%XWED{r^ z$SgcDpT;;&X_(UfFdc??8sij2irt8)rK3gFL;eGIOt~d9{|%DP-QCCH8mf6rT{e;%br8cx&FA={*0(9EO}(*Wg+;+x9zHR|ddNy&|L-)8=a1kXO(cqcF!QimIrDCOo{na^Bq^4k@Pn-EN%H_Tfb!&zg4k zdr)Y5ADV8}_ordJyS?K$tuNR8xlJ#R#wkrxoF<9U`-Z$r6StxD!7FPVCsjpMAY5-&apDvcrx>TC96_LI3CYEn zq@?~*-+4mOaYRo9aNHeOB11}v+a|cC$zDA`aO6-CM5dHP1po#hb=ZWEA^-vl-o=wh zbf8nxNZ27!+io@?IOko+^X43}2!Q}flNuxfW>NY6RfuW4dwV;M&GRQuKL5kZrt$y# z|HJ?B(Z$1;AAczWKX`cg#b=-Y>@WZJ!Gnh%ee(RffAYQ0KL7mnr(eJR>W%N{`+xHN zhtD7X?63Yq+pPcmfBDJRpMClE%eVK}`yc$t54x@gpx^!acg?B+2QkGrZ(rRuw^y6Z zpa1zkI-d0HyRY++9vtH|#JkRSoqId=Rv_h8AC8g@XofaBi)*r?XxpT;2&d7q2vdzCg#;nz@o{ z5V)#wv>+>3sv=S1MViPpMrNj_>&_WkzD&EG&? zGu*3R)^TTr3^Y>>ia}vN0cy=3tY(B3WK`cvxG3bm05SIcO!m6N4vYIA=4n!!(z&;F z#*6Nzf_{+n%wJe_>H=`TmotJjM*y)@BbA~V!P3R0BpoeWWZ`gVGga8w7HC;}P;Q!$i&kC(0GwYmbE0iY zsfNYO)o55Tcfc^_B4wd=ue|4MP2)@msEmhsE>SCW%C;DR0_bc#E}&ASRhiuR9p55T z(2#OP`3s}0##Cks8bi#1PQ&Hd#I%GzoZpDHhz%N7gJBslvYwjtRTv<%bmd2wN4EG> zApvJ}n70iSFIj23zR1RDE8x9m&uBa^n<|a+Vkp#7$oW6Ux_No!lQ=<9a?#I}IB^n* zBEu9z%-_xn9jq}UZ;?^6#i$FC zSsPUb|Iut8s0Ky#lGh_ojQ+Ncmxe^8qjd}4V`O8=r3S51V4jdFKW5FbGBQuGRu_JnpA)DqH|a&TrP6uIrBbk`N?PEFeq zIUhWL3MX}LoYHVOiVBb_!)Cp4K2Y#TFy>)X?Dx_o^3-9P=#-~RRAjlsZ00#if;fGG(gAPN$qN{ZsVBS(lB-(F>SC43OaeH^SS@p-m$#u=Euit#51y~cP5CJNGt>R8|ZB|hc1wo|XeNNM^dUqiWtJM6)$AC+fRbG1-V#5)p z39w*{g`PkKrQ%2|ZsnSfQe?NG1#4Tu_FICL#L&`TJyQgwvp}#IOQCEQ{7Pthm={{N z+;i4W&9%;$-)_tK^|jsHZ9;?oIR)Qp{+Pe4;Lbc`UA)?AS71JStM(ghq%%mJaj6kt zIfepb>U3m;F!MuBgp+a#P+?-Ss6;*|6cGSCR5mMkQZR2gTp-UH3jou$mP~-lqBRN? ze@`F4Ya(B>~7FTESCwf}s*(;R?`7nM%TM8Eoa|I_UGi z7Pl@1<~N$bZ#-jxxjOfi68Wl{Y}6v56hTx(5{ruD$QUPyk%uvzCOJ)f9Ht>MgV=@@ zd-viX;o86a(qd;+s?KE4`gHxn_-nBa%hj`R(2`>2)Ly>xTM1;svYPcX`nOd%D=)Ml z$=s2%DX$Wyb`sBQhDwEV<*3H>x?I2Zo*HsDGOAiVQ<$f(4$(}|T8AYwlPZWZSz$FU zYa3OR5dgq9PDFDN&)`G9UNt@(j>pq52yaDc#@QvuM-!I88}Yzv+Var`=Ilx>dKj=y&&r6h(xGVFJ{)X;$lXXq(}1 z8pkm-4gqwM#L})j0!+t|c|wQe&^ec4a?X3i;9K-Gj;GUUP>#&JTJ_8d8PKchAS#?? zKnS7h8YG&A)A4kghRJ#7lthJEN{N-64<6OEP1E)vPAQ3;jwenjr9^=c=wh=$=K*sS ze+L0rQ`S1UrYDPbeM_F0IkQGKk5vJ?jB7L>orM4nA*TSNB7meRI>2!pLDCpU1WhT4 zh;O_`dH3%2#mCPa`rrNP(`O$)`EK+bwQg|_tA$RzI^pk zf$#43tIO?g{{GWIO~39pn@8XI!FOK2di96j{eF`1-~Wf7|KNKc{rvBLzFKcyeDC?o zFTT3F*&Pl8f?hs+aIxLKd;4xYjr;wf=>s|v6a`H&Az_+Q_G_lds8~vfP!7D8{dvFz zD4>F>psNZyJD62eJrW`cNK)~N2pEC~Kw%*QazqHn)7Z6LziL}S}X&vD@u@<5k6ZIP8xffA{&9pTF8(uE%k@yTAY7gZa5`~ z5@T%EK@;EK-6B$oDfnh}u})KZ@bHm93cig33NVe6!qoPCIltA@5Z%g!aU6RS*XBy8oRgzmPGooBkQ7B2Rq`hMVgNv1eQS30;bY$^{8#zw{FJz|xBk0BGTVOXWA544E$h z4ACRZZ#nzZeqzO4^&2?r-V!xIb+!>$i8+9rrjg;K%sIDMEEc5#MvxGxczw(7)vCd4 z&ecAbKXYg1fgn_PXdZhstYzwfY8v@GMl*mG(Eylh`_%W=p9VyYG-cDN8F4vZsJ<3q z-h^FD1)M9^6vC@4I%(0T86kl2<2M-zVVUc_ghAEIUS}=mx@6C7nRA)_+p6g8w~90J zK4G)RYA5nnSlBn;T5_|ongu0Xp|%vxU7Hoc)HP~u_GMOtg61?5z?sEMmJ3vrP`&XA zYR7M#K|Gj&PPVR;3Q(KVBviGQfL+vys(fyMdy&(Ibw2Q%^cFKISgGO|$hcC?9SgI4 zgysRQfW|(HC|aFlH6EOIP{6XsrKs%!be>BTs1drtjpy%_iV4rK>Di($Q&EgxG-}$R zA9Wv9ZrYee3$NI<_o#OU9nU`BE>_oq1zgpQDhP42tlJr znmAYW9LJPcPE$M%aY{N&>2#XLD4fgkIhy-=W;Wa3IP*jub4Inb*RzFW^skG*WR+%) zsJ7I590M?4o|o55!n067T>v$1t=6t6WT{zgXvxi+<}Qoe4F& z^Zk3ETBS&sD;3T$Y=k0z%Di(lkxe3DA*q3OtQD+Xts%WQqBJ>L!F~ zj6O7d-#8aiN-3r|j*#~ycdZD3V1LmI2q#X7tCC!;I&yRzPH{XA!$8itCZx#gRgZ*m zN_`td;PSx*Ibx3EIL4R&B*x^)dGt-+19~FwywAb&T=tYvRkXuqwO%{ljMK?c2)>Om zDS<hrZ!>51qs~`U9C!c)pd)GJj?{4l$2e)jhtJbid^xqbEZSF4M5IHfLJ4f{{MAoW2~+V2h%4S}Fp zwU^z4!~Q;@AOa(1r=2ItxnxvM^ed@VqPd6)DhLvaD4oamYFrS>scMpBbsn8EvkEvQ z1cwd~R202)4u^4QLh!-2*t$zM3`5(xX_}mKecP~Tj2wdVNJ;s6clYq&!x+;zoP6+t zd^ipdudaLuUDvJGtGDlNzdXKNZ&nwVSBKrPbxvYRiJR8>;CYHJxHydB;mxbp-Fi)@ zfqVdPt993JR%wc^DZ<1%ANqDU4&yNT&bMtjdV)0}xe$DCIK_M-m?QEkLI}dlEQsX* zACClf#Hxk#Y8nrqA~^&`LIh$$*R^dN+fzD8Ne7N7a;8@rj2B^wHmsz&6s71t_-HIZT_l-&RF`o%qFzop4pQ`YyjbSfQ1j>O# zFd?0j+UuRwcY}avkOhn5-*)zD_O(MT>tEa+WY61vUjxhq2`?a9!5V7!%pI_y8KSHR zt6Z{C6j~sWv-DfxoDk7n1_G`0+(Le zKeZh!=N-)5n8{*wKkdBPtcQ$E4e6uN7Eu8t7o;(}q5vQ3`I)hShz{l?^cpZ~?mO@i}-l|FncHG7ik{}d=wIY%_S(Tb)6{u}6rElC+Mp+wKG?nSDGbew8gvPfD zQ0r#_R7WuwcrjAesjlG6UQ<_Nw)qy-22pD}Hp|vIg&YN*!Fy#=yN(7DZ6@>8g>g|6 z4l5yS;I{v=S_`=it>jlj@OAOdYh@m@F%nkuLzfn(MHpZ<-VjU1NM4nOi)++m`EM~9 z=7HdB>dahKnmre$fBdg=_>I*ZGt;ap1xpJv1)*lBc;`S-6i|UhR3XNcQW~ao8m3`P zr!gLfIOJWPl~+`G_8_j@~cTR~9?@-{Cc!o- zoZal!qM6smVVa?>HKnw~>o~{9mtW7Bg|iDxQw_s9)TvSjOghB*FB2gtp0PyJgb>DaG=``LP4%3wK4wh2)-?`9+#s?$< zLYX+GF{X4no+vmX2LO(!?b?3Tqaz;q?aey?SwC0_!~OML+cgg!UID^kcO=5DYwm9E z_lE-kt}i#v(Qp_DVZGjLwwq~6yZZxqYP$feX_Tf7&Jm|HokrK7h;-|IO5C)~x?d@h za2kh`-vN@tO5X0L?BJ7 z9eO1l2OdOMNUS3D00dW31EAwTQ96A?vn4gr7_ zrfKqx_l~A%5|O@d9kv8CjzjPvA6Y;Ogc`@#c8x3 ztoQ7wS?sGNAE13}gftwpfMyB>l`q=NM1Uf42xcscrDUh&JfIph$w8?DTi5NfW$V3KRrMu&J=?1aXMYqL z=ax%YW@#xH2A}1QEkUrIAoD7Izx_oA->2CbxxoPEe5FD}ogqIcWVEPepFt@_i@AC? zD^H1&in1o=aZ1y~W0cdFPGcIUltft|i~e$8aFIxrY6_X&wY%0)vo~$Xg)W71dd3%E zN@6+mY(dYwHZ#Y2HhE!iTzpyRTI|C`U;=aK&n$aY1px~TWw)0}*gAdRHZk*`)ig(& zRa;~4sX>5TE7ACNVX)LJ!3>#lZuH_cIl@`!3g$AfC5HL+Z z8cCWGZ!Wh@*N)S8*dLnUy$^T0-SKb?-fu200Npqolf=GXuhwgxRU7NeLWz@+w?|%M=2ahi=wyW#$?Zu-f@4mSEo4@?q^(vgw?w|hGfAOFH(=VLrkAM2p?drw< z^MCvwo_^<9I*s4^lTY^h!|nC{=IeJM=%4)LJ70eO^>Me4$2jaxsB*bokH?Xx>3Dba z!K=#aS6?)(?_9?s2$EFM5uld3@1>-V7U-W(|5HR`)a*qQu^@~k-I2lG4Yr~}4pmVY z5h${9n#c}E8c(AS!8sC<*H0ck zyt~`wvirOJzF#-P+am=&O(*aCv**ut$HVpO>$YzIq2H{o+6SEUcsiW!PvbFet~SB9 ziBnH9j(Tx<5u>a&D-?C;Vq}(Kz1cu$r)j#_UJi%D;r`T!-(0NF`SCEsV~nbyAs<5U zCFlb=QA7kOo7LIbs}2!M{iJflCxHVIU@1rzn24NrL4Du191{w}6cyEbf~WvO&Lv@) zWg)6$+-c$zK|rz$9LB*DiR1_{n(P2QlTHium)-x0fTYTjH-7=Bi22x-qUqZ|=VEX1 z#0)7RJ5Mcoie+<5(N<7>#F>AV8fS(CGXyXn?lQ%q%3neYkW?^Md?W>$tCot)b^l8B zSuZUm15C@z6tV4|I+y&`LS)QvZh>rPsE-xWII(2#=0YZ!w{vnkKrTC+**xbf0{ZeS0;ugfFfeNnI0MYOKL!_G zRh!l`999?-tKkUM|9(h#QM=PLZmZ<4tv8w4d`HyiA^$Q6qSOJWAaB%G@N zO=bq1rZ}V|v-wyKR0J{Ce~lpP+&47EkG53n0@j*-It!|Wl>Qc7qBYxXF_)DKjkva` zU?J9)mSk0JRmRobQdtMV+++#;m8mhO&|(5Cy=`G|zB!e8qQ#z zg5qJt;__e4{~VSmdO`DS1KP>H$evd2yi%_%JNlE<`lK-TO^Q?lL#sxxzM(n04c@O>7<}6 z5?nw+@4PC2a|8&g%#xCN??MxZ$a_Cc6HiH45UC68FixwBju26aRh@Hf)2XOLnPi&A zgrGce)3wffKnIQj&=ny93V`#z2owP!nHUsQP(68Y74K0{g_%=g zj!{LTB<6$y&QTgC?=dANhu*n33{x5bFfw~`o6U-pfast9*MD(;zh~jwuWvv9?aQD3 z~W|KtDmKLYb%yH|+ok3arsce_iHzV>g{7aNY_^_%OFqeDbha^;vfVI_}{6SXm) zU}gM=001HbK)|Z!vd^IiV?+dU1jVohqMW6MN&t!;Nkv2$2?Ka+TM-s!5p9}gJPyz_ zPW^hb3QahkPQz({#y1Xu{4hoDXw`MEzJC3aAASG+elN=8A*J--a{G>N2;FoXB8>vt zHQlr4Pfn-d?&fwHPMgbZ->+AzCo#q`j>0M!6UhE9cKzzO8{4kg9}ewGF4vbyFlxNJ zzTIAK`@Y}b?LyZ+`CxU}9dB=U?YdiaZRi51Cgv2ABS0*1#w3Eu%tGXX2SAslCIL7i zK$Luj8UhlkAOPn~&794zpuP#K&6=F!!y&~8K+d5miz+z)Z21r5NuC1EYTd)%W9}fO%GXi3enO-ZymG87s_%5%V_q8 z-D@|@-%urWK4e$30!Bk_Pz3)urYlXA>D8Q5M5>i+W0oDx~;qh#mFfLp~lyX=iU+*s{X`^02hi=7pSMqW`>!wnU?n<7?RIS z;)|_d=p=7=oV!p>k8ID0wOu{H$h)N;b{hOVa!zc2ZiW2+3DN@uoStPQBx#RF@jY=l?!v0MV04JMO0Z> zbc(DhED%|aW1JFCk&i<>j?)xb6u?f6(nTKBaut*e^xD0%-EV9V#m-c73y1U8w5mcsd;Rs_Gmm zpd|3Yb(;>9hzLMZN{8biPNS8lCJ^wR+OBPyE;Mb7sz^lS$svLY0U`$H966%AKN&%hRZ)tkMnp6w z$-6=G31NvjC6P2u10olFD4f`(7~7`NL_Sd4uR)2>2@0b2ZFqOR|Lw1T^Wfow?|tX{ zq&cSnavaY}JY8M-5p zuw-Adh!T-xl~f^*1^_5t9W{ubUC~l_JcsTR3poJ6guFPh5)dej69#nP9jPKV9#tVU zO%xqZr+(Fu!&TQgbW@C@h99LaQw$-rUB6m)!)a6i(X{F|2r!){Q0On$(-2>u-mbQ5=X~2W z(>MrAzwP4`kNW{t9fj#|@@w&~ao&6HPa<)c1{U&2NNsQc00hhlmB4{R6a)nkP@;?- zOG2?|N{It%2;O^-h+WrCV?-T@keLsO6;)8kk+1>@<%}!@B0>TLvSVJf}FYRh?F4qd@c`=gzRWwQO>5-g`Q4 zNCmBKlNn4`9RLRSZJPnYd{4zZFdGhF*nCDNg@Ckl>!RU=D)|k_mQaS;Mg_2uf&DWd z^jkVOSEN9!Ud`NWk?(f=7gU$8y%*suAIn}>YoyM$6aeKd7G^G1XqR7DPNPPhVUOk$ z!4Pe`0$3`A?E<%sl$RD@KnC~gL}dCDE6k7)DgcU>UFkC~)*I$=s$oLIWfuHb$Y+G* zcsQ2g?IrsS%wk2&`^i+j>sDxdH`+Xa)C%Gfi=;**SSg zrp~KrTJ%3v<|q|;&~BeOZ6@_O%qUa1SXG5qXQ&+)R}9kBnVY|=@U&pN>T#{Swn%80 zyJ0J)$O^1um zD9lUs9O_$MV;xR)Ug&#cJ|Aq+xFU)U6cMCE8KClfS*u0)0vOqg|DQ}F74e2m>zdH5 zSA9z9us^0a5m99J4juXSs>_duzMYQaFbs*4syOde^MMt(-maUbB_sj9ySw9QLXW`Q z_FcE?9l2?W!|B+xjSo#q({X=rfg0z>Q=Eory;*Ix+r$1ej3*TdP1A%XG~G0%af%^0 zje=e=S0!}h2;(>bf`~ZhL-1YGu*ftHDWyC_@(zKNHH1c3SQv|E3$oW=g&hWtaf*>+ zOq?81QgO~>IbqcM;GGMcIHiGAIkBn&QPZ}*3C?+P&Lo)$Yoy@456;yh3V?v<$dzhM z`TRVE#0d#iSXg3A0?N#&n2YUlMsJB#(fc-dLPQlNgtl!%<3KgWI8Ebpn!2uW0EgXa z+;n~09q)Jhz_TuD6%rgC`%od-eL=?(mQP z@sH^XUOl*a`|9msw|n~GGYUA4C+FI)Uw-}7XJ7vQ^Uq#>_VsGjUCW#2S0BFIed+1y za=UeW|M_PxFRs?8C@c@Ju6Boms3_<#jDRSST_6FAimD=F%H=E(LCgNP%J7m?>@XMC zChrIU&=F|Cs3Po$1P}y>D7bbncU!y^Rv_n`L)38`f^*K%co_Qi3O!u-_2D=ir&AQ^ z+UAs|(-^NFY~Q`U-}bAEtIfq~^YZnpIma>n#SYB)r0opB28l& zM+|N}op|z_i;LZU=Y1H);p*YTabO1C-5t8F_ifnkj~DB;Uo{R1RhfBxanYQHVLZ8x z?%z&tcjJQ|hd^98odC(oMHS5q1pf)+h)hb@?%hw4l# zTv%UdtuGWpZno|itXRmzmOKZC(qUlp;8>DpRyv>I%WCe68MiJCo^bIt$PhQ{h54nh=E z%IDW1SO`pOi-;A{fE|#kNLC_9t1r<|TVUz^cq5lIxMn7*kAq8qzrN5Shimv}9w5W)!-Vl$9|T zo27IP7Az-aF|ps^|8M=6fG86D+aJPw8c}7LiuLowsv0sa@YShI`&92Vh&}>nOi0Oyymvuy*!uIk4 z5$|vB$2bxq1t%=)i(Xm1ZxCH@G)~j)^>ryjPl!Z0(P+J1Z8jGo8sl^rhd55?kUWa$ z`fA&RCQj4wcp^{hi*-t}ySo$Mwr>>hbQluL#pOk}S{?SsVK@;1w!xuq+a5%QaR{DR z1PGmChKb(0(=?(3P!QH`)jH=zWgG`)$tRnVbD3{L6A)2UQc8{jA_V6ZfD`v!JH-yF0SA^b9$W8&qbbF%?ZEqSoZ7xomF?9UcNnKQj#JzE zVTzGcf6?9_kB#rH-`*3_{&={0aK+61s(bq6#aCZ`0i+O6M0U3~*fbaGb-&prO{-PU zQTB(!ixYn1= z^*uuhy}y2Yv)S~kRojLY5ps-^o)AG}-f%Ch(K$pw%E=U}ssbvE*#H0pCBy*2l1;2g ziYnkk2q85gOw%NeI59dPB}GMtF)sET>KBsPfXV{cK~1VHjw3ZKW_ZmWHJG#n1&gboSkgJNdtdU# zdL&(nEthA*uz z=vYQu^m^VwZa~)jc;(Jn3oJWdQ2?1;QOf+Io!eD4%Gs+c0MimEFkN+~vli2hkT(#| zXs#GDMVZYAYNoj5i~yKPrghL@xB`lfwX;^t#x%;dQO9oDx3LM?}AGgssr)(7iFG_-GoGtSH_&U(4nq=_~Wwgl(E2Ap>k z6ihx?Zj9MMRXAE;_ z;lkgKmP&8mFG7H7yigWRmMt~I0qPLz99F(J=$;3tb(51;ot5P>sshci0pmXFjy;c< zkLaqj#*!WYWhQfdm3o+)6eg?mQwQ$q>M}H8ce@+o$VrG$L_E3R8}EFx>JT7K>3+9k zNhu|lcW|nrV$(G1i?s@k!#JFVn4$|rgs9MVZP#}(%I;=QsH^QpMUKbgG>#(LGyxFf z7&*%2!>w(I(`gV% zssKtvsG`Esv_Y6vk)xKlF9DEnOu_k>Mo@@x0svHS5;y9)xBFuTu zfNugRk#Bq;=R7$=a!3R~!F$N!CD%a&i765SFrY_~G7&K*AG`uM??IjSfl53E2}wi} zM*wiH0RZrju^>4|h^nH*93whxdi1VQP*SHXyZzq#iI7H})~oJfyLtQO`ggzh?8S>` zVbu=zBeeMJ(Ibcc)!R2Io~||*>&-?2@Nrb-fA|0X%jq~JN!?Yq4b(i^9-JHZ(=Y$# zS7RC;KEAwsc-8sttFN!G9$mhD^JaT_;n7`fwrNPa{h{p}0-C0AjA?bTk|a@6a83Y( zRaA1w2#U7>%u8C!t|{b`!WD!V6qv<1=R>KNh7Os96BB_5APFl|;}mq|2!Qei>)`z9 zaPp0FL~#TV)JC`4?J%5nhrNil-X~^Z8G*3z>uom^ zdjT9yQ_}<@>el`3_5R{&dw+A^ue-}fbo=J|V%t7_{_y7dZb)(4rO<{XlG4{&;nUjH$*%?};;4CB;g0Z@V007j?$0|dic##(X zc8&tr|Lgg>Gjy@t0;L2^>2oR1kD!*!XerJ{j=5YYSVqedf8i{Y7ry)g%1mX=imJS* zP|n=i)*4vkU^x~jkX*_7V47fYn-M1;+-t`I6fb;zYIfw?Bvg{jrA4)jalW~LSwaM= zHL&Z?x=BFQd}p}$#kyKJCT{~!Eqhyx&R~?r!UD#SS`@4?%F?D<7^D{dE~ueK#LpD2 z*$Xp6Yfk$qAM?s(vdQ@#fZU4$6Dp>|;(asocUHc(M3#bmeaB- zQ)D|eyRu=f>%SOCu5(`i4?*z0_|F1Eb^2iLFBuZl8GaE_jRRCVmr2dueZaC|$Vk6f zTE^IB(v)G%jg;}vh;)8M1;A%M?>dc8@$vb)$~&qp12aB<-`oO)?1w|r8v4NHszkfb zw&UiiHHGUe2~7*D>I_Y5+J(g{mUJjTtC3J=p}=>`|3GsbfJM*F_XAX-FGpuq)3<@( zb1E11o%=pRNGwvmqW+Rvin%;oAyTgC#tN*QSVc7@j*-War>LhfjZwyY;;*f9z&X}} zrZnns0L|brR{54soqgN0P`}f~puZjF+vWEtQ&pC|v~J)AC=+N42F>h;lE1T5R|{*{ z&a$fdAYs6+3ogwj!8s92#6Gd4?ei2k(9=1JnjxGoKshv_b5PwO&j`t?(Pn#xV~65ZF3q<`}>_RJMUJTKE^a0MkIXr^pS|}Z+DV|r^wT! z+pBHcx5NJA9LC71K>1uq?>Odwm1L)W@F9f85gkuQwR8mMJpd$@&;$iUf?=FUfjl8- z)3oC_06vuF{S^- zKmX~Me|YtW&p+RNarh*Cps3GZJiB{)^XNw(KmXwQ-~Q*n4V(6(?|ks(@4x6i>AO|) z`ipndbiBX0`~2?ZIG#2a>&<3$|N1_(&CT^~zix+d6qbJ7jnmMrI*tjEa&A32L;@62 zR81_o1bdd7IU=8rLe86fp+eH)t`Jdjh)`-V0fCBu3X391-b5`b06<7%JOo&;yKYP= zsRE~V)vD?^9=pDGp7wVKbP!rMp5pGXM+b6}&8B(t>LyO?eMr-I`}R7;^!U-ko15$L zG{#}*SF4Wv@px>!@4D{({&;oiyH)@0?Yr&O_UggaDGl%5zFn`k9H-z&QsNZ5z866s z0ysJykDKl0bUdst`e_<^@B5FR-oCj7(2LCqQI%0x$Yp9UxsVI1s<0|^Dyk%x20{W< zB2-i$?`r)}LPAnxfS^v18JZ@fwh@(a1d%C;?QnFME0GqzZ_zxnd^yuL3yG?RgqA9% zdT^|D06pSf5R$YDCYRv_R1|X!C~KH_PYo{9Z8JSGlk9 zC0PCp)&>gtHxpzT2Y?cITiA1z+6yGTzL$O&QH`OQF6=6lg0Qz6GV$B3!b+D z3)`V)=Hc0(p~7gR7gh*N#@(e!Tuw?QS4~~9UX?y5&9AZ5uzYuM>z6>P#X71Pu$YcI zBx~6MGG{%Rapa=hP~oH{N#6gQUs<4Rt$d()GbofpWEWOUZ9DS=s|agKtRkE^F~`W` zBx6kDn1(4v&Uqn)sdK6LIdb+Mnf0tAVsiFOX3Z>BjHJ1Z1?liTrBD?ZehXoiUscvd z1XV%GwT=-9nb~-_c0j8rH{VP}?iL1GWU$p)I+wzW8K}3MubjodX6Vlk6;7Lt2BLf< znMi?3`ARvbY_6sSDw_9M0wN)ZXlVSir;j=E>(_6lVIm@OuJ3#AJ(43wgczssa5yDS zB20up=$%JG--Nbp5HPXaU*D!F5|JbCopZtGe>BN{e^_r<>(zRU!`O#uyK~12ZG4b0mtJi`8niN-2q^jEVq(2ow>L#K^88B(DsF)b$O34#%N# zUhp1NStNL`AR-_l2rPh}oO6_7RMsfm1TU(QBROPMhlmbUfv4nvlyEv_zGeh)l5@^E07W8CP7yqLKqLZkJ~LT9rT`Ggx$HlZ zyiE7VvJ{7?U{zhmXT?cQDAsq)YNH5YB$gy}f;T{}+W-SthsSsji;zwVE_Q{Q)|5oU(DGpv+0hd2+1ckh$ME>FijAR;>FOV#|=djh1K-iHX}P}P$sf?R5eP(jo-FlI!h4v}0w zFc#G*qWIuc0{hhV9g8MrFFqv}79?`uq-4=(0Z9vKh3CTcOm6D(Lh*HEnJ5M`96AI9 z6;@3#fz4;G`+g>kbt%%SuBceaUW!Gkn*uc_xfQ`IkcMcnpA|ADR$O3WRiujP%r#yS z$PC8F8d+##BMX{pGd+W|iBc#~2Uk(@`M>}G$IxKe-X0CLiN%wM^N#A=E2wH8!ICrpa+oT=nrcbXl15fY zpVNWLPq3qA)e>uJA<3+n?f02MLCjZ%R+vW@$q{N`V+O7^QD&)BGUOmR0wLD&d7ub> zp`;Dj)$9gUf|^usQT7UY@`9*#Z1pJ?D{u(`7an6==y{!yIaG$Cx=w1`YKf@LRMX;| z%q?f4EFI*<%C7u8XM~r12{3b));?r2#=e_#9%@z;+CY{@)!fKDgS9_uz%cWN(Q-la z8PzR5^LJ>|jP{(-RTr`>pD|D;eykssI0sIA~d3444$2v#m?ACfi9r}Cp_$GzVKUK)iuISkkD71pS86E&i1=-9tA|fh@ z%TY2SoKi|jSah6t;xxrnSQ{;PitoML6h$F`&KJPWMf~Md zF7W+ZQTVcd`7Esx_M{RoLKE)u`d;e3S>9)%Tsd}O_k7#C04z@WjSI^O{+2dMw5V=< zk-TXViGav*B`xlmk1omoiK-{3Aga&=zg}Ie*8SmdI313x5*i;u6TC+t^4<}Q({$YL zV@d#s4#_)UL8Q=x5L(~(aTww><-N8*3aH-u&<0T)hvY~=_3_h(3UGISH%?P73Ld<7 zjUR_8pUQM`d0A==p?Vk4lQIL~YPBK2;drFr(hvcNaz;Ji#7x0CLQz1V(0D}0DJ6;I z2!xS55~U>GJ0i!NQc8%Vs=o1gYkK7Al(-8H0a8kcr~-}XX!DRWl8ilCx--%PH( zD0V;wD=VS{Mj`+~0V0|>B^FXZB1fP~ATdp8;s}t&Y1-fInPU{$Y&yDfH{%c*j66O2 z;L-Pg^2uj^cquVnJm`Y!-hTf2Zh!OOI~Sc>KX~%szx{9i;$Q#U|M29+^L6mox<_v_6HVp^|OgmizuOJ05BNu8v$-|a#dBu%05 zQ;e&1OXNZI%P&5A`0(Lowd#EP_V(^@IIb^N`{B50`t5^D7FOmruird+^ssFM5b`7} z@cQMOtEUeos>q;RCr?a4gkqRN|Gx;5uz)s zi*d$ilv~bB+F*V;mKb4PcQ$Zz3NrV@5Xcq3QBA^%Pp9{EA+;8s-NmWaV)%sGC`H@CVRhXbTBtf5>KQgzRiNR$ z@(&uARse9NCyJ_&kA7Q1R;_cRpsIr8V9xO|{J5wxR6t-YG^9{{pqT&)id4^V(yH~q z-m6e;szPe09x*Jmn0=guoU`du+BKUYS4+2+>g4! z)j(Ngwp?Y%RQy7b76UAUM^p3FB1Hu7Gg?D)!+_0l?(PBv*6a>2#HnWw8n4<~s0LcK zaOcb&+mdZWg=(lS+|BbOnk86`vMN|BmsMl2%-Gz%zBgay?yeTd3|PuDde((}lNlm) z&dam!E#%r!tPRddF7r#kB!SK&T2Qq+mR&vAWA1n6ds0h;o+X$`5S-n)iw;6g zZ7V%O8$6zm4Y5>0H{;F#YTdY8;pBpn3wpf&L8xp5=R^5ppMUteEs4cuYpp%E005}f zfPjpe3M-ZzbuBqUEE1WgB$3lJaS|1o7p@6lsDfGFrxh-{fM%+F8%&>P%2sKm*S9GM zsB|q3;U(d}dABi(R&hz>RJByrhPti+Z6``K|E+sVqpW`Bt9rInOhpz`amj{y_V9Zo ztHiL06ahz=w?)>6i)R5*vPYRHpUg!>A`GBi(>{9gNQK|Lc?+Q4p{J&4gL6)WoOhh! zyPJC!7FHif0h9%inzn7ahQO)F{(c{)2@o8jh^$s!+qH>h941xq-g`&=YL#L-9FK7v zSfJl@86J&8l$iQezrDQJ?~kX$DTnIGV@e#SX|rCFcgNF^L@5@UkRt&Q7FKNu6~H5+ zC-1$ga!P<0rx-#&gfu1BIOj-26Dz2yG7@STB4~_uI6%SQ5bOBUS z?wKR<{i=5^1mF0s1q5`6>hmcccD@z3T=7$g$YmAih=2${<2W%35fqEfi8>;52+A@c zIwBMR)#TIzg5*+Lq6kVv>PQ&#Nl~1V_byk-chrb5B$dzrDIrbc$)6l-bv%v;AR=#G zzEM(7$RoV`!)@EqgNNHUU%Y-f#XtM!e->JIdc|$8+ZXHUZu}qq`+t4)zyJM% zs|S78zDw7gYmVc1@!;|8^&3%jfULlr&{1eY9H)hZfb7e!+Q&ksMJSOYRS*$JD8l2& zxwsMnhQ01#o@hv2+-ZX8Bv_3lpkRkyvoIF6_N;dr&} z_nZ(xm4&(MdZ(mG5g{gS*WK&uxBY7M{PBw)K79E3S6|)T>^7@TL{%lFv|g{`#Jk4T>oFG$%rIl(+dPc_L6k1qKJ%Pbq}x(67jynztC#% zd4LQD)F7vUOs#)f=8hr)0Sbw#FTf+0`COR9RYCz4^QmT4xk703cuhRfiLrt@-Gz@gf|Dg@@aE3pEtjm^tyUS5@;m8$cVnKi1^ zId7~CdG2>Hw`QZIE}ok4rAydaLEF6Sb$MGR&-U>zt0LOzh|A#=I~!rCL-Hao0wkw>>5`t`_+X`U z9R;3=&u>8c>P|4QUSC_*s}ZEgnd&c)l5~*wim6HQ1!`BQE2XTvnNc&l*V0CHw6L6O zumxc~#cvrv?WBoFlM-N}1#|vMxrIPfR28(8Ny#T%C?YyS0Tl@pp1gR{1poTg+bK=K zdvXp`9R+fYq?j<>zPpK21XSmo3oajw-ZV|qwyp`1((!bNF(Q%kgosTO`c=;&!)cnv z$&p*F*S-nfyWw~`9*-*0th!Cx+}#{P>rzT_Nb60%xxBc$zK?Mr=khtDF^Y=x>-B1V zF`cG34#81m2EgD5R9OT7avjXzL03z(XC-kDoDGDWGLOD5R7FT?z=HaW0_ufm{fo3BK_mIPVcaQj7_bibM1vI6v!A&QTX- zO~vR!U~~wGE+A%{1vxW<1rh=ZC@2#;=N+grLy?d{#`FJEzr!*TcP zU%dVDmtS5yy!_5jKG0M@;lEzdUbu%y8in5-OKxzufBeJ`DE+62XDT98#s{Q0xn-Tlq0x8S&MyEMf=eEyp! zkDq+<@dwxM-W`r7OsQLS#C&&mSap4W(N9Byh~sH^_Q4B(9Cx?7F^#L$Dqxs~N!5km z_ILa3gRKA@j)%>5&8#jo7wC?s6DWib6d1uNbMRhB2^3WjOBOp)E?=V{f+&=_2k)aK@0}MPHA3EFQY!r6?2ldQ!}oO1QY;(R z6&4~4!K;cY#F#{tO#4^2iTMa2!!m%Xab_J@A+hOog*gv%mbwcai8;5uHZ4%lO98%C zXQpC?3b&wy6qX!7pxF+%pke9yyfn+2#R~Ha+Cp1DXIKsaOO|=I!WUpx;XS}q zU$-24wWIA)-XiusNpkv=0sUD#)ySJJo1W=NwZk=`q%>Oh9?iD1!AmpP%0u?NDiJK0 zw3wCic-}W<;9Eb%P<_u<`k(bd>sh8-9!*~JwjoIoO7V?ZbZ8}=MG{p-a_xUkNg_)W zi7A)z*;xAAX5v1%mR81m^j~_pL^!U-6uiw5o?Hsu-GzuU|+O~1dr*Sx*hM1BFJ4fUl zsA^L0o%f+#wSX`jhVe8YLGYd&l5-)1ILU5zAjCMNe%p0zm!br6``i7P2373ZHYPpB zF*I%*CIa1FT{LZb`|f6%5@4O2J(Vv2cR za*9boDHo1pAxGpeXXd1ooI_!Com6HXyjZ zYeN$pd2~pqB1u)56Cwg3a}>tRAI_2F0@?tok^lg~IS&afGZTTxX0Q~ybb#Pcb8G+< zi&ch@?HnZGd}4s8GINpyQqIhh9I9d@@2GW6vvTBJ7n*U1;}li2X`7X6?dF5k>#@KmPJ}{g;37;HOR3eD_Bm z{^(CXnNIATzuWI{h)1D+1=M3RMx%vWdNvc`b4Y39_gs1fjgh2vJqzG&%1jLTE#9 z4xLY&5=TVjl!(Y7v7&eG!R7WejmP5*-{dTokulnHJaX1V^>YH{-?9sRV zib?yvcTb*N-(CBF=sb!0`t_T;yTf-s`Tpu+y1l+R?N6KShHy-r;t+l3Ac+s{>(}pI zeDFd^@2__k{YD^lZC^M%z}q+1{l%*B;jlk7A!x$TG=1Oh_J?VVh_dQiKujs+y}8AA z1_+>5Co%6-$pTLDiE#uf%&yn~kh4)lL|BA1F{?lmyehPvGPA~{3XaGJ-+;!%C6fWL z3bGmGn2uMS|E?Oa3b|6q7=e%+IaL*r7^f-)UpT{&7OXo|1@H$O^|}w zUTQO9mLCG-^pL_U2p|Z4PI#NyKQ9%-`FYV4)qa-Zj0MTrOjyC?Ea#`{fYJETR;Ari<=!{JZRPPgr%PeF1iM%tC|I>xDhSnp z%l#b1&|5!t1rlIVhB_bzz&tehObLvs~fjI@gkhe<6_cDG8U)9mz;@gV# zXU2nBgf9j+M-z)?SF(!DHC(|Wh^Qh&#DIt>EE4tV;pGP(zqq@;`@`=(Q($!DymR1O z=!Eh6sk_lcv5_$K62f%6hS9!CVoCtYo?HlV1g z{i=QU=4}%8=8XZ854&;%`4IPff08ViHH!17;9?vpm(;{S)FF+DWj{{Ap{kDK znD#L=p=lb|HO;Ew)8ste+`e_HzU%ck-hKVf5p5q{JbCiqM?d}U&Fy_4`ryxg7{9CE zKYqt2{p80V{O*^(e|J9~564H3x2NMcPTV)`%e!|IPsiP1wertDd>l2tetZ4=*`xho zI*q3npFH}-?|#4SE)bn>i3H;qo8U!Pj!?~>W)TrZK<^+gro8tiZ&)wo>ZmMhRsmHa z6e+tpd7K*WQ;gU&pc;ZF#FWIL@-#6a5~YMAp>tkXhtuf17mC5T-i2Wp805*LN8PF0 z?RUrHv1!{l4RIU}cY+EJ9zLB^rs2SmL+icUFw5^h`}N14eD6=b`~8=%-`?FHHk&pM zI8zAvW7}iqbVL zUHJWe7h^i?kIrLg0yF!(C*1*pI-gBe$-G4dadSo9CDsB(5e5;?1%Dh$6crUhBxrq* zrW^Dm!V2I#VZx?u;uHlLOkOX1bhA1>m$?}T7-9x{dzUsd_StybDW5Cv!1*45Ju#aC3lUJH0skf)(6lg|ab%-Kqscf?t-T0GZE z6_FTnHtnNzI28dcz{V2sV-f8rc9%jqB|8tkz(^>URLi-Oi=mzCk3u3S<0mbaiFLtd zqtJE{S1BnT778lk(7Hju@*vE8kBcd({abvIMc6!wIV%^)CdknLIsP#-WX5&XUaAmH zVe!X|SPhjM#x^#cnF@+ntsBHe0W`sUU%+0wJhY?PkQOQvG0IughM8KZ>VVNPTpFRThm?8Y3rGE+O6;$Wa@s^`~f* z`f^KeTCD53VBedv_eWL506-DrwgS%FOI5)X$yy(_CAf?$p1ny`geYf(7rQ>!h8ET0 z4=ElK1akSyoH<0ZkSSoj0CbyX%SeJ6Hk-qoRmm1TGIz+3e*RyP`OK;c-VrMkklJiz zeswGoWp%On&W}F?l$T$Aao8V&Z^(rZLI@22oKC|y>{ysZP{9WWpd2G74Z-()D+GP3V9^wybHbwNRG%6QV5<^<1_)Fs5k=eJ>*i9 zlFeg9L?i+v=N%z=@6CVb@|=3-OG(gK$|3@m;0-w}l`%CN6{;Y1NPRwWSry4sE+ynW z=ekTy6UJ%K$jX}hq#!zR;uso_s7>dIAf*WfMqyBHS{Fjl*x%mWZXay>zE@7i<8<5~ zKHVLsQ*R4}@Lg)4L4f=F+tju$>omfy52xcP_`peA@J-W9+`V0Hbm z=GK&sEQf5!jp`usnE;quTEfM7p!xqf%4FZ<%VtOAC+By~qsFomzzm~`(sD9^p|fg- zS;?kiqM^;>!eyM_XeNMVKrEO}&s@zFD%D(!`ucfKNktg-u?0TRat~$`cE$?%8*k4n zLjJJKrJmiIH9VBNiMfi?k~MU(0Bo=YIT{W?bKx7xSfaa1P%wsCUWfqBv`Tl>Ajov?U~Szyb~Az=kNX3@=&x5D8%AA*}Hu}HSB*3>ry0#qW;wq2Pn zTSR$UtTn8}p0iAh21_)U0lJj~GjlmNHCqbCAeD-U3w)+X^~=m12D0assn)kDJgl{R^rNVdl5>s|=M)7n zYgI+0s1-!3F$bt3qOxew`T=KqPGI5w%C3u9jM?vV56e_o>>=0pt0oNE@m?&PUy~1M zk&&A&eD6o!U9DFyzj%3bbE}%#rfs@DgoZf{<9IymStM70B}atBtQ?aMZoTQ6HV6YK z4?HRhIrL2c1Ywnw%jMweVinqEIt($U^>&TUrIdDecOuenR+2=8kdPcq(+G;|%|--n zZf+?fa)87_K+X|^3iEos@xjM5jpIlq1IBspR8)j1Lu2P0d6t~poB%1;`-iOQ9SVyh zVonLb0T7|f$D1g!Bw+!-;G9F3Qj}~6TLC#2Lhv4mTrOnly>o;_2^4_II{-kXoQ9ra z6p;A&De0Fgsa9&M8q2s=ltL;y(=AP`cP8X|~*t@nte znnckNcnXOjr3j(~B*4NkXUaII&SBE%h|rEQlvv)qx(<%o z^=4FVx(k0A_Pb*fnoZZ-+}@-#eEi{e;>f$>VSCX{$04j%qUq-Lw%e`{@vARhK6v)< z@$-wjyW#HouIu|aF*rCL4q*&k;}JkWrqd9-o5rDSn@zuVdIIRgG2=Tkv5H+xXxCvco7rF2fHC1oFqU{QIq&N2B_bOBtT32J&4tb~21= zNCXYu7yV1-q@1;cVQ3>?!88?*LG^2bT>zLYQxNEzV@WFbB0K(?Q>>e7(_&XQdFlBYF2yY zr3*r7@!-_SUEB<&>J%2=7#h}lLx}{Ck9{tkunX3aEP3sr3JAd1 z9Zlz}H~eOXoEdPcHHMS5xxpV@APg-tSl(}eoUGZ+UYt!rG@i_lSNOI>`8KhX9cXzCipx=yO`0o9_g*DnzqRJ+_dqH~W7 zj?F#6c`NgrvNT&EGYqsj!r82thgmJZij3!3Kf~U*NyVlUTPp_|dq25Ku$vqF)Sm_?YG zSyD_XNh&es#Wb9E%6e1t&dQ(F&Zr!*>>t<~Id8K*q$Xz-z)DXqP1$pT{m~*8I0ruG z)s%s?Xs$hvj`A+jq7I7?P}O{5LsdR=IrC};)OVgotE)OHy<3RgWjMO@yYxP>Rc0 z-Z>&9P)yS#DhTL82*I(avPxnKzF)P%qJZOJQ0B`ATS7V32M;;XySF!l&Ut!sbN%Gu4h?jBxVUS0I@xF3hXd5S3o3f?tw znwqAG$j-qqM0L)odLjiRPr`zLE<0^=%ospfR6waj*qn3OJ`_e#1Z zUXHTBrbPrrig{~B0-~M#RVHESh?)twuvIcLLL!~DV~NqIF0@ifo51SJG{3WrQs=Df zqJpUyfd-QbAU3Q8#Vj$OtJ>dC>9NH4Wy>yi&PnaYT8)O01SQ=>klj_qpy|W?Ii$qi&qf8dax)HAWnl$T5ax^nH6_VqKug^jGBfSw(`y{FkfU`+2 z^7Or~o*DbFxHPxEb)0ISivT&>^wS+sRFYybdZX6GCs0=c~7v)EDf=`x+R<`6Oa zeaMN3g63V-wr{V#AioOhn{j4^qQ13?lsaz<^(idQ6IfP@bEEOt<&9!i>(j)=xtOfDqjM-8~V4;?Md$kg)&)aB0nMFbE9B&{1LLx+F z7G+jN%;+Bwl%oJa9zBw4oNt-{O5Lgf1o8nL0zeW0P!$;S`FEm_{rZ3iST;kWBO*tx z=rBc3gq~WLjj0SrkU3{$XT!ycUppiRgbwmvPKA^vMTC<8DiEd^6%+(~Xq?X?Tv3S7 zNmL?4=bQ)c(R)uSF~(^~JSr*@U}hC^o|8}m+x6NJb%T#-t!aAw@-=$buG^&2I4{xt z{?jj3UGw|K+3YgO8p){dfQIXSXkJ zp1ybjBFDp_@B8C;N~(?Xx7Rl>K6rY0wf*Yzw~s%5c)UL$Nbu;$w_P_4(=<%24^v9M z^TLp8o)VFW=HtGQ(ELDTwYhSrSseMSyd9_jieyQo-V+OxqnKh7f+lD}!%V|4H7yci z5lrI<$^ei!W`6eGDeCMzL(p7P zO3E>7m~%lSAD$+{i~veV0EF3y<(Trxb=rnTl#j!SfgN~H2+lL5n38SXk_Y6*=j42s2F zP~p0{AJ3hvGY{$fR80h$cP|(!n`7UzFL)j}0xalVJGf-EVy0DIEKIA`pTb#W5dh0C z^6xRGJ(KSPL$?bQjrsg9gCe>(o?zkCR}-)Ky?ZwYfw~e!v+4+3Vk%!zD%F zj2{*RtiovV5SmS~0PTecT3rp<(~mYg^@V67GOmL%ngv3ehgIx2sC+yxQ%jLYfU}%8 zowK1TT^B29`Q<!`&lKL;2jR9enlu}}5(ZtGm zgK(CTqH~{3rq0$#Ek|45jY~s+u`HJk@^dQ8W1Lg<=9UrQJu3cD=l|KQMRJrTv+TrN z@<^QX&MAPaX$e&asM!E!a2CxA2;@jb!K+9Q>`%-0%0G*t88gj1vn>+qdI5 zp+o1W2^~*qx7(BRgFDpUYwul5VB^6Xyulx132iBB0@(8L3p>1g#hapB! zc(J_<)ZE;Jyrt{i9=hQIy!?@;lhPoCf2?mqh73rFF%zxYG5ZXRwf-kz=>JifYld%Ie% z9=+Hm=Izybe}5!YMTu!ztvVcloD*eKgnZ64BC`M>IiF!`c7f$UjDY0093f6=BIk0} zl>=~zM3O29v!VdH6qB+vAqZtbf|sG`#tyRH*v7RkmNOANjt!inSko81TB`S7A? zfBlC~H|y2zeiv5b#e?nc_V#!f5IxB5;nhP-aJRo-Z~EK2yZwPa{rnF<`SFhvMV``d z90l;flPAa15RX&8?sqr4=`gmP553>t++IC>aCd#D!Yq9M_V)3M$0;V5bi`qOu|a@g zOb*kkZ9_w+Qy5RfG@RPLC6rudLK(=DiZUrFpemWh5rlGvgorAm3aARJu&97@P7xC) zJsq16oC~3Cq9np8Ns17`2Zz}8Jq$zQsH!TUR`9XHs--MmC{G0}0W1Viku)WhB|2H4 zfNzNRii@gO(r(L`*)(%KTvqE*m0)@lYXXAit@C9wE1qK;H19rw)QA9>KF&Hm<9-4x z#eWQGls>?m$z!^Ih6giP0IT^_@v?dcGl|9OMza_{x4{SMNTwrIcB5HAu+0AC@E!(wd3z#8Q$zRiP7O-`3 z8E0NmKm@4*t9rd*#^YF%h~6KE>Nhxle#tj~|Az@uC$>zevC3?KES^{C)j}zZt#!ZkHwf`jhv_DJx^%&IKfyl19wW^Q)n?r%T2Pb0D-b28n%-Cd-MC5y}q@~9It161`sfS7q? z&C0&4dhy)c3&=#s_VjG;a*llnVgLAu zph#>Y2E@$HVNy$KjHYN^zhdGsP73A#6-t7Oh=>W3XCg#au<0}rVJ&Wg%$Z`SD$OT` z0K}BpvKVYy5+yYmkRc#3c_7CQiHXQDJ9gePG0oLLbIePc0#$PCIWW86y&14$M9g{r zEhW<=)5D_fF;00atH;>o6ffSx&tXi71OBqKr>IIs`ii-`9jm;F?cX&e~Q z&;%q&5{ZaNBYWpk%=nd@cZQZgWlEORBq4zTj&X8|{eLB-VQ z-MjA}?%uDQ+g@D!5l{F+gZ=80&t84^&9|bK zG^twG`52`XM{=yHBIcNL$v3L!loky|h(?TxM5gK;t2I57RUCsUGv{SS1QJsOaNbWT zF*5;8V+_s#f`THV1ByvfO5VF6p4hQYfBdUL^rw?~~BUFgrfA#IF&p$aGCj+{;x_-RhM_m&} z@A&cYZnF-@2kk;|+l#}^zT2(Y}f(dj=*ofprFrZ8*858n~Wqjaj=|J@RJ( z^2%E>2B=8^^H{BHGS1+t&S?v<%*Y`tJ1pgap;{NX2nZ~QKYIda)jmT5TQ=UZr$FcW zE_lY&1+M35RuMo%QieGVXHNS7QL8R8=;)+jCD3}CUbiNp(giZ zrAVFQItPU%S_)cC0l|{*f{hlk4Ri zta8vi3kzZ|Cak`4&Lqm;l`osDu(`2H*0O1P*=CW0t$C~gIGejvoU9eDTc&{3URF9Z zI-d!qxyTpP<#c9+&33_Jz<73Bv0U0TWs9qH@_!{8|8M>j3be&mmfV~XsAow~g^q=` zB^FsznPv{gd{F5AxtV3)O!Me;Bqy003X-jvR{?h_|O&r+APgRm4G~t=& zX}KU_!Ft6(-`HsJ?s_NG2*fPt2*DtUpjwt)B(%^PA&o@WiXl);oXL z@5d=hiU5G62qpjl8Hy?(FcKJs;MjREG?AE+s&+mgsu7{sa2U7S6#_&NN-|9;bl!XK zf-|wZ+uM{<*9Sn5BxzDa*j}!uG3B&xAAHxZ?r!e@l$di=)HyQCTeHY{h*R=iaNem( zjFFin2@xTXnyRUD3~GdojB%LM1Qa2cDIuty8Iz=$&gBra;?yxS717BwAVC$BL_|P+ zA5<}f;GAPe#LUPlqNXOf5UHAIb|gCI+^X-qcPbZ)l$+B zKvPlzwL}2XY`tA0tC`QS4F(jMxmaKEcDvm@ez^JBFV_@Y((%cQ&AazE-P%97e$Hs8!+6*~93Ky>^(v`+ z`r{XO@9(BKeD&=YFJ4^V-8}sKCojMK;@$D^=pD1@VHkby5s55`nW+#l<^$SI!N3wK zD3sh_R0GJzq7gYnRRvQfiZM=V!LxUcktGTuOw(ir#FRiaMiKSFo3V4`doHD;)3DkA=Rg?0glQZ%+ub;gZ{NTF z^wlTtKD-A_S65dLj}PzPf7o4KxDNZ(#oKr9R+ru5&HZ+_osP%d?qa>&C_&%##l(m0Nx>zIfTLkN}+Z!Yx= zfsht(tBKGo2J@oBoK>T$sd^bod9Esi8%X;zvi;BLh@zJ(R>g``7U;9c#^xF?C_+mj zV3YDyZDa>cIYzgj?(L=DBv|}YoP#Q6)SpVO9=lM3SgVDrpB%6|J;w+t6KExITWvu zuf-w^X0KxQ25N!wponf6xVNfuu!Qs%d}{wp^XCP$^g+U*z+&f3q*P&c&Q9c1CJj z{w^$t4g4A`$TWKtvQNdT#IRJR()IB$Bclwn)l(?ahGuhhu0ikB=_f*`jVs>4)K*AG9v<{*UFOr&v)5S*xfDT)Z@yjaC7 z)ELPCnL#vX@h|~_n4!fusc7f}BB~G~CP~|ijj0UdF`l z@0i$ezv{*@YK-i;^IdS=-G>`uu)NI{C~qIi+W-tQt!T4e13*k7nt=imF#zO47ziDE zM8GtOm>`0P$7Q&K|p@5@Q6j zlmyX`h#Uv+5xwsmGkfnGJ47UALPCcKOnKV}<$^4T*>c3ZH=WrzBm&SHM<)?AP)Pz{ zMk;0?#S&Cd*33|{baJ?r`O{%I1a(N&kiAhbFO2(0>fI^(6B9|E~$}|iQ z_YZ{Bb?keWWicVD+Oro=_K*A1!+{8W7l!?Ccs!mwzW@Hs^~LqovnR*Hahk-fZeBdS zIy~;j2f5sZo15E*o8#{K^38YO%QOVW|MWM1v*YV`kKY~T`1YH(z`9#)-@d(Bb^Pkn z7il^n)7`s=tEXFboIa!!wO>Miq6J;4Z#^inI zeE_tWR8*PSITFzjLK2xo@+NLjh*MH$6g&e85i+6a6jL8M5nF9m<1i8uddxLl5y>&h zWMS0}V+@Wr+Y2*1?oX@D>hL&RJlTz>@!jqBPoF<~cz=6}<7(4`()$m$SC?1o)oRyo z5tw@i;Mn8s-Oc85r^o4}vc0;T_VND1;mPxBA{xhOifO%DcaF)isYOXlZXCz13#cF_ zxv*>qo)Eyq%#e(jP&2D3ROE%Ih?LQbnP$T^O(Tk_nDbsl9VbCzz){mUjNS)8aKSrC zG?JmlIGXPm5rLem+nF$nCB=`WcM+6DzoV&%NCH9;DawJcx^kB$!$)eZVYfxg?e40V ztfa;i{9{E_&iXGa4XS`M>wJamT`O8b0nv<55n0U`uw|=Piva4jzjIi*P;gD^<2jha z*+#OD?gS{sb6P~DIr4Locm|aDC~I2~sO0=NEmP1`2JP1Ju1l7Xwf?aqTw^_RZL8Kr+^rt3OPhX*Vyvz$Iuqw@c=3pEpw? z02M|ME|*Dh6yR*PRAUrpK5XqbSw+>7UVN45SNqlENLii;&HrtS7XPn)KK|Nf1}|UN zJ{T;dQN8=j?r+?PfLbkp!aCL>BxnLTtyD!*PKmC{av3W*$K@H;H(Q|nwJ_zZPL$2) zxlq5t|2ijU>H@2LZSSiq9GdKzt>0pj6)m-}kpN&3G+o4Q79+?{s43JPooKnN87}=s zqWKgvOG&!EBV<(_hS7UYllb6}aGD|#uycq&%xIRTs9;cb{MR)`lylT_W=IvLHFXX0 zz>7Z3Df&##5qTe&9D4>vP|035Ns=_FSlL_az4yU;AADfPfZ&{S%z#Mj0D!30$uagJWTe7-*%pFO!6_rv{o+x6Xcw@%6S52wp#Pd1zF+L#)8W|n-Eca7|K0bm zUwXeD>`5?aiHY+;7(X#p-xCI3tm`UavI9)8p~#`spw|?r$G1udk2poVL|3a-93wfJrqPEGM*%a>Zna&f7{}9);;3Sp#IfUiw2lFg znHeE65g3|^0hlQgIUfXKKF7rwK@4K!$JN|`F8ZJEviU0jI0ubZ6>tl=H1}j_WF~)gZ37g{xK#62P-(rRr7G1F zX{^Yh&a)MZ!am*ukY|qSL0|<#Wme6>3(Uo#Ded+oFuC-1TYj#ezvvQb4Gea92 zmsy8ua?LS-I=@s~sGMAxuv#bQrbZzTLM!~0AFA%}mc#}Cb+`Kuw`~-!4b$qeiodbdWAW*9GT{>YbH zc8#0X3HWG`R%-xPvS<1ufNAx8&$4bYPW!>@ez2sV+KnYh(M*jcZx%#d2R1j>*f_fm zN})*wM3B54z_RKsbvSZG6)}(^rvRvxP+DeTRx2NC;}t120(~SMa6y_Mgb?iG4~1ll z$E%ykmN((NCaToYrvw$_G zf?`u^)V!CM2y@M$+*onsshJuwa5>HGAHKBB&y{d(Zn^XtZE=4zH?pZL2VjF z7g&-ZlLCMm<>U_}0#XH$WRL(L8MqP{fx0tYi`*t8L{m$eH~vc2XM~iGByi4o=Mlh% z;GECtZkD8ka|Bfr5D;?k&WEn+JICyUMKc^%=`^8T`eRgqsdw?+^8-Z?itNSnR zHWxdOyjuA^^cWv!|~LuI`+KZA6MJ$<9@%}toQrjq@xd=@A&ICU%zsB-<}^7j7WaJomL&9;Ahc)Yy27zjVy-t=L0 z8jl8gfAe8?xg((IGUXe>e+%>axj@4$P1Y^|UcJ3o`Q_OL(u;SSN~TBE=!p1Hss5te zYa+%Bud^=5?a&#HK`ci z0jN1iSjS!g9hRBMa34zUcJW(fvQhD_=F>X?Dp?jftrf>C#e5nRFD0QW8)S6}EzJNM zmaV+fkQ&z8>wilf+?cA6t|-xhZ|j84^E<2a!e*9pYAb^nKrZpw%+>`qSuzbaHE%!w z+L|shoWNYO4l1BQXp>jD)EbRyvPePgRKqp-27+cuH>;_Fl;spOgwcLihFX$qezNwv z<>uqr-7_dI!ML-R7dVPDttx9Rd8+&_leqY1zVZCM^B2Y*#E;HLj{*Q7p+`qdT^G?Cqgre5eNxP(llY# z8VX4wqI1ju283o>w}_aCC}q?FG)NrAC<%E8)cIA1=vM31 zYVA-l03+)#jvwCLJ$d?Mwc7pSuYY#?-Hlu0cVE8mSN*^L%dek4dkW5-PQz-`U0!X! z{qEg|Z$IoVI>&H4rmL&f_g}o-U2Z=4^ywdeH}$J-xJ$$1NlbjlX-b3;h(uG2w(7z( zMnqy_O(~5DJu#D*q9QXVky1m|P)!ldF^VPzHpJi^+eS2rCQ#(Mi`|EShJ@@KoK6D* zn#vT_xvsd=z$|Aq5=V(l$d1jSSC&Z_fe|&?q_*n&k)}9|GQs9z7pD}0HvkvtcswNQ zF4w!ww!gW#efi`$B0fCaUq89NzkPV}JU)B%?CUSSef8pbf+Qjgd^nyicNZEHv)$d^ zUSB_XJRDa&n3*PtV1Onm5mJm3AbN7D2F_{O`4QKlQ_Rc$>(iF$&h!}|oxopqRXT78Zm=D?W!9lc?L`}1~S`s;mK%Y&4 zlF?E9Cs0GoRil0^!e@oByoOaB&q}|!hG?M=D!8e;OLLd9zkYVJRZ&}Zw<%zz2UJ^P z23M_V0xO3V&e*9si*X5ks``eU@wYT`isHbkC}80?TJ|fehN1>77mUH?J^(dkWFX8t zg{UarEbD-&OncL7mcboja}1W@XGISsm{Gu!wQg2aLe*Ob0M$DIODdgBAXGPX8IYOf zv(J~0EZ`?D6!c6(sP@iW*}Krm8m)<-lhpuAS;dM$Y(_zC&ar*W4*SLvg)&$-h?amrTYvLt zi`R*ur9WhiXmwPJXiVXT*_?r58e+r0iy2w0&C=hJt5G2`mLAyB3arg8Cw5+44QyAA zvPQvk>Mb}8t7TwkVDry0)A9{<@bO|A+tWFdz0P44WVL+395l2B8r%Der9B(3 zbvEbse)NOYR-7+<^fQy7AlaJ4Qt|vp@^m&tXRzA-tuX|v!*1U9%)?e!Z)Vy8+l%i% zyZ<#OqU7xDvJbKJub6=i^Uv;kT)gsZluP5G^b}$4`ZApN5yU^EP$O|$G0SlQEE=Rh(cg}et zP|+lb0FprnKJS!810Q_XcaM*IKqMj#J~%IC$Kz?7Miq6P2P$W^5FojH<~@k@I<23TSHitY1u` zF-Fs&?Juu;%Q2>ifX*`_AfcpmIvvrBn7lItOvCAPIv}e`a*heWCNoa&4&#fb7e0iP zB&N}Ie0}j8P%p19@9%Dd4<5R}1c{!1_DQnw6@CV)r_<@#(<{f}`O6nq>+LshzI{C1 z{r=|mZ=XH?{F9#@_P+_i-`*Yib^qy;XK&x%guaX8bb6QwaT?Oq^~MK!|KWapy&|GC zO}kD1@OVT=q9Rjlkk2!#8Ui60BTsT-^aLa+`7Y!=B?vA-N~Q?ph!io7vFm+a@txe1Cg$`TUBVzrVX*@3xN*53gQ6zrBAr4b$!Wo2Sp7XR+$osRBAm zQ5+M1n&|#`Sgm>h*zQ)-#1f}c05orQo!3E@D3J5V48+uskv)w=0yQ)vV(&Q$K(-!5 z9TE|F#}b^43I>uAA+TeBELF7fo>dKKu#oOpDiJl+wiMYv6yJaDQg){nolVv0dafy( zK&PhHu*CEMAt&H9nLeiy)a{6r{kH~)np1olpf7r?da$ZWsQom`*@U(zXgx#Rmhp@Y z@IjH{1xz;uGb=8vMB)tm!2lJk0NV1uTu06fA=e79MH&90ZS4%wW2Js;exc+l`u&KS z4MR2S2B8W%1emKnS}mpkb%=G2=Hb^8=M5?qZCFj90#^%`Tjco6)TsdySbVi~%g)m> zgXP9W^;bhZZE_nVtPa6)uGNe|Vd1Su07FC92-LuJwN{{5sWao(ZWaaJpiNsZv+wZ? z!Dh17p3aegf_|{Af+dn(&P1CLDz!Bi1%LAQw!E#nEGzw%mTvv9gw2)8HqTW1x3Wy- zth#c}m~4r902=;VzUO=jTW8?B=he1rUAM)nu^Mx&8EZJQ7>jM@>(`A94Hg?A7H|$0 z?bq$DWmcfVOlxz6=j^luuQ*TsOtZ6L!lI>0pfmhf$Wlbm!jM`_3{+`o_QN#1bGci@ zMdL`-W<%;pJcGYbvZ6{E2tbE|wY z(=2!Fd@LU^&wvn4~tZbNt@N%AQhNK0hY7P^Z zy}(woiK+~TGGG-00#l=$4Z;MXY1DqR`uxW)pFV%`$3J{=^WlSY&U?0`SI@6E>)reB zZ%)IJ9U(XqA%YYYa}i7g%Et&`K8u|&Z!8dtQ}o_RO3WlGX6AA(2uwhyWS~lBNkqV0@Rlp2iU5F`5a2KtDBwKr)~h5E zr>HRjU`&&#=%n7$X1h(J0@yGN&$equjHf}=6cZafJl;r>{r+y-t#=of!*TT6ZnxVq z(c}I;TwEc-`X}q_i|hUU-LL=U*Zn%IcPmo+`xmdDKYQ`7|NfhC8oRas)gQn5tDk)K zhd1AlDhh1E8aiO6-P)&d0_5w&H@W(G+zkd4lx9`!1O~3p4yYGJTlOO%zcYoYoZys*$uP(2g z_s8RYyWYHgck|@sbAK4d$NllJzqq_gF{Ts^iOG3F5d|bb5U~AzzuT@wz&l5XF-{d& zC>RitsZvvOb+zpfteh;-kT3T5w7Ud>Qcam~@M zN(Bu-YgcDzS%49K1d7@iD~)SE3pSjuSlP~tSo3u%ro-w5TiTe**>2?cfhVn?oh7|0 zeHN~_0ul(96Tjpgu!ZW!b0CT>kn$1IoYnisuG0!u<_d|6cNG){r~s~Tr$WPgA2W7t z-)39qoW~nBsQ3L~49!w$!L<_Fz}A^!gw4cRxPtO57UwQlW#X2WQgBvIV66<;uzIcG zl^|Vp%x8;toVWYYCtKW6vn-a5=1RkQ<422b zVThX*WZdImusS%K|Z&}mA!YB&9$WQup>vN8mEbwk_a(p zl#R{v!KPsn(9LdjI*ncESL<;5;RZeB zt?=1HUbe9Uf|(`-PmDQX-x2XJj>M!%*)bxi2oV7h=frnVQAtSvL33>kEWFw*IHGbw zvzq1~X5zA6n}~^>V?;;Ap(rWlm2 zzoi-w)}#X>MzX5(8`v<@ytPJEH7SCr8lssdL{KqRp}LU zcuz#4r0g9B0M86+$cc#5%rs4dGUK}QhBQr+^NtwMLGWy%DrtMQ`SeFGzkmDo;ls^` z?)L4?SHJ#~b9iyFBBX6t zakmyrfB54cnCSVl>o}c$^!yUVq9zwSF*@WaPB_}`VwV&i?oVCEOuON91O*fAR&KMq zxW9WChRJ!~cP@#FnMlDxkX>=aQ#!Eg8S}Am;yroiQW5~rB*>I3t=D~=Vzd~#z6)U* zM(2Zy=p++ONJIucbiwR2#8vN+P*m^l4{2wcuqJX-n&Kqv84=A0&|km2zI}Ih`|f6U zb;(J3c{1JIykCFX^^D)W z`R>O*d;RX)_nq$rAr0fjldJvXX}w#&fB*f{C(pX>a+=16$A|4^YX(L<4HNf)GD|oN z&QDQ>C8X8m{F_wkr}j}xtEuntSL;@oT(V2YU_rbuuuy!KUCd) zHiDY1GJn)+JmG>30cJJdUOC%chG5PBG1q2lsq3>LQjLOQ#TAE8{k6Ci3yeU-tb4%b z>ofhE8CN*0VwQ7))o4I%zOKnXho7^0s-WDO8EcL6XI@w`z+A8v=0I8NTzd-ZR97TP z=O%9hU9G9*I2O<2f~*Y${~*BA=5ztOE6~Ly5QA!~EF6Th%~hiTFkiQ_9&@f4&fS3d zzG5I33=Ne>GD~2!C6;q^j`o)@{s*vhF?n@s%VN~{gH`~RNi6fCU6Q)?Zzg-`KGrs~ zmw)bAqfps;*fM>fm=7YVIlhDjfLdMV2+eS9M&SawTf@hdndY@zM*~$#6k1nwjUSP5 z@j!v?6@51sK^3sIf#NEH=B|as%bKZHL!?cK&0WmQmA{%76X4k*w1vXS_qX=I&hm~* zVH`7S>%}sC6%yFX=g%*$HZjHD|LzZIoI>ZlUq9UM3HjwGuaf9@-+yl^?5Jw_cH(`R zbTmz-j>&rm2E+)W(=a;kCB@JMNouAp1Oqr7$Iv-505#tQ0Fac%aRjs+I!G~ft4>oA zFy94Lou(uzt5q0}(`LIiv-`Vy@{EKa*`@YSZS}tyX>TUDpRj zCdWuXkSmDBd54RcfiXd@Jxb)5DQ^oPCe2-K(bk+mM}Wm?TiA=72Lm8QU$Y3x`Og3j zk|+|Evy;*Uhycz|@+kpS%nt)G1ayRfc;$OBO(K@^o(fIkvTj#X1DQ_Kn3RY(FEu1b z=v*HHuU9%w^8K5)663|i?&YV?cNe?Ws$2VQ9Ma8)yH7vqqK*nOJRSqm-~Gcct}ib| zlI#85?ajm8{zrfR%hU1n_WgIypFLgq?#nOVKJFi%JlX9owm*9H1ww< z(w>Nt*~R4=m~K8iK7ak}sS64kdVhEOu-&cu;BRj3x9nG4Pk=zA2oBLiO@$DQ05KO# z#XfA4C_4m%q(Vk)&O7IUBgT{x7%D0|7SU-OyDo&zcNiWYPaG^o(R5s`H))z2``sqQ zG>S}2-g_R$iH(R|7rH4s34jUn`3Z!`#G&t#*%YIs6eW5N4CslK9Xppq%|JyHCg&U>F|qS5#s~mv zI=g_+W%3Vy3ZPp!Le7PL5wJ}iX7JRMf7bOC9hFs8H73?yRoj;vu%g>pnPcrn zRAB|vn6u=w-nNPyD%{Qh9p_$_3+I_At(hfa zs_@T>)GqOeWhl2^Jm-gxI$9qnkZ9Hg8L)laUPCh#{**qI?k(|I!%oc&3TG%3%@o1q zr?WO_*29eapy8U_Q1K1hg4-($Xdhs>;q0 z0wFRX0123=rWl!7lS&3BgoI@u7#ilnge2gYEFV{_3aX+eG3MBlYW^*TM$C?h3DsnO zjH}?co3Oong2dj34{zU{_QT=vn8tSm3V;s}$;ei|@3yN?esW0)`^Sg(Z$FIF(D`t6 z`P5Ojzx!}?`SMTS-J`x=JNm_6e{Q33pg(@|y_xJ*{q}O}Jlwteu-dG*tIiQV9*@4` zF-}Aje5YbhpI#mw4~*nPh$*f5kR%Pm1k3=2TKACyGBUD?8Uh5Sm=Yj3;xtC^7P>B_ z)P>Fz)I?GO!q9~jWt!q@wVtN9yV#857~=q_!*E=0wlO8|*pW{nV(NpR#xy`&uU%4g z?2&0WMP&BDh0dvQO5%e{r_qSFyY1<57^iU+y8D|4dhS-6%^&~x#b5sNmlu~$PH}kg z>dD)$zTIrLtA6+P?ag}Kg%I9-fAiVruiyOX&2Tsd-#y+wY%h0={|!|+tqh_j~1iG(E@07gyMRNq~3H$$8FifO@&8s+Ak z4}+?)3n8q=%nPb4#t>FLhm;L^Y?XT&;aX!E)^UuF$%N{ z4V;m{Y%wmuLBl*am)@^>I)7^Z)}nzMl&dPgWpr1zsW{j{$$V=0FLlRX;nLDhdr(Vn zP-k3zW+^uiQs%{=s|3u4zgLPtT@aYLvZ258L@t1w z2Xt=KS;={;R8SI z{BpEKh$Ai>`eh)c(?wjD|I8Xu7CoyV`;0BhgMVhmpe8m!h3yM7u6Cp887M+DJ8EXL zy9%0|VN%1!izRfH;Z=KF=iSQcD2|yb@1V+Rgc203emcb0pT4@fx_Eqe{N}5#rqeJ^ z>Dh~?#Ps-hIP8y4F0ZbiKl%2}_v1J^W~A!MDw{Y;d^{%%n3{9U&Y9UXO$b1M0svrL zV38tnC21}-2nL#x?>k3)cswK(FeAriU?SbRQUq#F*K$h#H`&=98)%fkZQd)vC)2R75GONG1~l1ViLH1Cm4}&Dyn^dGm58sw@Ai zxfn&p#*T@JxE>cKnn1IzL1yZF2tK&rz0c`FSSCBGOvptQk&$wtKtxbckyHzenn+5b zA|ff8K{@(8#|SWQF)5?Soya9tawOIfXC89w@?oFE?AbZ*!O$^!=hPs|l(Af^=t_hl zmJ0`a?~w@%n8C3#be1f1lQeewFqXHPGG{ikoPuP-*+^@sNl&bjB$uD}2KT^xtix<5Sb`@S2; z>FM()H*aq@+y3F z7;yQjG;YldsOIUsV6FTal?x4V0xWl2 zR8z6t1P#y?ymVIG4BFQ<6LK*+Yiu+xfU|Kde%F+l8Ky3HHGiHtc9tOXG_-ZFV8q2d zH*u2-p3e^HhT*M3<~ktDwLU>r#Y*;nscLRTS(M2zD}|Fka^NonpxN>w%x)rEOkrCE za6a@(0bG)ydNLL^$b!C$rDd>;7}XcdE~Yt#SJq8yZDE6yWWBln^HRr!U?~S^)WglI zIk6mLgR6*yIkQ8ex&i>vGFaXkI$_kRL3iQ>ENFaP3~AHI8gb9<9iudc2xFLz)6 z>1%Z693g^=0RlU+oU9I@CGkc9l-RNNSSoTGGfPZ>xh^ORXfC@cF}dK0SX1)8SJnOL zkWw@N7Z`z3OrZg`gBv0cb55}bgzR}YW&}h9 zKr)BKj!Z31Ba*2?7o3Xa;y-{$x%y$vUML1|nTafYK*4I!49IxBY*d7d4v9(u)O>_> zn-TOr1n;}9?}B$s>~i)IstIDQsR&T^PN15hww(o{5=Bysv3yie)tvpqL`dkEvNciq zVrXWR{q=wdmR+scXQUz`0*Im_3gXyz-nqaOOc2#NCItm1iK-@GioniOOlBg(kn-`v z?3@9xLqg6AVw?swF~NQlyqb4j)IELmWQ_NRVN}y;O5l80IdkZ-6R@kRtMPd9)T6<# ze)n%c%1GY1X&M;a^OsLVWYqim@Y3@kN1OHg?Py$>w=0+`7~>Q z5PVde28ARO434=AVVoxR-m6Jc7hFndnkGpp^d5{*C2&7YX|r9$q{cBOWq{q2_3i!b zi%(y^`QrQa#=|g-F*)Y}k8i&F=IQen4|k9K?pav%5T`d^y!nU!^#A_Tm;ds3yT5vI zeL9W1t8LO4Z{v$kpMU@L+fP6LgSY*G#!&YNY=;r;*R&qw{|siRLdgcrMcce);7ww_0EQcsJJBBxTySF@6En;Z0fy$qLwJr zbanMDH~eo3#s&0SMO9gYXpU}Bc1%`}_q=ssHc2WLn@2s9x%w!uSsnBJWwbT1aRJ}k z!3iH>wQ7PuH53*I380awA(MxUNhI;dt zHsgnygj*PEq1G1|prpOMdpgL*Z_; zdH6FE%>T?kOI+8O1xn^ewMx$<#Egv%U~z^wVJi)I_5!N~wd!!@ah7Xk!e%Hrn|hgP zX3V#=Q7XG-VN-ML%hE36s=oMn+|5)dqbae>1#z^7Bj*I2MdaixjS3f%beX?4J7kJ^ zGLsMhS`po9LdIls%(nnv(dy1ek`g zTla)89EK!-SZO=rf{jgrIymRAe5RnYb5iqHuV*-?X zE^oE27*RwFz;zxGMWU)AWgUv9s$%4T35hW0z=%onE9BY8)=l0)t2O392!=q2jtC9N z5fc^W)*Q=Hc7%YP45}b#6$B+DEW%JFDu5+TVA%(nrj#V55^YCdCU)qI z0(0;l%p5x;aLzFifDtp46AyCgL@61>ga#n0h+gt(t>}kg0)#Y*$_QwkM`BbnQ$tYa zQIxYWr6QOC9p{pSI!yy2qzJ$moSTL?#VN&;=QTTE=i(HT#NU1R6SFbWhr7F;yzjja z&Uc<%kZJt(%Wu*&9)`Pab-7*zb}KY8Q0Hj7+W=Y|rgvX|a2*~~{QUD*oAo-41Cj?x z3ifz^Fx1`dGDgW|_)n*4y;&p3C>kJz>_DtfB((@eDV47 z$GiQ*`UQG+vUcEItRrYn;~<( zZVh2tO&F@0usABK=AR+eJgJKwAVQrKYnD-gFBJqq1(FT4G`KRO-|DGt`~WcPZClJo z8EJiuwT~5jG^~_!)}WZdm3tc#LR0y*^R5xQJha3HSw+=8;i6B)Uz+(S-v@0B6*<

HCt{_{myNsDtXTkZ)32<+ptZ1&@uFOt&mhg!4aN4>lO;IjGSt{RGLYt_9 zf)BjfZM^fQ>G9!l7>3Y$=)&=ExVnDw{MEBx{mXB}tnWhK_3O>*+poT3j|PykD-SUj zphQGb&2eE>12A@unL*4s0zg8HF&Th&4w+I?=Uft*L|4p2PGai&m53b2Q!c_oj!hv> zakcK9cjGXol)65gPN&tTH-ljq`*m>6Pvev%X3?zzh!$KvHy!de0L=w+s^iu z*RRB~=Oh7Q2JVhoM9fSiW%AbiD}-90whC55Kq*Dgk#hz;BG=WeNi#$>25 z*ZI0qaxI>ed00fV!ZTG7QIRB3B}q!z_gen31P(jLtKej?>h4teTMhs_#!DswM)6X$m2j;WUh^&3ZVE z7u(JLbc)mDm>&0!7rV>TDeg8KFiesUSC+`phwgM7{myr*4G1Fm<9^s&t)@YfrmpJ= z`R4uI>(5_}#{o50&yRoH{72i}_V)eb>rbD*dwYZK@bCZjyI=g}FZU0p z_wR0=K7D%g{==i~FD|e4kHd?n&)>iO{^`pn`-jI5Hy^gw7pN4cXlmU$#32RtW1QI2 zs_#xmO{$!I3uMTcL_p1PaV@DD7vCZ>lb9f)Kq_koflGB!U_#8Lv_w@cf%MKP7$S7R z$COln8FPM+m_a_K1HlogXh}?{Si9=$Dw?b0g){Nrz(-5FJ`=U)KD?qo6^wxDS49F8 z5s@)cNw%~adoOUQA@AD$j7MO0^|V}@R7>}S&6^aAr*IDvAWuqNLU|) z>egKV_<3S#e$Zm_8u-TfsY;NFJS!;5w#-Kv4HYGqCt8|I!%{PFX&|WXHvj}|VfKpi zDyeYZ&44p1{OFx^XgR{%pvDZ8ZGJH-<~;xlhMiko0?qn^wY&qC9ESyD{pek#%jYqG z1+mZLO>G`BE^RLNYUb9l)kX?@txZ%amn-v{!}*xf<%<`^WU$5~T5P9M2U{p$22Qi@ zzx1{lpYxb!0^~oJ?(U4W{}=v**@0fxJkB7p*rsTW;TCgtM)BF3kMne#+g)Yt&wSpb z#ykd_ed(E54XV6rriOjQsqNED@desFBgt~uv(F+s5a!P0Ic^D1^{2ql+Vh&jhEO(A z!g6|{feV1*GcAc_W~QRKehMSiilfI3si;xC_&f0t0S*5h0>qpG}b$2VQ$clO}2WW4F{KVwzMOP)G7=K z2!upTrGAnbfQi;y1p0Ni-EI(BG(A2(#4)m?zVm7+9@2}KFP^`C@lXHwuYKoN-ZQ(^ zX8rwl@5vz$Tg*ouS>Ah1fJxP|_ehP2fLP5iDmn5@l0-yvW(+gODX}91Gtrf2Fq}?P zzwVG=I8G`F0FW>zkFQoedpC_SO{wcUGzi`!LK>p;M9eAXd>C^~#eSsX7AvloB3iNo zNQsDvk-$t<6d@!jOB8|fK?I0M`3#QG zv!;B`fFS`9<&cYl5fZTz7gS{$rYI93AR+i%v%Yf*04hkNHj()>#Sp@J-3=#@ zyqP?ScV5ZH(<$^JiLSaHEgPcoaNM(VfUsMyZ8GP=5T_U?a!Bm!(-GpWQv)zxn2ypa1k{n+x~- zckiFSeDU2k!*1Ju^{202fBt$n47VRXTt2;ee7Ji&JznjeBuLj!w)Y=ypT2nd;k);T zhr`vy1rVsE@g(c*#c98Ho{x`*?#Z=Zt>SPr17=FokTuI@fwgh| z)TDj`;Ry4mGl4umuuPPJ2BLGj2w3y`D|%W$pxK>N4+*Xh!mRVHs;(J%)x?wxLMo&% z%MtOaP@qDM<-3{|tf&Dia$5wFt01cbulWo!sAw@_Q!UO8o9SW=VPMV<`lw_+LB6=e zki~#NXqE<)fwv@*I!3HW0T*q~KY37}lJ#zl+SteLfT3F|kN z0NDKKsHLa%k@nW*Szh^?&3fLTf+5WCrdmu3lLuP#p!C8_b3YW&nJFUXt-npTS+&aM zmfCLamM3&>%))%r$7=y9Z=Dew786-n8cOcARTSDNQArGEl{i~)0MFVf`!dQBAZYCu z71{`f4XrkyyTo|V8m^C*by+R(d3^POI*8ikyx13mx5cpY5Sp8RrdL^D9Sdy5m2f7uaj^*7Dr?l6 zhmLJcTU#Q{oNad&zFp9{sew7PS1qG6F}VCGt=m#MnkxQ8Rn;gdsfdaok|QGGE;#4dl@J91 zDpduTQzMcf7^;f*KG$^e*&G4Ni5g}mU}#22%uI+PN@Rq{o|wqk%mBy;0Es+fN+2;# zctFPpKtLjbOzhAMdiEADN}8rg698JS1(j0Dd#RDo08KzekqH@7ltBhXP!-37ijwpw zr(u{jD;K)XR6Ntl1?A{go9;S1y}lZb19;XX&n}-O7>Cs8JbieO6n~T+U7>8(*_Hnyjjc@N>zPf&QcOx+pyM5^Y!8;6Mr)r<($j6IP8p~Wcd2@Fs{6_AVoRE3>SDdv2y zX+&aHl{7{24hd2e0AuI7;A28FoW@9m!|_OneZP{ZedrU!=@569;WVVX`NEf@#EdY zi_e~Y_vMFi71d<7-I~%g4P75j3I@h1ouC5X27k-` z;RPxMsI|Ou15^QXK@(^AxT!dt!Ei+@)d^hQX9h^KYp(n*3T&ZsO18Y3i5Z%)QP`#=0L)%P%&wtwf4g28qcTZht6EB;ogtl%SH?CSgrp(> zh^7wnd5#qUl=-TL#p0(qmlvb0n4&$6Py*tM`6{qx=AoJB&_Yr5Qu$-H-^%Y|r6OWU znVZek>Z-21SwaZSE~+oWHiNi$e|rQF(5TGN!Vhh&gH=(_<_s2uOpES*%nGxKVKW}j ztD_n!W!h%!jJUKDD)_Y7Ho`O9H=}%PoY2^=2rm0U?+Q1ZIpoi#yur`1PFf~OOGjIP z;&~ml-si8E#8|LYbvj#v&2SbSsf(amY%_JsP_1xR6E#bQZ4a~sofU(YaDs`JGb8ff zs@WpQ%@zi!dTwC&x4|mt=Nvxn1|GDNVz0I-N$9a`-Mg1fpr2 z7~Jz`&nV!pe)St4T;KP7=$&)#-o8UN12##_EULNA3?s#)9V37uqGtl5G^zLGgEIq5 zY5*yj^URLpl$<93kd%DqKtZM$x`2eI!%57%cbU_sVOp&Nd#B09)3jQ5003eV6A%XP z+2#EMlZX+6sS#l*c2t~ZdEpuY5R-^zBh(}1lL}IdK$y!r0%18VxXPaFi8q6sqdc4O zkdqf`Mo>}V$dtF%TD4sP$WV=$9a880y6e1W$3!mIQt;i-IFqosf(ZU3>i3YiRC>tZOg0d-MIk8byymRP46)dM~ zBSld#Ln2Z@a>2t$fT%KwsUZ^}#yAo?LQ(@WaE{!nGcYDLGf_bc$uv$Q0<&WgK?v+Q zO=+4Yv1n4xDbC6CYOo48?x!v|O?n*S)wBNc@?x`I8<>m|T&JkKvaN^TfB9a_n1Bf` zw(FO#o)ci4#{I*?VSl*1+PrxEg2_)R`-g|?-3F7P!rFyV;MMb|4~OG)9MJ)p9UiC4 z>zzspKBPFAap!}?NNN|m_31dIDWZemy(CeyF1Vx$s!0LNh`H=kF;fvH29*$46eOyl zkV8g4p7L(>ejKJrl|03moOjH|mO&h`TX!)|+wE?@e=vy`+ie=tkAME7fBUC@`)~j4zrFs^`1K#Z z`1adxU%q(#u)pt-R-5hiYWv~s+sn=N;^K0c_NRx(SD(KA@^^pQA0BpmwOVfw;dp=g z?DJ2*{pQ=<<$5?CFD@?QG~v2;?51hzyKXq1y3naa=N+0LIT2x3PLqawyf&d@24c>6 zQz;>lCefUIhoB;w_pU$!qkKS^sHzAPWt-DE?^s4kDgyNYbxD$s2L>=ERyI`un03(X z`Z?1F^^ca03DwD8(>dq+u(el|HR7_B3fU`2pTT-X_RY%*C3x77>H>B($Xd*d8jYTD z0764MGcao^VfKYXu~p7I>j*IK8-NN*fNGBDtZl09tnWcI1gn*Qth%k6IR=$juEz3RDr$d=SMnq zG1W7ot4}R5vDzIA_h~!0w=&1_kMer~Y;oBLlxG(Eq31Bz7F$9aZLByPu}<-l=2jv{rGiaG_q9w=HEbGODsJDl*03T* zBy9ULtgQo^vHY3awAo~M*2zj~vw4+P7SAs)+tmSDDb`u5e~h@>I&U_?49jd0`v7a% zW_49m&}+@)TF8Kz!Egce8%{o3^)sZcGuS#*1xkJ44}KR3qi3(E9NjLISdCTQXeCA$ zY;k4^)cc^0v5tFj|BRHXgj)Eu7uHfU0%|ZMo6MHa2u8|f#Z?uFOGt|-3joO5D=}|G ztPkfiR;|d1*6b|S=0!TMjOxW-N`dp6D?c=;w+t%4k~~;-$l1D@|Ae;wVIezkCf599 zU0Ka0!4hvQaOU%l+Ya^VQ9|bAGi7?Zvm~u^yB#KC);)uL+2n1$P z5&(7HA+tmwA~2Z7i5(%5nsoh2G)<=yQciS4CK|@r_nyc}l4%&iIslT1O)-YftE%^2 z#qt(jcC4ZRz|2-saV%d^GhecOpyF5X&H-Rb2@yq&5iK8gNyN+*#j2L8239M2mB1^S zfgm!JDay6;8EIAuYLF9OopauK->p`ibL^aJsi=ATwGp5x8cIq4Y9eS#NZa6@^9aC> zF)L0WQ`IC>6g4#!%xHlLEFUwinY}FQZBWXY)!F+;M#zR_29qR^L_ov}n$wUhDKJ?+ zYZU+~7ykxD6NyGlMwrixKro9bn#O#{ain|@@dybJO%xEFcN|vCJWV4ps-$U%ssgBt z9M*L7RMZjATd{A%@N|8VGff4RF1>u~q}{&+mx-rlb^t9~8!kH<7k-iL>9c=7V- zZnr%gj-nzdcA*!I@4o#$p=`J7Pd<4Gh<6YBUGF`tlG!khm(RC?z>bC~4%2XXeYHP4 z#%b(2?>%zp8K!-T!{Ky&bv2HsBr#1f^qvC`$H7D#lZb*EnHqv4149vUglYz4s$int zyC{Mc;@BkWu6!^S}J>|8RG+`Rw)TH~;eMzxdC8x9u;6!-w13`yc)I z^RK`Ds_Qq0GEgbS z`k`z&vW)!D$OoUMQ4pPXlf^WNs${6ZjN}N&2q_IIi8{8tcOqZWuX*WQhCW|F)&0j zI9ESdyxEZJG%VcKK(jNbBtZPYRSE!rw(!ehQ%M!LRKI*l9-6UNGd*%si+}(cfFYWy zDJrR$GN|RaLD5JRWr7)kni5oeg`fs(6^zzIj%pyxs3HS?tdo$tzqq}q-1E{&Gx4+k zWr-*%4xGaz%`G?U^K(z<$DgYm(PnXx7Lq4!iT?5<@WVgqpcLx4(Y2ihl1f5F=|uC` zqs{Qe3W&*A(Vc~*ng_|szU`V+RKe#NAJ+nzRw3lV*v&mC1*aqi>}h*^=YdsRO9Yx3 zQb7$&Q_eRx1prc$=J}|uigV%EMqJyitFCs#>Iz(>cb>CDCFvqD3ujW+&FWM=1o_OS zto6@T44%`dQL4Uh88~R%)-1mw-}47Gt?RVZ^QogNOju4(~8evwpZg9&a9j05Ci6Imdj-F#w1f z5S8i>OrB^MQWqS1HUphRG!X(hLZldzigvwAlXSfok!hG#n_S5!CXrkz2msTRm@t*-KnUR1{lNyqONm3$o zgaB-2goFgDN=Qa%pejHF2$UoOS>6=QWp6N$BUMl_0Hbm@0Oq5Bvop$a*a0F;NnG8b z;etZ|X40q#HlC)*rol&v3CIlG{`PUb?eE{8?(gmq;c~rVGO48xE_JMa8%b2^^#CNIpDtl|hpJ~*3_sxcub zBIm=~h;l8+d?>c)q@xcZup3UtZq;|IFdR<+-~-DPF(|u$fHB5y)hSrlbxBjM&H8xv z2!^{Y0$2$BdaKhgIM2t!$+^d?-Q{>Vt~MJW8V^Tgj3}$k%1qwBzkT}T>fQUBXV0G; zkH>Gm{N|Ux_{GEh@$UBK=I;LUpMCb5-~Rq@{_3xO_nY5ezr6n4zy9{W{BQrwdG~OC zA9}amZrT_H;aKH)~1BhcHc} z=HwC}6(KZ3bcmwKMDyvt-FlVOWEhAXp$U;`-dIV5#LmZQR1+|aA`YGAkT4oBx!{wE zsx}0zqKI5v+{j9RVzY~IjW@M1UeRI z52aXnZJ}zfEEEW5&wuSJ~0imd*1!kLFNhL~&)i7u4v2Eio zuK$Jz(9E*tQ3Wf`6tJxO&NeWVQlVCJj_SrbGMI~l<`-E_WT{3E+LEe;bOjGoOXf^h z*Lg&oYi!ohmCiJ03fA$gnb!W!ED7kBBJJ%tpFD1X>DPq<;<0) zD~hc>IUisnPwUeX`p$Eb0YfHanWXAR$JX1A=eSxQScurJ*Rfga=Au96_tY*|?yi7) zUf<9HFMuuI#TL!ZtWa&)Im@T5e<+p=F6ok+$U6b+IzQ`UWtv=63|s7Hrfl({7PL?h zRvTNp4oKzXA`?*sK}2FC0yH2X)0|gIkqosk`$vmzCWqAsWg}}fI5OimlW>kov|qC} zY4f+#Db*5~8DsH+bFOOlH=$4gW=Y+__Ljy6HJMMdL@eaW0vfdj-^}uoK~3tNU-f;z zSrL&)-0u%loFv6;*NLciE_hB+yk|q4P9vfF$hkfy&H#`oiD*gy z$PUeDngmH>%qJiVVYZJf#nHgxG%+zbSI!?J+O0P+MFmA9GhudJ@G9DEcZ|4QZ=5IR zU2wrt8i%Rtg9`RtFoMI~W7qqBy~>Hv`-g{L{f{pIbrrh5{ky-CA?+^KH}4*vKD#;` z9+SrRkH;1B_Sw_J;m~jT6w~9w(K!!{-g`q>uUE&%T}V@M&Zz-{^q~_25$ii2W3FIBVvs;gm5?+eRt0qcBFFuHv)u;nhU2)}^t7VW z@u;fKI|LNTHT!8ACf{|c(US-74~Jt2e0bce%GK5NX&n2mlPG42gopbF1bp`VY1Z}Z zy$fy}Ck_FQQC-^aAFr=>cX#)%K6&}aKYjWB{fD3Z?5F?zzrXqNt3Uks)6aLC{>|5K z{_<~r`TzUx|KoDE{`J59%U}G}Umj0~`w#b**Sm-BZyp{V!m1lj5<;IqyDpqgr|rcq zO%V*HVOnk0rV-SFcPUMQoT`Q3b&7;&Du9@BZW-lc@KDu|fE}&+0BR|bL@~7-#4}T3 zVn!yMz!HF|q-2PYYwNN)Mse&XiA{VP7^)Rd7Xl$Fp=kp%_>uIrkA?A>T*fBw8%(Go z|GbGsP~l^MwD5K!b7>MRCt!2YzgdQg!&E`Jy8R2vMFTU$mVHwFqZza1EWe6)a0%!O`p?FV zHPx2&aYcP?m{5^diFM~qZWRfGLbV?XvM-~>ifwDIN^PtH7i@}rnJ!l0Y%QHL1FVW} z>q9s*)Qt9u&TnCs3L9!F#GHOGGh@r2ItNq@7o&mEM|%L;n{m-3;74$)!cK%1$f&jh zV9gsUl&m&s1IJ}vK4O~uL_;yn#KvlSLNQ%uAAJ3%d|y~{!MH7H$8s)En}ddBE1+)+ zV-5gRpmf&BGScd4#~JKa0)2Gv8GwTZPS1X3xLlzc)=t!6H`XcK(VA#?7UZ|wRR8f$ z%_Lb&;aML`E4XX{OC=MiCeUnF&(__XmQ&QV2o2XKu(YV8Bq{Q9Rh>}?-vO>TmE^K z&CK6MgKfCA+vk%}h+WZn;U1g^-atRL|J!V`Rc4(%10g?u@$}~H{lor|y)y)x5;3NvqA7rbKzDo0;ocDiGe&{VXMsfbuX=XstCN}_B=$3>1g0#sx! z6|r;GJVVIkH3=xN>%8y#HBxepOeLSlkR(AVoB^fyp#dYQN-6gV8NygD=9GQ*zV85t zz?cwBiR)48dDwY6qI&OK2nafkr!sUAX7({j;r#P*>qTKJ_zy0<@k_il+K7I1(C!avX^=kb% z9zJ|{SYLF9aR8z5IIMz0LC21mRqe1p5z)ny&BKTN=`?hG#}3g9v9N&yT6e4ca3aeU zQRR3X)wJ^t4PsK?`)M*VOJig%+or_~h)|T7)IgFVAUgyCRgP*1Hcms=tyaB{!`SsJ zH6N3XW9(NQAgU=7BS4%YG3I%>+-=8c8q+k5ynlG?HvKe>{kk)P;qfSd(-a@?9-q8; zwp#D*Ztmkav10&qeP@FtjSg3x>yp?fFJ65A)mNYV*Z=2dKmO6(hqrg#?I)jo`ujh8 z`Rw(JU;g!9|MoZkIvySlkB?8EUcGL^M-i?=&U`A_4(H09DQKPeef!0Gtn-4IU22KEXJdSyBjWQ6kpJ znTe{H_{2<@kDn!DN8X&O#$p+mDJUorXqJtHjFeQ7FjopX7wFc+`I&rQ-ciNKEg=3cz;#XIhQIcV8{W{?66Zng`9qx?Jm@;e2A+*vOxA4&Z+4T6+7fEDF7Kj z5nZM;zRQURz|G$eplWr11vWG|Q2~7Q4mZ_{I3tRABF<)c;T*1I0gK7kz~sy#v%$95 z_193*>{PV*o5c*&#?G+L0=l;yntBEYo0SC_(3k<30J;W17us&l0x0YOKLkScPFqB? zD-xQ~aK%7%H^oe5XvhN#g&TmhMp39KNoCMjCOX?=IYptyCCUuU<@KtQy47mMGP}*I z-zL799m`z0*`TiP&o;_=4*D54ER7`i=)yVa7M~Z>jq}_V9-{K+Ikx`uZB@Ih_Q-5W z)yj(Pt(h@@D7i|{7f>AJwX7gno&wb?r7#^LyI{~#&GluBL)BLU<}+s->cP|+yKGqHEa$79#8Uw!i8 z%dg%X9``BZB_vA`0!|;c{2bQND@iX_rZHNjxk9LD=z|)5(2p3Gcz0EG(=VN zo<&O>l5*WoGc!o04hv*0q*5ayVsgZUG^S`^L?}s1fqcyM`*X0{OtpD;2vExcH7pgD z@}wXm5hG<^89+VV8VM1-JLet8C`#6azH?!JI!cP0-6~D#bU2a6!)YI<7^ir+f1IW%bRn#}C(oaF z3f*>nv0jg-Ar2EeB&XL;w!{5!+8;H_dfgq4NAKNfI{D6@#=&>ITCL)ghGAIueZT4Y zupay=juSH~nUQsP5uGH_u5+rs>oljEulk^e0maB5C0(t$X^hh_A`=mbsAG~Opjzfg zOKlqRA*sYMMVz|6_deGJ>Io7m4#(5>a%(^m6Z;@C0dPujwen=njDTr84gio$o?Jgs zQBb^ka{d0p?dh;b#MLxyL%4qW^zq>+n%;hW^ZCzya_IVTe|+=Z``15ubv#YG%j^67 z@mIh5x4-)3FaJf-&HZh6wR!pJ^FRImPk;CKfAjL;)$e|D`@7%$_CNpE|7~*_KfJqt z@#^`*!~Xv6=9ABUv_A}ToWc{|!)lPzX*?lPFm%9alrc@~bpVnnM&CKio7ahuOhu4# z{#sEjNR*-!JZKQSQwhn(lPG9D=?gUh6RPBxfQcyOBC}|S;GNT2exRZV05DZ$!ct@= z?_jU_dp}gX@W1}CD#9~}I@5UPsKMI*YT~uk2a9J5!N4fX_o6_}YFcUzkC&6(v0|b* zm1fz|n%z)yK8iOqi;j{QR096i^bi_S$$73xtXOmxEvm$dr(WsQ5&{ki_tmxP5Sff-yyf+jq*FLIqQO1_HPb^ez z%?h7qsQN%5A1^&q)y@G;nIN1oX{FOgl(&{ZQ6{Frw&qNSGbD9J&DzLZ)8(TZ&%nwI z6bc?v(}lSM1m@;jS{q2UjP>H8E&Y{qzY6ad%x`YJJu7OGF@DWCYqnxVb2T3gX3tyw zSRZaFU(l|fSz&X8p|-que?zt(mAu7*xv>S4en9;iTgs*V=9gkIXe!;$0XEKNL2iD= zgg=;BY?;1@ZIM)j-KMhg>5?1T%9{mCy}o#RWyOUL`TVEO9oB_aVYkgF6dD(0f?!>4 zXHC@6e0&k=x@r`Gh4;LfK9y-R)GfCeENO;ql`lBnvfM0fR^VOURzxEdM~4~{Ap)z@ zsH6ZOxl%+%P>yL5$+#`&;Z%Rd!lJG*h!zO>h#_&A<2TQKVd}F`5W>9r7cI=fxfmDK z$RMmDu2JEP%vop`MzzJ$0BU8IL;;qBAQ`!_53UQ{dcAV&h-jLI{p0;O4JjovsAEUV z#UCM?4UoVrfoJl8i12hg^}he{Pd@q6@4gU8jJR5N+wJ<@_jju5ItR#U8rgHM$3(sb@Kq^!88i{G0ki_+xi(a;z*xBw4G>Adj0lKa)~03#=*kQ*Xi@+WJ~uVKZG9O3@)nAEnLwF-=f zq3eTp?3|A>t-A0i$+62iZ<2fO003i}h|Du4QvhJ3RS3snT<=zJ7z{K7!UVY#F*BMf zGcyqoPNRaE#OS&pVoV5qkQhg_O}`n&3BB{4iGdsr$D!+c7dXY(g)pVWNK>3b=-A^H zR;VDFrpeyF|M2YD6GW6~PoF&f?(N&4^7iX*FaGkEMtF67^>{e!F7@5}H!oj*%1DR( z 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 ^hloS4cNo? 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

EW&;m*>U3?G5e-P=Tr_1()#wzx6V7~ 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

!5Dsg% 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

rt@PTe2dQe7-G|U00Xr+ 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 z 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

rAXPzrE1;lM(Nx2 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%0DyO8_ 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∈s@V1!^8hX#e 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 yHHBKc5STts) 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 QoWc3o& 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 IM6N<$f@BGDcK`qY diff --git a/src/diffusers/models/attention_processor.py b/src/diffusers/models/attention_processor.py index df6c00099859..afe6ba6a3658 100644 --- a/src/diffusers/models/attention_processor.py +++ b/src/diffusers/models/attention_processor.py @@ -4299,10 +4299,6 @@ def __call__( *args, **kwargs, ) -> torch.Tensor: - if len(args) > 0 or kwargs.get("scale", None) is not None: - deprecation_message = "The `scale` argument is deprecated and will be ignored. Please remove it, as passing it will raise an error in the future. `scale` should directly be passed while calling the underlying pipeline component i.e., via `cross_attention_kwargs`." - deprecate("scale", "1.0.0", deprecation_message) - residual = hidden_states if attn.spatial_norm is not None: diff --git a/src/diffusers/models/autoencoders/dc_ae.py b/src/diffusers/models/autoencoders/dc_ae.py index 387356574867..6390afbf8078 100644 --- a/src/diffusers/models/autoencoders/dc_ae.py +++ b/src/diffusers/models/autoencoders/dc_ae.py @@ -13,14 +13,16 @@ # See the License for the specific language governing permissions and # limitations under the License. -from dataclasses import dataclass, field from typing import Any, Optional, Callable import torch import torch.nn as nn -from omegaconf import MISSING, OmegaConf from huggingface_hub import PyTorchModelHubMixin +from ...configuration_utils import ConfigMixin, register_to_config +from ...loaders.single_file_model import FromOriginalModelMixin +from ..modeling_utils import ModelMixin + from .dc_ae_blocks.act import build_act from .dc_ae_blocks.norm import build_norm from .dc_ae_blocks.ops import ( @@ -40,59 +42,6 @@ __all__ = ["DCAE", "dc_ae_f32c32", "dc_ae_f64c128", "dc_ae_f128c512"] -@dataclass -class EncoderConfig: - in_channels: int = MISSING - latent_channels: int = MISSING - width_list: tuple[int, ...] = (128, 256, 512, 512, 1024, 1024) - depth_list: tuple[int, ...] = (2, 2, 2, 2, 2, 2) - block_type: Any = "ResBlock" - norm: str = "rms2d" - act: str = "silu" - downsample_block_type: str = "ConvPixelUnshuffle" - downsample_match_channel: bool = True - downsample_shortcut: Optional[str] = "averaging" - out_norm: Optional[str] = None - out_act: Optional[str] = None - out_shortcut: Optional[str] = "averaging" - double_latent: bool = False - - -@dataclass -class DecoderConfig: - in_channels: int = MISSING - latent_channels: int = MISSING - in_shortcut: Optional[str] = "duplicating" - width_list: tuple[int, ...] = (128, 256, 512, 512, 1024, 1024) - depth_list: tuple[int, ...] = (2, 2, 2, 2, 2, 2) - block_type: Any = "ResBlock" - norm: Any = "rms2d" - act: Any = "silu" - upsample_block_type: str = "ConvPixelShuffle" - upsample_match_channel: bool = True - upsample_shortcut: str = "duplicating" - out_norm: str = "rms2d" - out_act: str = "relu" - - -@dataclass -class DCAEConfig: - in_channels: int = 3 - latent_channels: int = 32 - encoder: EncoderConfig = field( - default_factory=lambda: EncoderConfig(in_channels="${..in_channels}", latent_channels="${..latent_channels}") - ) - decoder: DecoderConfig = field( - default_factory=lambda: DecoderConfig(in_channels="${..in_channels}", latent_channels="${..latent_channels}") - ) - use_quant_conv: bool = False - - pretrained_path: Optional[str] = None - pretrained_source: str = "dc-ae" - - scaling_factor: Optional[float] = None - - def build_block( block_type: str, in_channels: int, out_channels: int, norm: Optional[str], act: Optional[str] ) -> nn.Module: @@ -292,48 +241,62 @@ def build_decoder_project_out_block( class Encoder(nn.Module): - def __init__(self, cfg: EncoderConfig): + def __init__( + self, + in_channels: int, + latent_channels: int, + width_list: list[int] = [128, 256, 512, 512, 1024, 1024], + depth_list: list[int] = [2, 2, 2, 2, 2, 2], + block_type: str | list[str] = "ResBlock", + norm: str = "rms2d", + act: str = "silu", + downsample_block_type: str = "ConvPixelUnshuffle", + downsample_match_channel: bool = True, + downsample_shortcut: Optional[str] = "averaging", + out_norm: Optional[str] = None, + out_act: Optional[str] = None, + out_shortcut: Optional[str] = "averaging", + double_latent: bool = False, + ): super().__init__() - self.cfg = cfg - num_stages = len(cfg.width_list) + num_stages = len(width_list) self.num_stages = num_stages - assert len(cfg.depth_list) == num_stages - assert len(cfg.width_list) == num_stages - assert isinstance(cfg.block_type, str) or ( - isinstance(cfg.block_type, list) and len(cfg.block_type) == num_stages + assert len(depth_list) == num_stages + assert len(width_list) == num_stages + assert isinstance(block_type, str) or ( + isinstance(block_type, list) and len(block_type) == num_stages ) self.project_in = build_encoder_project_in_block( - in_channels=cfg.in_channels, - out_channels=cfg.width_list[0] if cfg.depth_list[0] > 0 else cfg.width_list[1], - factor=1 if cfg.depth_list[0] > 0 else 2, - downsample_block_type=cfg.downsample_block_type, + in_channels=in_channels, + out_channels=width_list[0] if depth_list[0] > 0 else width_list[1], + factor=1 if depth_list[0] > 0 else 2, + downsample_block_type=downsample_block_type, ) self.stages: list[OpSequential] = [] - for stage_id, (width, depth) in enumerate(zip(cfg.width_list, cfg.depth_list)): - block_type = cfg.block_type[stage_id] if isinstance(cfg.block_type, list) else cfg.block_type + for stage_id, (width, depth) in enumerate(zip(width_list, depth_list)): + stage_block_type = block_type[stage_id] if isinstance(block_type, list) else block_type stage = build_stage_main( - width=width, depth=depth, block_type=block_type, norm=cfg.norm, act=cfg.act, input_width=width + width=width, depth=depth, block_type=stage_block_type, norm=norm, act=act, input_width=width ) - if stage_id < num_stages - 1 and depth > 0: downsample_block = build_downsample_block( - block_type=cfg.downsample_block_type, + block_type=downsample_block_type, in_channels=width, - out_channels=cfg.width_list[stage_id + 1] if cfg.downsample_match_channel else width, - shortcut=cfg.downsample_shortcut, + out_channels=width_list[stage_id + 1] if downsample_match_channel else width, + shortcut=downsample_shortcut, ) stage.append(downsample_block) self.stages.append(OpSequential(stage)) self.stages = nn.ModuleList(self.stages) self.project_out = build_encoder_project_out_block( - in_channels=cfg.width_list[-1], - out_channels=2 * cfg.latent_channels if cfg.double_latent else cfg.latent_channels, - norm=cfg.out_norm, - act=cfg.out_act, - shortcut=cfg.out_shortcut, + in_channels=width_list[-1], + out_channels=2 * latent_channels if double_latent else latent_channels, + norm=out_norm, + act=out_act, + shortcut=out_shortcut, ) def forward(self, x: torch.Tensor) -> torch.Tensor: @@ -347,49 +310,63 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: class Decoder(nn.Module): - def __init__(self, cfg: DecoderConfig): + def __init__( + self, + in_channels: int, + latent_channels: int, + in_shortcut: Optional[str] = "duplicating", + width_list: list[int] = [128, 256, 512, 512, 1024, 1024], + depth_list: list[int] = [2, 2, 2, 2, 2, 2], + block_type: str | list[str] = "ResBlock", + norm: str | list[str] = "rms2d", + act: str | list[str] = "silu", + upsample_block_type: str = "ConvPixelShuffle", + upsample_match_channel: bool = True, + upsample_shortcut: str = "duplicating", + out_norm: str = "rms2d", + out_act: str = "relu", + ): super().__init__() - self.cfg = cfg - num_stages = len(cfg.width_list) + num_stages = len(width_list) self.num_stages = num_stages - assert len(cfg.depth_list) == num_stages - assert len(cfg.width_list) == num_stages - assert isinstance(cfg.block_type, str) or ( - isinstance(cfg.block_type, list) and len(cfg.block_type) == num_stages + assert len(depth_list) == num_stages + assert len(width_list) == num_stages + assert isinstance(block_type, str) or ( + isinstance(block_type, list) and len(block_type) == num_stages ) - assert isinstance(cfg.norm, str) or (isinstance(cfg.norm, list) and len(cfg.norm) == num_stages) - assert isinstance(cfg.act, str) or (isinstance(cfg.act, list) and len(cfg.act) == num_stages) + assert isinstance(norm, str) or (isinstance(norm, list) and len(norm) == num_stages) + assert isinstance(act, str) or (isinstance(act, list) and len(act) == num_stages) self.project_in = build_decoder_project_in_block( - in_channels=cfg.latent_channels, - out_channels=cfg.width_list[-1], - shortcut=cfg.in_shortcut, + in_channels=latent_channels, + out_channels=width_list[-1], + shortcut=in_shortcut, ) self.stages: list[OpSequential] = [] - for stage_id, (width, depth) in reversed(list(enumerate(zip(cfg.width_list, cfg.depth_list)))): + for stage_id, (width, depth) in reversed(list(enumerate(zip(width_list, depth_list)))): stage = [] if stage_id < num_stages - 1 and depth > 0: upsample_block = build_upsample_block( - block_type=cfg.upsample_block_type, - in_channels=cfg.width_list[stage_id + 1], - out_channels=width if cfg.upsample_match_channel else cfg.width_list[stage_id + 1], - shortcut=cfg.upsample_shortcut, + block_type=upsample_block_type, + in_channels=width_list[stage_id + 1], + out_channels=width if upsample_match_channel else width_list[stage_id + 1], + shortcut=upsample_shortcut, ) stage.append(upsample_block) - block_type = cfg.block_type[stage_id] if isinstance(cfg.block_type, list) else cfg.block_type - norm = cfg.norm[stage_id] if isinstance(cfg.norm, list) else cfg.norm - act = cfg.act[stage_id] if isinstance(cfg.act, list) else cfg.act + stage_block_type = block_type[stage_id] if isinstance(block_type, list) else block_type + stage_norm = norm[stage_id] if isinstance(norm, list) else norm + stage_act = act[stage_id] if isinstance(act, list) else act stage.extend( build_stage_main( width=width, depth=depth, - block_type=block_type, - norm=norm, - act=act, + block_type=stage_block_type, + norm=stage_norm, + act=stage_act, input_width=( - width if cfg.upsample_match_channel else cfg.width_list[min(stage_id + 1, num_stages - 1)] + width if upsample_match_channel else width_list[min(stage_id + 1, num_stages - 1)] ), ) ) @@ -397,12 +374,12 @@ def __init__(self, cfg: DecoderConfig): self.stages = nn.ModuleList(self.stages) self.project_out = build_decoder_project_out_block( - in_channels=cfg.width_list[0] if cfg.depth_list[0] > 0 else cfg.width_list[1], - out_channels=cfg.in_channels, - factor=1 if cfg.depth_list[0] > 0 else 2, - upsample_block_type=cfg.upsample_block_type, - norm=cfg.out_norm, - act=cfg.out_act, + in_channels=width_list[0] if depth_list[0] > 0 else width_list[1], + out_channels=in_channels, + factor=1 if depth_list[0] > 0 else 2, + upsample_block_type=upsample_block_type, + norm=out_norm, + act=out_act, ) def forward(self, x: torch.Tensor) -> torch.Tensor: @@ -416,21 +393,45 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: class DCAE(nn.Module): - def __init__(self, cfg: DCAEConfig): + def __init__( + self, + in_channels: int = 3, + latent_channels: int = 32, + encoder_width_list: list[int] = [128, 256, 512, 512, 1024, 1024], + encoder_depth_list: list[int] = [2, 2, 2, 2, 2, 2], + encoder_block_type: str | list[str] = "ResBlock", + encoder_norm: str = "rms2d", + encoder_act: str = "silu", + downsample_block_type: str = "ConvPixelUnshuffle", + decoder_width_list: list[int] = [128, 256, 512, 512, 1024, 1024], + decoder_depth_list: list[int] = [2, 2, 2, 2, 2, 2], + decoder_block_type: str | list[str] = "ResBlock", + decoder_norm: str = "rms2d", + decoder_act: str = "silu", + upsample_block_type: str = "ConvPixelShuffle", + scaling_factor: Optional[float] = None, + ): super().__init__() - self.cfg = cfg - self.encoder = Encoder(cfg.encoder) - self.decoder = Decoder(cfg.decoder) - - if self.cfg.pretrained_path is not None: - self.load_model() - - def load_model(self): - if self.cfg.pretrained_source == "dc-ae": - state_dict = torch.load(self.cfg.pretrained_path, map_location="cpu", weights_only=True)["state_dict"] - self.load_state_dict(state_dict) - else: - raise NotImplementedError + self.encoder = Encoder( + in_channels=in_channels, + latent_channels=latent_channels, + width_list=encoder_width_list, + depth_list=encoder_depth_list, + block_type=encoder_block_type, + norm=encoder_norm, + act=encoder_act, + downsample_block_type=downsample_block_type, + ) + self.decoder = Decoder( + in_channels=in_channels, + latent_channels=latent_channels, + width_list=decoder_width_list, + depth_list=decoder_depth_list, + block_type=decoder_block_type, + norm=decoder_norm, + act=decoder_act, + upsample_block_type=upsample_block_type, + ) @property def spatial_compression_ratio(self) -> int: @@ -450,125 +451,94 @@ def forward(self, x: torch.Tensor, global_step: int) -> torch.Tensor: return x, torch.tensor(0), {} -def dc_ae_f32c32(name: str, pretrained_path: str) -> DCAEConfig: +def dc_ae_f32c32(name: str) -> dict: if name in ["dc-ae-f32c32-in-1.0", "dc-ae-f32c32-mix-1.0"]: - cfg_str = ( - "latent_channels=32 " - "encoder.block_type=[ResBlock,ResBlock,ResBlock,EViT_GLU,EViT_GLU,EViT_GLU] " - "encoder.width_list=[128,256,512,512,1024,1024] encoder.depth_list=[0,4,8,2,2,2] " - "decoder.block_type=[ResBlock,ResBlock,ResBlock,EViT_GLU,EViT_GLU,EViT_GLU] " - "decoder.width_list=[128,256,512,512,1024,1024] decoder.depth_list=[0,5,10,2,2,2] " - "decoder.norm=[bn2d,bn2d,bn2d,rms2d,rms2d,rms2d] decoder.act=[relu,relu,relu,silu,silu,silu]" - ) + cfg = { + "latent_channels": 32, + "encoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViT_GLU", "EViT_GLU", "EViT_GLU"], + "encoder_width_list": [128, 256, 512, 512, 1024, 1024], + "encoder_depth_list": [0, 4, 8, 2, 2, 2], + "decoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViT_GLU", "EViT_GLU", "EViT_GLU"], + "decoder_width_list": [128, 256, 512, 512, 1024, 1024], + "decoder_depth_list": [0, 5, 10, 2, 2, 2], + "decoder_norm": ["bn2d", "bn2d", "bn2d", "rms2d", "rms2d", "rms2d"], + "decoder_act": ["relu", "relu", "relu", "silu", "silu", "silu"], + } elif name in ["dc-ae-f32c32-sana-1.0"]: - cfg_str = ( - "latent_channels=32 " - "encoder.block_type=[ResBlock,ResBlock,ResBlock,EViTS5_GLU,EViTS5_GLU,EViTS5_GLU] " - "encoder.width_list=[128,256,512,512,1024,1024] encoder.depth_list=[2,2,2,3,3,3] " - "encoder.downsample_block_type=Conv " - "decoder.block_type=[ResBlock,ResBlock,ResBlock,EViTS5_GLU,EViTS5_GLU,EViTS5_GLU] " - "decoder.width_list=[128,256,512,512,1024,1024] decoder.depth_list=[3,3,3,3,3,3] " - "decoder.upsample_block_type=InterpolateConv " - "decoder.norm=rms2d decoder.act=silu" - ) + cfg = { + "latent_channels": 32, + "encoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViTS5_GLU", "EViTS5_GLU", "EViTS5_GLU"], + "encoder_width_list": [128, 256, 512, 512, 1024, 1024], + "encoder_depth_list": [2, 2, 2, 3, 3, 3], + "downsample_block_type": "Conv", + "decoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViTS5_GLU", "EViTS5_GLU", "EViTS5_GLU"], + "decoder_width_list": [128, 256, 512, 512, 1024, 1024], + "decoder_depth_list": [3, 3, 3, 3, 3, 3], + "upsample_block_type": "InterpolateConv", + "scaling_factor": 0.41407, + } else: raise NotImplementedError - cfg = OmegaConf.from_dotlist(cfg_str.split(" ")) - cfg: DCAEConfig = OmegaConf.to_object(OmegaConf.merge(OmegaConf.structured(DCAEConfig), cfg)) - cfg.pretrained_path = pretrained_path return cfg -def dc_ae_f64c128(name: str, pretrained_path: Optional[str] = None) -> DCAEConfig: +def dc_ae_f64c128(name: str,) -> dict: if name in ["dc-ae-f64c128-in-1.0", "dc-ae-f64c128-mix-1.0"]: - cfg_str = ( - "latent_channels=128 " - "encoder.block_type=[ResBlock,ResBlock,ResBlock,EViT_GLU,EViT_GLU,EViT_GLU,EViT_GLU] " - "encoder.width_list=[128,256,512,512,1024,1024,2048] encoder.depth_list=[0,4,8,2,2,2,2] " - "decoder.block_type=[ResBlock,ResBlock,ResBlock,EViT_GLU,EViT_GLU,EViT_GLU,EViT_GLU] " - "decoder.width_list=[128,256,512,512,1024,1024,2048] decoder.depth_list=[0,5,10,2,2,2,2] " - "decoder.norm=[bn2d,bn2d,bn2d,rms2d,rms2d,rms2d,rms2d] decoder.act=[relu,relu,relu,silu,silu,silu,silu]" - ) + cfg = { + "latent_channels": 128, + "encoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViT_GLU", "EViT_GLU", "EViT_GLU", "EViT_GLU"], + "encoder_width_list": [128, 256, 512, 512, 1024, 1024, 2048], + "encoder_depth_list": [0, 4, 8, 2, 2, 2, 2], + "decoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViT_GLU", "EViT_GLU", "EViT_GLU", "EViT_GLU"], + "decoder_width_list": [128, 256, 512, 512, 1024, 1024, 2048], + "decoder_depth_list": [0, 5, 10, 2, 2, 2, 2], + "decoder_norm": ["bn2d", "bn2d", "bn2d", "rms2d", "rms2d", "rms2d", "rms2d"], + "decoder_act": ["relu", "relu", "relu", "silu", "silu", "silu", "silu"], + } else: raise NotImplementedError - cfg = OmegaConf.from_dotlist(cfg_str.split(" ")) - cfg: DCAEConfig = OmegaConf.to_object(OmegaConf.merge(OmegaConf.structured(DCAEConfig), cfg)) - cfg.pretrained_path = pretrained_path return cfg -def dc_ae_f128c512(name: str, pretrained_path: Optional[str] = None) -> DCAEConfig: +def dc_ae_f128c512(name: str,) -> dict: if name in ["dc-ae-f128c512-in-1.0", "dc-ae-f128c512-mix-1.0"]: - cfg_str = ( - "latent_channels=512 " - "encoder.block_type=[ResBlock,ResBlock,ResBlock,EViT_GLU,EViT_GLU,EViT_GLU,EViT_GLU,EViT_GLU] " - "encoder.width_list=[128,256,512,512,1024,1024,2048,2048] encoder.depth_list=[0,4,8,2,2,2,2,2] " - "decoder.block_type=[ResBlock,ResBlock,ResBlock,EViT_GLU,EViT_GLU,EViT_GLU,EViT_GLU,EViT_GLU] " - "decoder.width_list=[128,256,512,512,1024,1024,2048,2048] decoder.depth_list=[0,5,10,2,2,2,2,2] " - "decoder.norm=[bn2d,bn2d,bn2d,rms2d,rms2d,rms2d,rms2d,rms2d] decoder.act=[relu,relu,relu,silu,silu,silu,silu,silu]" - ) + cfg = { + "latent_channels": 512, + "encoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViT_GLU", "EViT_GLU", "EViT_GLU", "EViT_GLU", "EViT_GLU"], + "encoder_width_list": [128, 256, 512, 512, 1024, 1024, 2048, 2048], + "encoder_depth_list": [0, 4, 8, 2, 2, 2, 2, 2], + "decoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViT_GLU", "EViT_GLU", "EViT_GLU", "EViT_GLU", "EViT_GLU"], + "decoder_width_list": [128, 256, 512, 512, 1024, 1024, 2048, 2048], + "decoder_depth_list": [0, 5, 10, 2, 2, 2, 2, 2], + "decoder_norm": ["bn2d", "bn2d", "bn2d", "rms2d", "rms2d", "rms2d", "rms2d", "rms2d"], + "decoder_act": ["relu", "relu", "relu", "silu", "silu", "silu", "silu", "silu"], + } else: raise NotImplementedError - cfg = OmegaConf.from_dotlist(cfg_str.split(" ")) - cfg: DCAEConfig = OmegaConf.to_object(OmegaConf.merge(OmegaConf.structured(DCAEConfig), cfg)) - cfg.pretrained_path = pretrained_path return cfg -REGISTERED_DCAE_MODEL: dict[str, tuple[Callable, Optional[str]]] = { - "dc-ae-f32c32-in-1.0": (dc_ae_f32c32, None), - "dc-ae-f64c128-in-1.0": (dc_ae_f64c128, None), - "dc-ae-f128c512-in-1.0": (dc_ae_f128c512, None), +REGISTERED_DCAE_MODEL: dict[str, Callable] = { + "dc-ae-f32c32-in-1.0": dc_ae_f32c32, + "dc-ae-f64c128-in-1.0": dc_ae_f64c128, + "dc-ae-f128c512-in-1.0": dc_ae_f128c512, ################################################################################################# - "dc-ae-f32c32-mix-1.0": (dc_ae_f32c32, None), - "dc-ae-f64c128-mix-1.0": (dc_ae_f64c128, None), - "dc-ae-f128c512-mix-1.0": (dc_ae_f128c512, None), + "dc-ae-f32c32-mix-1.0": dc_ae_f32c32, + "dc-ae-f64c128-mix-1.0": dc_ae_f64c128, + "dc-ae-f128c512-mix-1.0": dc_ae_f128c512, ################################################################################################# - "dc-ae-f32c32-sana-1.0": (dc_ae_f32c32, None), + "dc-ae-f32c32-sana-1.0": dc_ae_f32c32, } -def create_dc_ae_model_cfg(name: str, pretrained_path: Optional[str] = None) -> DCAEConfig: +def create_dc_ae_model_cfg(name: str) -> dict: assert name in REGISTERED_DCAE_MODEL, f"{name} is not supported" - dc_ae_cls, default_pt_path = REGISTERED_DCAE_MODEL[name] - pretrained_path = default_pt_path if pretrained_path is None else pretrained_path - model_cfg = dc_ae_cls(name, pretrained_path) + dc_ae_cls = REGISTERED_DCAE_MODEL[name] + model_cfg = dc_ae_cls(name) return model_cfg -class DCAE_HF(DCAE, PyTorchModelHubMixin): +class DCAE_HF(PyTorchModelHubMixin, DCAE): def __init__(self, model_name: str): cfg = create_dc_ae_model_cfg(model_name) - DCAE.__init__(self, cfg) - - -def main(): - dc_ae_f32c32_sana = DCAE_HF.from_pretrained("mit-han-lab/dc-ae-f32c32-sana-1.0") - - from PIL import Image - import torch - import torchvision.transforms as transforms - from torchvision.utils import save_image - - device = torch.device("cuda") - dc_ae_f32c32_sana = dc_ae_f32c32_sana.to(device).eval() - - transform = transforms.Compose([ - transforms.ToTensor(), - transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), - ]) - image = Image.open("/home/junyuc/workspace/code/efficientvit/assets/fig/girl.png") - x = transform(image)[None].to(device) - latent = dc_ae_f32c32_sana.encode(x) - print(latent.shape) - - # decode - y = dc_ae_f32c32_sana.decode(latent) - save_image(y * 0.5 + 0.5, "demo_dc_ae.png") - -if __name__ == "__main__": - main() - -""" -python -m src.diffusers.models.autoencoders.dc_ae -""" \ No newline at end of file + DCAE.__init__(self, **cfg) From da7caa5850f1ae2b9620675ea4c7afad7ec9ed81 Mon Sep 17 00:00:00 2001 From: Junyu Chen Date: Thu, 24 Oct 2024 21:07:22 -0700 Subject: [PATCH 006/141] replace custom activation with diffuers activation --- src/diffusers/models/autoencoders/dc_ae.py | 38 ++- .../models/autoencoders/dc_ae_blocks/act.py | 27 -- .../models/autoencoders/dc_ae_blocks/ops.py | 258 +----------------- 3 files changed, 40 insertions(+), 283 deletions(-) delete mode 100644 src/diffusers/models/autoencoders/dc_ae_blocks/act.py diff --git a/src/diffusers/models/autoencoders/dc_ae.py b/src/diffusers/models/autoencoders/dc_ae.py index 6390afbf8078..436f779724d6 100644 --- a/src/diffusers/models/autoencoders/dc_ae.py +++ b/src/diffusers/models/autoencoders/dc_ae.py @@ -23,7 +23,7 @@ from ...loaders.single_file_model import FromOriginalModelMixin from ..modeling_utils import ModelMixin -from .dc_ae_blocks.act import build_act +from ..activations import get_activation from .dc_ae_blocks.norm import build_norm from .dc_ae_blocks.ops import ( ChannelDuplicatingPixelUnshuffleUpSampleLayer, @@ -164,7 +164,7 @@ def build_encoder_project_out_block( block = OpSequential( [ build_norm(norm), - build_act(act), + get_activation(act) if act is not None else None, ConvLayer( in_channels=in_channels, out_channels=out_channels, @@ -215,7 +215,7 @@ def build_decoder_project_out_block( ): layers: list[nn.Module] = [ build_norm(norm, in_channels), - build_act(act), + get_activation(act) if act is not None else None, ] if factor == 1: layers.append( @@ -542,3 +542,35 @@ class DCAE_HF(PyTorchModelHubMixin, DCAE): def __init__(self, model_name: str): cfg = create_dc_ae_model_cfg(model_name) DCAE.__init__(self, **cfg) + + +def main(): + from PIL import Image + import torch + import torchvision.transforms as transforms + from torchvision.utils import save_image + import ipdb + + torch.set_grad_enabled(False) + device = torch.device("cuda") + + transform = transforms.Compose([ + transforms.ToTensor(), + transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), + ]) + image = Image.open("/home/junyuc/workspace/code/efficientvit/assets/fig/girl.png") + x = transform(image)[None].to(device) + for model_name in REGISTERED_DCAE_MODEL: + dc_ae = DCAE_HF.from_pretrained(f"mit-han-lab/{model_name}") + dc_ae = dc_ae.to(device).eval() + latent = dc_ae.encode(x) + print(latent.shape) + y = dc_ae.decode(latent) + save_image(y * 0.5 + 0.5, f"demo_{model_name}.png") + +if __name__ == "__main__": + main() + +""" +python -m src.diffusers.models.autoencoders.dc_ae +""" \ No newline at end of file diff --git a/src/diffusers/models/autoencoders/dc_ae_blocks/act.py b/src/diffusers/models/autoencoders/dc_ae_blocks/act.py deleted file mode 100644 index c5fadd90deef..000000000000 --- a/src/diffusers/models/autoencoders/dc_ae_blocks/act.py +++ /dev/null @@ -1,27 +0,0 @@ -from functools import partial -from typing import Optional - -import torch.nn as nn - -from .utils.network import build_kwargs_from_config - -__all__ = ["build_act"] - - -# register activation function here -REGISTERED_ACT_DICT: dict[str, type] = { - "relu": nn.ReLU, - "relu6": nn.ReLU6, - "hswish": nn.Hardswish, - "silu": nn.SiLU, - "gelu": partial(nn.GELU, approximate="tanh"), -} - - -def build_act(name: str, **kwargs) -> Optional[nn.Module]: - if name in REGISTERED_ACT_DICT: - act_cls = REGISTERED_ACT_DICT[name] - args = build_kwargs_from_config(kwargs, act_cls) - return act_cls(**args) - else: - return None diff --git a/src/diffusers/models/autoencoders/dc_ae_blocks/ops.py b/src/diffusers/models/autoencoders/dc_ae_blocks/ops.py index e239f7314182..c65bfeab7c2d 100644 --- a/src/diffusers/models/autoencoders/dc_ae_blocks/ops.py +++ b/src/diffusers/models/autoencoders/dc_ae_blocks/ops.py @@ -4,28 +4,22 @@ import torch.nn as nn import torch.nn.functional as F -from .act import build_act +from ...activations import get_activation from .norm import build_norm from .utils.network import get_same_padding, resize from .utils.list import list_sum, val2list, val2tuple __all__ = [ "ConvLayer", - "UpSampleLayer", "ConvPixelUnshuffleDownSampleLayer", "PixelUnshuffleChannelAveragingDownSampleLayer", "ConvPixelShuffleUpSampleLayer", "ChannelDuplicatingPixelUnshuffleUpSampleLayer", - "LinearLayer", "IdentityLayer", - "DSConv", - "MBConv", - "FusedMBConv", "ResBlock", "LiteMLA", "EfficientViTBlock", "ResidualBlock", - "DAGBlock", "OpSequential", ] @@ -66,7 +60,7 @@ def __init__( bias=use_bias, ) self.norm = build_norm(norm, num_features=out_channels) - self.act = build_act(act_func) + self.act = get_activation(act_func) if act_func is not None else None def forward(self, x: torch.Tensor) -> torch.Tensor: if self.dropout is not None: @@ -79,29 +73,6 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: return x -class UpSampleLayer(nn.Module): - def __init__( - self, - mode="bicubic", - size: Optional[int | tuple[int, int] | list[int]] = None, - factor=2, - align_corners=False, - ): - super(UpSampleLayer, self).__init__() - self.mode = mode - self.size = val2list(size, 2) if size is not None else None - self.factor = None if self.size is not None else factor - self.align_corners = align_corners - - @torch.autocast(device_type="cuda", enabled=False) - def forward(self, x: torch.Tensor) -> torch.Tensor: - if (self.size is not None and tuple(x.shape[-2:]) == self.size) or self.factor == 1: - return x - if x.dtype in [torch.float16, torch.bfloat16]: - x = x.float() - return resize(x, self.size, self.factor, self.mode, self.align_corners) - - class ConvPixelUnshuffleDownSampleLayer(nn.Module): def __init__( self, @@ -224,193 +195,11 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: return x -class LinearLayer(nn.Module): - def __init__( - self, - in_features: int, - out_features: int, - use_bias=True, - dropout=0, - norm=None, - act_func=None, - ): - super(LinearLayer, self).__init__() - - self.dropout = nn.Dropout(dropout, inplace=False) if dropout > 0 else None - self.linear = nn.Linear(in_features, out_features, use_bias) - self.norm = build_norm(norm, num_features=out_features) - self.act = build_act(act_func) - - def _try_squeeze(self, x: torch.Tensor) -> torch.Tensor: - if x.dim() > 2: - x = torch.flatten(x, start_dim=1) - return x - - def forward(self, x: torch.Tensor) -> torch.Tensor: - x = self._try_squeeze(x) - if self.dropout: - x = self.dropout(x) - x = self.linear(x) - if self.norm: - x = self.norm(x) - if self.act: - x = self.act(x) - return x - - class IdentityLayer(nn.Module): def forward(self, x: torch.Tensor) -> torch.Tensor: return x -################################################################################# -# Basic Blocks # -################################################################################# - - -class DSConv(nn.Module): - def __init__( - self, - in_channels: int, - out_channels: int, - kernel_size=3, - stride=1, - use_bias=False, - norm=("bn2d", "bn2d"), - act_func=("relu6", None), - ): - super(DSConv, self).__init__() - - use_bias = val2tuple(use_bias, 2) - norm = val2tuple(norm, 2) - act_func = val2tuple(act_func, 2) - - self.depth_conv = ConvLayer( - in_channels, - in_channels, - kernel_size, - stride, - groups=in_channels, - norm=norm[0], - act_func=act_func[0], - use_bias=use_bias[0], - ) - self.point_conv = ConvLayer( - in_channels, - out_channels, - 1, - norm=norm[1], - act_func=act_func[1], - use_bias=use_bias[1], - ) - - def forward(self, x: torch.Tensor) -> torch.Tensor: - x = self.depth_conv(x) - x = self.point_conv(x) - return x - - -class MBConv(nn.Module): - def __init__( - self, - in_channels: int, - out_channels: int, - kernel_size=3, - stride=1, - mid_channels=None, - expand_ratio=6, - use_bias=False, - norm=("bn2d", "bn2d", "bn2d"), - act_func=("relu6", "relu6", None), - ): - super(MBConv, self).__init__() - - use_bias = val2tuple(use_bias, 3) - norm = val2tuple(norm, 3) - act_func = val2tuple(act_func, 3) - mid_channels = round(in_channels * expand_ratio) if mid_channels is None else mid_channels - - self.inverted_conv = ConvLayer( - in_channels, - mid_channels, - 1, - stride=1, - norm=norm[0], - act_func=act_func[0], - use_bias=use_bias[0], - ) - self.depth_conv = ConvLayer( - mid_channels, - mid_channels, - kernel_size, - stride=stride, - groups=mid_channels, - norm=norm[1], - act_func=act_func[1], - use_bias=use_bias[1], - ) - self.point_conv = ConvLayer( - mid_channels, - out_channels, - 1, - norm=norm[2], - act_func=act_func[2], - use_bias=use_bias[2], - ) - - def forward(self, x: torch.Tensor) -> torch.Tensor: - x = self.inverted_conv(x) - x = self.depth_conv(x) - x = self.point_conv(x) - return x - - -class FusedMBConv(nn.Module): - def __init__( - self, - in_channels: int, - out_channels: int, - kernel_size=3, - stride=1, - mid_channels=None, - expand_ratio=6, - groups=1, - use_bias=False, - norm=("bn2d", "bn2d"), - act_func=("relu6", None), - ): - super().__init__() - use_bias = val2tuple(use_bias, 2) - norm = val2tuple(norm, 2) - act_func = val2tuple(act_func, 2) - - mid_channels = round(in_channels * expand_ratio) if mid_channels is None else mid_channels - - self.spatial_conv = ConvLayer( - in_channels, - mid_channels, - kernel_size, - stride, - groups=groups, - use_bias=use_bias[0], - norm=norm[0], - act_func=act_func[0], - ) - self.point_conv = ConvLayer( - mid_channels, - out_channels, - 1, - use_bias=use_bias[1], - norm=norm[1], - act_func=act_func[1], - ) - - def forward(self, x: torch.Tensor) -> torch.Tensor: - x = self.spatial_conv(x) - x = self.point_conv(x) - return x - - class GLUMBConv(nn.Module): def __init__( self, @@ -431,7 +220,7 @@ def __init__( mid_channels = round(in_channels * expand_ratio) if mid_channels is None else mid_channels - self.glu_act = build_act(act_func[1], inplace=False) + self.glu_act = get_activation(act_func[1]) self.inverted_conv = ConvLayer( in_channels, mid_channels * 2, @@ -568,7 +357,7 @@ def __init__( for scale in scales ] ) - self.kernel_func = build_act(kernel_func, inplace=False) + self.kernel_func = get_activation(kernel_func) self.proj = ConvLayer( total_dim * (1 + len(scales)), @@ -748,7 +537,7 @@ def __init__( self.pre_norm = pre_norm self.main = main self.shortcut = shortcut - self.post_act = build_act(post_act) + self.post_act = get_activation(post_act) if post_act is not None else None def forward_main(self, x: torch.Tensor) -> torch.Tensor: if self.pre_norm is None: @@ -768,43 +557,6 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: return res -class DAGBlock(nn.Module): - def __init__( - self, - inputs: dict[str, nn.Module], - merge: str, - post_input: Optional[nn.Module], - middle: nn.Module, - outputs: dict[str, nn.Module], - ): - super(DAGBlock, self).__init__() - - self.input_keys = list(inputs.keys()) - self.input_ops = nn.ModuleList(list(inputs.values())) - self.merge = merge - self.post_input = post_input - - self.middle = middle - - self.output_keys = list(outputs.keys()) - self.output_ops = nn.ModuleList(list(outputs.values())) - - def forward(self, feature_dict: dict[str, torch.Tensor]) -> dict[str, torch.Tensor]: - feat = [op(feature_dict[key]) for key, op in zip(self.input_keys, self.input_ops)] - if self.merge == "add": - feat = list_sum(feat) - elif self.merge == "cat": - feat = torch.concat(feat, dim=1) - else: - raise NotImplementedError - if self.post_input is not None: - feat = self.post_input(feat) - feat = self.middle(feat) - for key, op in zip(self.output_keys, self.output_ops): - feature_dict[key] = op(feat) - return feature_dict - - class OpSequential(nn.Module): def __init__(self, op_list: list[Optional[nn.Module]]): super(OpSequential, self).__init__() From fb6d92a4b97468c52e988bb1e1ac4f4cb46ebfa1 Mon Sep 17 00:00:00 2001 From: Junyu Chen Date: Thu, 24 Oct 2024 21:08:50 -0700 Subject: [PATCH 007/141] remove dc_ae attention in attention_processor.py --- src/diffusers/models/attention_processor.py | 69 --------------------- 1 file changed, 69 deletions(-) diff --git a/src/diffusers/models/attention_processor.py b/src/diffusers/models/attention_processor.py index afe6ba6a3658..e735c4ee7d17 100644 --- a/src/diffusers/models/attention_processor.py +++ b/src/diffusers/models/attention_processor.py @@ -4283,75 +4283,6 @@ def __init__(self): super().__init__() -class DCAEAttnProcessor: - r""" - This class is modified from https://github.com/mit-han-lab/efficientvit - Processor for EfficientViT in DC-AE. - """ - - def __call__( - self, - attn: Attention, - hidden_states: torch.Tensor, - encoder_hidden_states: Optional[torch.Tensor] = None, - attention_mask: Optional[torch.Tensor] = None, - temb: Optional[torch.Tensor] = None, - *args, - **kwargs, - ) -> torch.Tensor: - residual = hidden_states - - if attn.spatial_norm is not None: - hidden_states = attn.spatial_norm(hidden_states, temb) - - input_ndim = hidden_states.ndim - - if input_ndim == 4: - batch_size, channel, height, width = hidden_states.shape - hidden_states = hidden_states.view(batch_size, channel, height * width).transpose(1, 2) - - batch_size, sequence_length, _ = ( - hidden_states.shape if encoder_hidden_states is None else encoder_hidden_states.shape - ) - attention_mask = attn.prepare_attention_mask(attention_mask, sequence_length, batch_size) - - if attn.group_norm is not None: - hidden_states = attn.group_norm(hidden_states.transpose(1, 2)).transpose(1, 2) - - query = attn.to_q(hidden_states) - - if encoder_hidden_states is None: - encoder_hidden_states = hidden_states - elif attn.norm_cross: - encoder_hidden_states = attn.norm_encoder_hidden_states(encoder_hidden_states) - - key = attn.to_k(encoder_hidden_states) - value = attn.to_v(encoder_hidden_states) - - query = attn.head_to_batch_dim(query) - key = attn.head_to_batch_dim(key) - value = attn.head_to_batch_dim(value) - - attention_probs = attn.get_attention_scores(query, key, attention_mask) - hidden_states = torch.bmm(attention_probs, value) - hidden_states = attn.batch_to_head_dim(hidden_states) - - # linear proj - hidden_states = attn.to_out[0](hidden_states) - # dropout - hidden_states = attn.to_out[1](hidden_states) - - if input_ndim == 4: - hidden_states = hidden_states.transpose(-1, -2).reshape(batch_size, channel, height, width) - - if attn.residual_connection: - hidden_states = hidden_states + residual - - hidden_states = hidden_states / attn.rescale_output_factor - - return hidden_states - - ADDED_KV_ATTENTION_PROCESSORS = ( AttnAddedKVProcessor, SlicedAttnAddedKVProcessor, From 5e63a1ae6cdd20f3c80021eb880172688bdf485c Mon Sep 17 00:00:00 2001 From: Junyu Chen Date: Thu, 24 Oct 2024 21:13:05 -0700 Subject: [PATCH 008/141] iinherit from ModelMixin --- src/diffusers/models/autoencoders/dc_ae.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/diffusers/models/autoencoders/dc_ae.py b/src/diffusers/models/autoencoders/dc_ae.py index 436f779724d6..e83ebd83ede0 100644 --- a/src/diffusers/models/autoencoders/dc_ae.py +++ b/src/diffusers/models/autoencoders/dc_ae.py @@ -392,7 +392,7 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: return x -class DCAE(nn.Module): +class DCAE(ModelMixin): def __init__( self, in_channels: int = 3, From 72cce2b468930c657dfe08ca9b3d448df5f56379 Mon Sep 17 00:00:00 2001 From: Junyu Chen Date: Thu, 24 Oct 2024 21:33:09 -0700 Subject: [PATCH 009/141] inherit from ConfigMixin --- src/diffusers/models/autoencoders/dc_ae.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/diffusers/models/autoencoders/dc_ae.py b/src/diffusers/models/autoencoders/dc_ae.py index e83ebd83ede0..17b8fd8343c3 100644 --- a/src/diffusers/models/autoencoders/dc_ae.py +++ b/src/diffusers/models/autoencoders/dc_ae.py @@ -392,7 +392,8 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: return x -class DCAE(ModelMixin): +class DCAE(ModelMixin, ConfigMixin): + @register_to_config def __init__( self, in_channels: int = 3, From 8f9b4e43bc2c395c3809ab439d1da0decb0b60ba Mon Sep 17 00:00:00 2001 From: Junyu Chen Date: Thu, 31 Oct 2024 00:17:58 -0700 Subject: [PATCH 010/141] dc-ae reduce to one file --- src/diffusers/models/autoencoders/dc_ae.py | 579 +++++++++++++++++- .../models/autoencoders/dc_ae_blocks/norm.py | 54 -- .../models/autoencoders/dc_ae_blocks/ops.py | 572 ----------------- .../autoencoders/dc_ae_blocks/utils/list.py | 51 -- .../dc_ae_blocks/utils/network.py | 95 --- src/diffusers/models/normalization.py | 8 + 6 files changed, 572 insertions(+), 787 deletions(-) delete mode 100644 src/diffusers/models/autoencoders/dc_ae_blocks/norm.py delete mode 100644 src/diffusers/models/autoencoders/dc_ae_blocks/ops.py delete mode 100644 src/diffusers/models/autoencoders/dc_ae_blocks/utils/list.py delete mode 100644 src/diffusers/models/autoencoders/dc_ae_blocks/utils/network.py diff --git a/src/diffusers/models/autoencoders/dc_ae.py b/src/diffusers/models/autoencoders/dc_ae.py index 17b8fd8343c3..3e8927ac1638 100644 --- a/src/diffusers/models/autoencoders/dc_ae.py +++ b/src/diffusers/models/autoencoders/dc_ae.py @@ -17,31 +17,580 @@ import torch import torch.nn as nn +import torch.nn.functional as F +from torch.nn import BatchNorm2d from huggingface_hub import PyTorchModelHubMixin from ...configuration_utils import ConfigMixin, register_to_config -from ...loaders.single_file_model import FromOriginalModelMixin from ..modeling_utils import ModelMixin from ..activations import get_activation -from .dc_ae_blocks.norm import build_norm -from .dc_ae_blocks.ops import ( - ChannelDuplicatingPixelUnshuffleUpSampleLayer, - ConvLayer, - ConvPixelShuffleUpSampleLayer, - ConvPixelUnshuffleDownSampleLayer, - EfficientViTBlock, - IdentityLayer, - InterpolateConvUpSampleLayer, - OpSequential, - PixelUnshuffleChannelAveragingDownSampleLayer, - ResBlock, - ResidualBlock, -) +from ..normalization import RMSNorm2d + __all__ = ["DCAE", "dc_ae_f32c32", "dc_ae_f64c128", "dc_ae_f128c512"] +def val2tuple(x: list | tuple | Any, min_len: int = 1) -> tuple: + x = list(x) if isinstance(x, (list, tuple)) else [x] + # repeat elements if necessary + if len(x) > 0: + x.extend([x[-1] for _ in range(min_len - len(x))]) + return tuple(x) + + +def get_same_padding(kernel_size: int | tuple[int, ...]) -> int | tuple[int, ...]: + if isinstance(kernel_size, tuple): + return tuple([get_same_padding(ks) for ks in kernel_size]) + else: + assert kernel_size % 2 > 0, "kernel size should be odd number" + return kernel_size // 2 + + +def build_norm(name: Optional[str]="bn2d", num_features: Optional[int]=None) -> Optional[nn.Module]: + if name is None: + norm = None + elif name == "rms2d": + norm = RMSNorm2d(normalized_shape=num_features) + elif name == "bn2d": + norm = BatchNorm2d(num_features=num_features) + else: + raise ValueError(f"norm {name} is not supported") + return norm + + +class ConvLayer(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + kernel_size=3, + stride=1, + dilation=1, + groups=1, + use_bias=False, + dropout=0, + norm="bn2d", + act_func="relu", + ): + super(ConvLayer, self).__init__() + + padding = get_same_padding(kernel_size) + padding *= dilation + + self.dropout = nn.Dropout2d(dropout, inplace=False) if dropout > 0 else None + self.conv = nn.Conv2d( + in_channels, + out_channels, + kernel_size=(kernel_size, kernel_size), + stride=(stride, stride), + padding=padding, + dilation=(dilation, dilation), + groups=groups, + bias=use_bias, + ) + self.norm = build_norm(norm, num_features=out_channels) + self.act = get_activation(act_func) if act_func is not None else None + + def forward(self, x: torch.Tensor) -> torch.Tensor: + if self.dropout is not None: + x = self.dropout(x) + x = self.conv(x) + if self.norm: + x = self.norm(x) + if self.act: + x = self.act(x) + return x + + +class ConvPixelUnshuffleDownSampleLayer(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + kernel_size: int, + factor: int, + ): + super().__init__() + self.factor = factor + out_ratio = factor**2 + assert out_channels % out_ratio == 0 + self.conv = ConvLayer( + in_channels=in_channels, + out_channels=out_channels // out_ratio, + kernel_size=kernel_size, + use_bias=True, + norm=None, + act_func=None, + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = self.conv(x) + x = F.pixel_unshuffle(x, self.factor) + return x + + +class PixelUnshuffleChannelAveragingDownSampleLayer(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + factor: int, + ): + super().__init__() + self.in_channels = in_channels + self.out_channels = out_channels + self.factor = factor + assert in_channels * factor**2 % out_channels == 0 + self.group_size = in_channels * factor**2 // out_channels + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = F.pixel_unshuffle(x, self.factor) + B, C, H, W = x.shape + x = x.view(B, self.out_channels, self.group_size, H, W) + x = x.mean(dim=2) + return x + + +class ConvPixelShuffleUpSampleLayer(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + kernel_size: int, + factor: int, + ): + super().__init__() + self.factor = factor + out_ratio = factor**2 + self.conv = ConvLayer( + in_channels=in_channels, + out_channels=out_channels * out_ratio, + kernel_size=kernel_size, + use_bias=True, + norm=None, + act_func=None, + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = self.conv(x) + x = F.pixel_shuffle(x, self.factor) + return x + + +class InterpolateConvUpSampleLayer(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + kernel_size: int, + factor: int, + mode: str = "nearest", + ) -> None: + super().__init__() + self.factor = factor + self.mode = mode + self.conv = ConvLayer( + in_channels=in_channels, + out_channels=out_channels, + kernel_size=kernel_size, + use_bias=True, + norm=None, + act_func=None, + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = torch.nn.functional.interpolate(x, scale_factor=self.factor, mode=self.mode) + x = self.conv(x) + return x + + +class ChannelDuplicatingPixelUnshuffleUpSampleLayer(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + factor: int, + ): + super().__init__() + self.in_channels = in_channels + self.out_channels = out_channels + self.factor = factor + assert out_channels * factor**2 % in_channels == 0 + self.repeats = out_channels * factor**2 // in_channels + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = x.repeat_interleave(self.repeats, dim=1) + x = F.pixel_shuffle(x, self.factor) + return x + + +class IdentityLayer(nn.Module): + def forward(self, x: torch.Tensor) -> torch.Tensor: + return x + + +class GLUMBConv(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + kernel_size=3, + stride=1, + mid_channels=None, + expand_ratio=6, + use_bias=False, + norm=(None, None, "ln2d"), + act_func=("silu", "silu", None), + ): + super().__init__() + use_bias = val2tuple(use_bias, 3) + norm = val2tuple(norm, 3) + act_func = val2tuple(act_func, 3) + + mid_channels = round(in_channels * expand_ratio) if mid_channels is None else mid_channels + + self.glu_act = get_activation(act_func[1]) + self.inverted_conv = ConvLayer( + in_channels, + mid_channels * 2, + 1, + use_bias=use_bias[0], + norm=norm[0], + act_func=act_func[0], + ) + self.depth_conv = ConvLayer( + mid_channels * 2, + mid_channels * 2, + kernel_size, + stride=stride, + groups=mid_channels * 2, + use_bias=use_bias[1], + norm=norm[1], + act_func=None, + ) + self.point_conv = ConvLayer( + mid_channels, + out_channels, + 1, + use_bias=use_bias[2], + norm=norm[2], + act_func=act_func[2], + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = self.inverted_conv(x) + x = self.depth_conv(x) + + x, gate = torch.chunk(x, 2, dim=1) + gate = self.glu_act(gate) + x = x * gate + + x = self.point_conv(x) + return x + + +class ResBlock(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + kernel_size=3, + stride=1, + mid_channels=None, + expand_ratio=1, + use_bias=False, + norm=("bn2d", "bn2d"), + act_func=("relu6", None), + ): + super().__init__() + use_bias = val2tuple(use_bias, 2) + norm = val2tuple(norm, 2) + act_func = val2tuple(act_func, 2) + + mid_channels = round(in_channels * expand_ratio) if mid_channels is None else mid_channels + + self.conv1 = ConvLayer( + in_channels, + mid_channels, + kernel_size, + stride, + use_bias=use_bias[0], + norm=norm[0], + act_func=act_func[0], + ) + self.conv2 = ConvLayer( + mid_channels, + out_channels, + kernel_size, + 1, + use_bias=use_bias[1], + norm=norm[1], + act_func=act_func[1], + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = self.conv1(x) + x = self.conv2(x) + return x + + +class LiteMLA(nn.Module): + r"""Lightweight multi-scale linear attention""" + + def __init__( + self, + in_channels: int, + out_channels: int, + heads: Optional[int] = None, + heads_ratio: float = 1.0, + dim=8, + use_bias=False, + norm=(None, "bn2d"), + act_func=(None, None), + kernel_func="relu", + scales: tuple[int, ...] = (5,), + eps=1.0e-15, + ): + super(LiteMLA, self).__init__() + self.eps = eps + heads = int(in_channels // dim * heads_ratio) if heads is None else heads + + total_dim = heads * dim + + use_bias = val2tuple(use_bias, 2) + norm = val2tuple(norm, 2) + act_func = val2tuple(act_func, 2) + + self.dim = dim + self.qkv = ConvLayer( + in_channels, + 3 * total_dim, + 1, + use_bias=use_bias[0], + norm=norm[0], + act_func=act_func[0], + ) + self.aggreg = nn.ModuleList( + [ + nn.Sequential( + nn.Conv2d( + 3 * total_dim, + 3 * total_dim, + scale, + padding=get_same_padding(scale), + groups=3 * total_dim, + bias=use_bias[0], + ), + nn.Conv2d(3 * total_dim, 3 * total_dim, 1, groups=3 * heads, bias=use_bias[0]), + ) + for scale in scales + ] + ) + self.kernel_func = get_activation(kernel_func) + + self.proj = ConvLayer( + total_dim * (1 + len(scales)), + out_channels, + 1, + use_bias=use_bias[1], + norm=norm[1], + act_func=act_func[1], + ) + + @torch.autocast(device_type="cuda", enabled=False) + def relu_linear_att(self, qkv: torch.Tensor) -> torch.Tensor: + B, _, H, W = list(qkv.size()) + + if qkv.dtype == torch.float16: + qkv = qkv.float() + + qkv = torch.reshape( + qkv, + ( + B, + -1, + 3 * self.dim, + H * W, + ), + ) + q, k, v = ( + qkv[:, :, 0 : self.dim], + qkv[:, :, self.dim : 2 * self.dim], + qkv[:, :, 2 * self.dim :], + ) + + # lightweight linear attention + q = self.kernel_func(q) + k = self.kernel_func(k) + + # linear matmul + trans_k = k.transpose(-1, -2) + + v = F.pad(v, (0, 0, 0, 1), mode="constant", value=1) + vk = torch.matmul(v, trans_k) + out = torch.matmul(vk, q) + if out.dtype == torch.bfloat16: + out = out.float() + out = out[:, :, :-1] / (out[:, :, -1:] + self.eps) + + out = torch.reshape(out, (B, -1, H, W)) + return out + + @torch.autocast(device_type="cuda", enabled=False) + def relu_quadratic_att(self, qkv: torch.Tensor) -> torch.Tensor: + B, _, H, W = list(qkv.size()) + + qkv = torch.reshape( + qkv, + ( + B, + -1, + 3 * self.dim, + H * W, + ), + ) + q, k, v = ( + qkv[:, :, 0 : self.dim], + qkv[:, :, self.dim : 2 * self.dim], + qkv[:, :, 2 * self.dim :], + ) + + q = self.kernel_func(q) + k = self.kernel_func(k) + + att_map = torch.matmul(k.transpose(-1, -2), q) # b h n n + original_dtype = att_map.dtype + if original_dtype in [torch.float16, torch.bfloat16]: + att_map = att_map.float() + att_map = att_map / (torch.sum(att_map, dim=2, keepdim=True) + self.eps) # b h n n + att_map = att_map.to(original_dtype) + out = torch.matmul(v, att_map) # b h d n + + out = torch.reshape(out, (B, -1, H, W)) + return out + + def forward(self, x: torch.Tensor) -> torch.Tensor: + # generate multi-scale q, k, v + qkv = self.qkv(x) + multi_scale_qkv = [qkv] + for op in self.aggreg: + multi_scale_qkv.append(op(qkv)) + qkv = torch.cat(multi_scale_qkv, dim=1) + + H, W = list(qkv.size())[-2:] + if H * W > self.dim: + out = self.relu_linear_att(qkv).to(qkv.dtype) + else: + out = self.relu_quadratic_att(qkv) + out = self.proj(out) + + return out + + +class EfficientViTBlock(nn.Module): + def __init__( + self, + in_channels: int, + heads_ratio: float = 1.0, + dim=32, + expand_ratio: float = 4, + scales: tuple[int, ...] = (5,), + norm: str = "bn2d", + act_func: str = "hswish", + context_module: str = "LiteMLA", + local_module: str = "MBConv", + ): + super(EfficientViTBlock, self).__init__() + if context_module == "LiteMLA": + self.context_module = ResidualBlock( + LiteMLA( + in_channels=in_channels, + out_channels=in_channels, + heads_ratio=heads_ratio, + dim=dim, + norm=(None, norm), + scales=scales, + ), + IdentityLayer(), + ) + else: + raise ValueError(f"context_module {context_module} is not supported") + if local_module == "GLUMBConv": + self.local_module = ResidualBlock( + GLUMBConv( + in_channels=in_channels, + out_channels=in_channels, + expand_ratio=expand_ratio, + use_bias=(True, True, False), + norm=(None, None, norm), + act_func=(act_func, act_func, None), + ), + IdentityLayer(), + ) + else: + raise NotImplementedError(f"local_module {local_module} is not supported") + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = self.context_module(x) + x = self.local_module(x) + return x + + +################################################################################# +# Functional Blocks # +################################################################################# + + +class ResidualBlock(nn.Module): + def __init__( + self, + main: Optional[nn.Module], + shortcut: Optional[nn.Module], + post_act=None, + pre_norm: Optional[nn.Module] = None, + ): + super(ResidualBlock, self).__init__() + + self.pre_norm = pre_norm + self.main = main + self.shortcut = shortcut + self.post_act = get_activation(post_act) if post_act is not None else None + + def forward_main(self, x: torch.Tensor) -> torch.Tensor: + if self.pre_norm is None: + return self.main(x) + else: + return self.main(self.pre_norm(x)) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + if self.main is None: + res = x + elif self.shortcut is None: + res = self.forward_main(x) + else: + res = self.forward_main(x) + self.shortcut(x) + if self.post_act: + res = self.post_act(res) + return res + + +class OpSequential(nn.Module): + def __init__(self, op_list: list[Optional[nn.Module]]): + super(OpSequential, self).__init__() + valid_op_list = [] + for op in op_list: + if op is not None: + valid_op_list.append(op) + self.op_list = nn.ModuleList(valid_op_list) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + for op in self.op_list: + x = op(x) + return x + + + def build_block( block_type: str, in_channels: int, out_channels: int, norm: Optional[str], act: Optional[str] ) -> nn.Module: diff --git a/src/diffusers/models/autoencoders/dc_ae_blocks/norm.py b/src/diffusers/models/autoencoders/dc_ae_blocks/norm.py deleted file mode 100644 index cd3dc85a227a..000000000000 --- a/src/diffusers/models/autoencoders/dc_ae_blocks/norm.py +++ /dev/null @@ -1,54 +0,0 @@ -from typing import Optional - -import torch -import torch.nn as nn -from torch.nn.modules.batchnorm import _BatchNorm - -from .utils.network import build_kwargs_from_config - -__all__ = ["LayerNorm2d", "RMSNorm2d", "build_norm", "set_norm_eps"] - - -class LayerNorm2d(nn.LayerNorm): - def forward(self, x: torch.Tensor) -> torch.Tensor: - out = x - torch.mean(x, dim=1, keepdim=True) - out = out / torch.sqrt(torch.square(out).mean(dim=1, keepdim=True) + self.eps) - if self.elementwise_affine: - out = out * self.weight.view(1, -1, 1, 1) + self.bias.view(1, -1, 1, 1) - return out - - -class RMSNorm2d(nn.LayerNorm): - def forward(self, x: torch.Tensor) -> torch.Tensor: - x = x / torch.sqrt(torch.square(x).mean(dim=1, keepdim=True) + self.eps) - if self.elementwise_affine: - x = x * self.weight.view(1, -1, 1, 1) + self.bias.view(1, -1, 1, 1) - return x - -# register normalization function here -REGISTERED_NORM_DICT: dict[str, type] = { - "bn2d": nn.BatchNorm2d, - "ln": nn.LayerNorm, - "ln2d": LayerNorm2d, - "rms2d": RMSNorm2d, -} - - -def build_norm(name="bn2d", num_features=None, **kwargs) -> Optional[nn.Module]: - if name in ["ln", "ln2d", "rms2d"]: - kwargs["normalized_shape"] = num_features - else: - kwargs["num_features"] = num_features - if name in REGISTERED_NORM_DICT: - norm_cls = REGISTERED_NORM_DICT[name] - args = build_kwargs_from_config(kwargs, norm_cls) - return norm_cls(**args) - else: - return None - - -def set_norm_eps(model: nn.Module, eps: Optional[float] = None) -> None: - for m in model.modules(): - if isinstance(m, (nn.GroupNorm, nn.LayerNorm, _BatchNorm)): - if eps is not None: - m.eps = eps diff --git a/src/diffusers/models/autoencoders/dc_ae_blocks/ops.py b/src/diffusers/models/autoencoders/dc_ae_blocks/ops.py deleted file mode 100644 index c65bfeab7c2d..000000000000 --- a/src/diffusers/models/autoencoders/dc_ae_blocks/ops.py +++ /dev/null @@ -1,572 +0,0 @@ -from typing import Optional - -import torch -import torch.nn as nn -import torch.nn.functional as F - -from ...activations import get_activation -from .norm import build_norm -from .utils.network import get_same_padding, resize -from .utils.list import list_sum, val2list, val2tuple - -__all__ = [ - "ConvLayer", - "ConvPixelUnshuffleDownSampleLayer", - "PixelUnshuffleChannelAveragingDownSampleLayer", - "ConvPixelShuffleUpSampleLayer", - "ChannelDuplicatingPixelUnshuffleUpSampleLayer", - "IdentityLayer", - "ResBlock", - "LiteMLA", - "EfficientViTBlock", - "ResidualBlock", - "OpSequential", -] - - -################################################################################# -# Basic Layers # -################################################################################# - - -class ConvLayer(nn.Module): - def __init__( - self, - in_channels: int, - out_channels: int, - kernel_size=3, - stride=1, - dilation=1, - groups=1, - use_bias=False, - dropout=0, - norm="bn2d", - act_func="relu", - ): - super(ConvLayer, self).__init__() - - padding = get_same_padding(kernel_size) - padding *= dilation - - self.dropout = nn.Dropout2d(dropout, inplace=False) if dropout > 0 else None - self.conv = nn.Conv2d( - in_channels, - out_channels, - kernel_size=(kernel_size, kernel_size), - stride=(stride, stride), - padding=padding, - dilation=(dilation, dilation), - groups=groups, - bias=use_bias, - ) - self.norm = build_norm(norm, num_features=out_channels) - self.act = get_activation(act_func) if act_func is not None else None - - def forward(self, x: torch.Tensor) -> torch.Tensor: - if self.dropout is not None: - x = self.dropout(x) - x = self.conv(x) - if self.norm: - x = self.norm(x) - if self.act: - x = self.act(x) - return x - - -class ConvPixelUnshuffleDownSampleLayer(nn.Module): - def __init__( - self, - in_channels: int, - out_channels: int, - kernel_size: int, - factor: int, - ): - super().__init__() - self.factor = factor - out_ratio = factor**2 - assert out_channels % out_ratio == 0 - self.conv = ConvLayer( - in_channels=in_channels, - out_channels=out_channels // out_ratio, - kernel_size=kernel_size, - use_bias=True, - norm=None, - act_func=None, - ) - - def forward(self, x: torch.Tensor) -> torch.Tensor: - x = self.conv(x) - x = F.pixel_unshuffle(x, self.factor) - return x - - -class PixelUnshuffleChannelAveragingDownSampleLayer(nn.Module): - def __init__( - self, - in_channels: int, - out_channels: int, - factor: int, - ): - super().__init__() - self.in_channels = in_channels - self.out_channels = out_channels - self.factor = factor - assert in_channels * factor**2 % out_channels == 0 - self.group_size = in_channels * factor**2 // out_channels - - def forward(self, x: torch.Tensor) -> torch.Tensor: - x = F.pixel_unshuffle(x, self.factor) - B, C, H, W = x.shape - x = x.view(B, self.out_channels, self.group_size, H, W) - x = x.mean(dim=2) - return x - - -class ConvPixelShuffleUpSampleLayer(nn.Module): - def __init__( - self, - in_channels: int, - out_channels: int, - kernel_size: int, - factor: int, - ): - super().__init__() - self.factor = factor - out_ratio = factor**2 - self.conv = ConvLayer( - in_channels=in_channels, - out_channels=out_channels * out_ratio, - kernel_size=kernel_size, - use_bias=True, - norm=None, - act_func=None, - ) - - def forward(self, x: torch.Tensor) -> torch.Tensor: - x = self.conv(x) - x = F.pixel_shuffle(x, self.factor) - return x - - -class InterpolateConvUpSampleLayer(nn.Module): - def __init__( - self, - in_channels: int, - out_channels: int, - kernel_size: int, - factor: int, - mode: str = "nearest", - ) -> None: - super().__init__() - self.factor = factor - self.mode = mode - self.conv = ConvLayer( - in_channels=in_channels, - out_channels=out_channels, - kernel_size=kernel_size, - use_bias=True, - norm=None, - act_func=None, - ) - - def forward(self, x: torch.Tensor) -> torch.Tensor: - x = torch.nn.functional.interpolate(x, scale_factor=self.factor, mode=self.mode) - x = self.conv(x) - return x - - -class ChannelDuplicatingPixelUnshuffleUpSampleLayer(nn.Module): - def __init__( - self, - in_channels: int, - out_channels: int, - factor: int, - ): - super().__init__() - self.in_channels = in_channels - self.out_channels = out_channels - self.factor = factor - assert out_channels * factor**2 % in_channels == 0 - self.repeats = out_channels * factor**2 // in_channels - - def forward(self, x: torch.Tensor) -> torch.Tensor: - x = x.repeat_interleave(self.repeats, dim=1) - x = F.pixel_shuffle(x, self.factor) - return x - - -class IdentityLayer(nn.Module): - def forward(self, x: torch.Tensor) -> torch.Tensor: - return x - - -class GLUMBConv(nn.Module): - def __init__( - self, - in_channels: int, - out_channels: int, - kernel_size=3, - stride=1, - mid_channels=None, - expand_ratio=6, - use_bias=False, - norm=(None, None, "ln2d"), - act_func=("silu", "silu", None), - ): - super().__init__() - use_bias = val2tuple(use_bias, 3) - norm = val2tuple(norm, 3) - act_func = val2tuple(act_func, 3) - - mid_channels = round(in_channels * expand_ratio) if mid_channels is None else mid_channels - - self.glu_act = get_activation(act_func[1]) - self.inverted_conv = ConvLayer( - in_channels, - mid_channels * 2, - 1, - use_bias=use_bias[0], - norm=norm[0], - act_func=act_func[0], - ) - self.depth_conv = ConvLayer( - mid_channels * 2, - mid_channels * 2, - kernel_size, - stride=stride, - groups=mid_channels * 2, - use_bias=use_bias[1], - norm=norm[1], - act_func=None, - ) - self.point_conv = ConvLayer( - mid_channels, - out_channels, - 1, - use_bias=use_bias[2], - norm=norm[2], - act_func=act_func[2], - ) - - def forward(self, x: torch.Tensor) -> torch.Tensor: - x = self.inverted_conv(x) - x = self.depth_conv(x) - - x, gate = torch.chunk(x, 2, dim=1) - gate = self.glu_act(gate) - x = x * gate - - x = self.point_conv(x) - return x - - -class ResBlock(nn.Module): - def __init__( - self, - in_channels: int, - out_channels: int, - kernel_size=3, - stride=1, - mid_channels=None, - expand_ratio=1, - use_bias=False, - norm=("bn2d", "bn2d"), - act_func=("relu6", None), - ): - super().__init__() - use_bias = val2tuple(use_bias, 2) - norm = val2tuple(norm, 2) - act_func = val2tuple(act_func, 2) - - mid_channels = round(in_channels * expand_ratio) if mid_channels is None else mid_channels - - self.conv1 = ConvLayer( - in_channels, - mid_channels, - kernel_size, - stride, - use_bias=use_bias[0], - norm=norm[0], - act_func=act_func[0], - ) - self.conv2 = ConvLayer( - mid_channels, - out_channels, - kernel_size, - 1, - use_bias=use_bias[1], - norm=norm[1], - act_func=act_func[1], - ) - - def forward(self, x: torch.Tensor) -> torch.Tensor: - x = self.conv1(x) - x = self.conv2(x) - return x - - -class LiteMLA(nn.Module): - r"""Lightweight multi-scale linear attention""" - - def __init__( - self, - in_channels: int, - out_channels: int, - heads: Optional[int] = None, - heads_ratio: float = 1.0, - dim=8, - use_bias=False, - norm=(None, "bn2d"), - act_func=(None, None), - kernel_func="relu", - scales: tuple[int, ...] = (5,), - eps=1.0e-15, - ): - super(LiteMLA, self).__init__() - self.eps = eps - heads = int(in_channels // dim * heads_ratio) if heads is None else heads - - total_dim = heads * dim - - use_bias = val2tuple(use_bias, 2) - norm = val2tuple(norm, 2) - act_func = val2tuple(act_func, 2) - - self.dim = dim - self.qkv = ConvLayer( - in_channels, - 3 * total_dim, - 1, - use_bias=use_bias[0], - norm=norm[0], - act_func=act_func[0], - ) - self.aggreg = nn.ModuleList( - [ - nn.Sequential( - nn.Conv2d( - 3 * total_dim, - 3 * total_dim, - scale, - padding=get_same_padding(scale), - groups=3 * total_dim, - bias=use_bias[0], - ), - nn.Conv2d(3 * total_dim, 3 * total_dim, 1, groups=3 * heads, bias=use_bias[0]), - ) - for scale in scales - ] - ) - self.kernel_func = get_activation(kernel_func) - - self.proj = ConvLayer( - total_dim * (1 + len(scales)), - out_channels, - 1, - use_bias=use_bias[1], - norm=norm[1], - act_func=act_func[1], - ) - - @torch.autocast(device_type="cuda", enabled=False) - def relu_linear_att(self, qkv: torch.Tensor) -> torch.Tensor: - B, _, H, W = list(qkv.size()) - - if qkv.dtype == torch.float16: - qkv = qkv.float() - - qkv = torch.reshape( - qkv, - ( - B, - -1, - 3 * self.dim, - H * W, - ), - ) - q, k, v = ( - qkv[:, :, 0 : self.dim], - qkv[:, :, self.dim : 2 * self.dim], - qkv[:, :, 2 * self.dim :], - ) - - # lightweight linear attention - q = self.kernel_func(q) - k = self.kernel_func(k) - - # linear matmul - trans_k = k.transpose(-1, -2) - - v = F.pad(v, (0, 0, 0, 1), mode="constant", value=1) - vk = torch.matmul(v, trans_k) - out = torch.matmul(vk, q) - if out.dtype == torch.bfloat16: - out = out.float() - out = out[:, :, :-1] / (out[:, :, -1:] + self.eps) - - out = torch.reshape(out, (B, -1, H, W)) - return out - - @torch.autocast(device_type="cuda", enabled=False) - def relu_quadratic_att(self, qkv: torch.Tensor) -> torch.Tensor: - B, _, H, W = list(qkv.size()) - - qkv = torch.reshape( - qkv, - ( - B, - -1, - 3 * self.dim, - H * W, - ), - ) - q, k, v = ( - qkv[:, :, 0 : self.dim], - qkv[:, :, self.dim : 2 * self.dim], - qkv[:, :, 2 * self.dim :], - ) - - q = self.kernel_func(q) - k = self.kernel_func(k) - - att_map = torch.matmul(k.transpose(-1, -2), q) # b h n n - original_dtype = att_map.dtype - if original_dtype in [torch.float16, torch.bfloat16]: - att_map = att_map.float() - att_map = att_map / (torch.sum(att_map, dim=2, keepdim=True) + self.eps) # b h n n - att_map = att_map.to(original_dtype) - out = torch.matmul(v, att_map) # b h d n - - out = torch.reshape(out, (B, -1, H, W)) - return out - - def forward(self, x: torch.Tensor) -> torch.Tensor: - # generate multi-scale q, k, v - qkv = self.qkv(x) - multi_scale_qkv = [qkv] - for op in self.aggreg: - multi_scale_qkv.append(op(qkv)) - qkv = torch.cat(multi_scale_qkv, dim=1) - - H, W = list(qkv.size())[-2:] - if H * W > self.dim: - out = self.relu_linear_att(qkv).to(qkv.dtype) - else: - out = self.relu_quadratic_att(qkv) - out = self.proj(out) - - return out - - -class EfficientViTBlock(nn.Module): - def __init__( - self, - in_channels: int, - heads_ratio: float = 1.0, - dim=32, - expand_ratio: float = 4, - scales: tuple[int, ...] = (5,), - norm: str = "bn2d", - act_func: str = "hswish", - context_module: str = "LiteMLA", - local_module: str = "MBConv", - ): - super(EfficientViTBlock, self).__init__() - if context_module == "LiteMLA": - self.context_module = ResidualBlock( - LiteMLA( - in_channels=in_channels, - out_channels=in_channels, - heads_ratio=heads_ratio, - dim=dim, - norm=(None, norm), - scales=scales, - ), - IdentityLayer(), - ) - else: - raise ValueError(f"context_module {context_module} is not supported") - if local_module == "MBConv": - self.local_module = ResidualBlock( - MBConv( - in_channels=in_channels, - out_channels=in_channels, - expand_ratio=expand_ratio, - use_bias=(True, True, False), - norm=(None, None, norm), - act_func=(act_func, act_func, None), - ), - IdentityLayer(), - ) - elif local_module == "GLUMBConv": - self.local_module = ResidualBlock( - GLUMBConv( - in_channels=in_channels, - out_channels=in_channels, - expand_ratio=expand_ratio, - use_bias=(True, True, False), - norm=(None, None, norm), - act_func=(act_func, act_func, None), - ), - IdentityLayer(), - ) - else: - raise NotImplementedError(f"local_module {local_module} is not supported") - - def forward(self, x: torch.Tensor) -> torch.Tensor: - x = self.context_module(x) - x = self.local_module(x) - return x - - -################################################################################# -# Functional Blocks # -################################################################################# - - -class ResidualBlock(nn.Module): - def __init__( - self, - main: Optional[nn.Module], - shortcut: Optional[nn.Module], - post_act=None, - pre_norm: Optional[nn.Module] = None, - ): - super(ResidualBlock, self).__init__() - - self.pre_norm = pre_norm - self.main = main - self.shortcut = shortcut - self.post_act = get_activation(post_act) if post_act is not None else None - - def forward_main(self, x: torch.Tensor) -> torch.Tensor: - if self.pre_norm is None: - return self.main(x) - else: - return self.main(self.pre_norm(x)) - - def forward(self, x: torch.Tensor) -> torch.Tensor: - if self.main is None: - res = x - elif self.shortcut is None: - res = self.forward_main(x) - else: - res = self.forward_main(x) + self.shortcut(x) - if self.post_act: - res = self.post_act(res) - return res - - -class OpSequential(nn.Module): - def __init__(self, op_list: list[Optional[nn.Module]]): - super(OpSequential, self).__init__() - valid_op_list = [] - for op in op_list: - if op is not None: - valid_op_list.append(op) - self.op_list = nn.ModuleList(valid_op_list) - - def forward(self, x: torch.Tensor) -> torch.Tensor: - for op in self.op_list: - x = op(x) - return x diff --git a/src/diffusers/models/autoencoders/dc_ae_blocks/utils/list.py b/src/diffusers/models/autoencoders/dc_ae_blocks/utils/list.py deleted file mode 100644 index 71fa5f78131f..000000000000 --- a/src/diffusers/models/autoencoders/dc_ae_blocks/utils/list.py +++ /dev/null @@ -1,51 +0,0 @@ -from typing import Any, Optional - -__all__ = [ - "list_sum", - "list_mean", - "weighted_list_sum", - "list_join", - "val2list", - "val2tuple", - "squeeze_list", -] - - -def list_sum(x: list) -> Any: - return x[0] if len(x) == 1 else x[0] + list_sum(x[1:]) - - -def list_mean(x: list) -> Any: - return list_sum(x) / len(x) - - -def weighted_list_sum(x: list, weights: list) -> Any: - assert len(x) == len(weights) - return x[0] * weights[0] if len(x) == 1 else x[0] * weights[0] + weighted_list_sum(x[1:], weights[1:]) - - -def list_join(x: list, sep="\t", format_str="%s") -> str: - return sep.join([format_str % val for val in x]) - - -def val2list(x: list | tuple | Any, repeat_time=1) -> list: - if isinstance(x, (list, tuple)): - return list(x) - return [x for _ in range(repeat_time)] - - -def val2tuple(x: list | tuple | Any, min_len: int = 1, idx_repeat: int = -1) -> tuple: - x = val2list(x) - - # repeat elements if necessary - if len(x) > 0: - x[idx_repeat:idx_repeat] = [x[idx_repeat] for _ in range(min_len - len(x))] - - return tuple(x) - - -def squeeze_list(x: Optional[list]) -> list | Any: - if x is not None and len(x) == 1: - return x[0] - else: - return x diff --git a/src/diffusers/models/autoencoders/dc_ae_blocks/utils/network.py b/src/diffusers/models/autoencoders/dc_ae_blocks/utils/network.py deleted file mode 100644 index fa054e7acb8f..000000000000 --- a/src/diffusers/models/autoencoders/dc_ae_blocks/utils/network.py +++ /dev/null @@ -1,95 +0,0 @@ -import collections -import os -from inspect import signature -from typing import Any, Callable, Optional - -import torch -import torch.nn as nn -import torch.nn.functional as F - -__all__ = [ - "is_parallel", - "get_device", - "get_same_padding", - "resize", - "build_kwargs_from_config", - "load_state_dict_from_file", - "get_submodule_weights", -] - - -def is_parallel(model: nn.Module) -> bool: - return isinstance(model, (nn.parallel.DataParallel, nn.parallel.DistributedDataParallel)) - - -def get_device(model: nn.Module) -> torch.device: - return model.parameters().__next__().device - - -def get_dtype(model: nn.Module) -> torch.dtype: - return model.parameters().__next__().dtype - - -def get_same_padding(kernel_size: int | tuple[int, ...]) -> int | tuple[int, ...]: - if isinstance(kernel_size, tuple): - return tuple([get_same_padding(ks) for ks in kernel_size]) - else: - assert kernel_size % 2 > 0, "kernel size should be odd number" - return kernel_size // 2 - - -def resize( - x: torch.Tensor, - size: Optional[Any] = None, - scale_factor: Optional[list[float]] = None, - mode: str = "bicubic", - align_corners: Optional[bool] = False, -) -> torch.Tensor: - if mode in {"bilinear", "bicubic"}: - return F.interpolate( - x, - size=size, - scale_factor=scale_factor, - mode=mode, - align_corners=align_corners, - ) - elif mode in {"nearest", "area"}: - return F.interpolate(x, size=size, scale_factor=scale_factor, mode=mode) - else: - raise NotImplementedError(f"resize(mode={mode}) not implemented.") - - -def build_kwargs_from_config(config: dict, target_func: Callable) -> dict[str, Any]: - valid_keys = list(signature(target_func).parameters) - kwargs = {} - for key in config: - if key in valid_keys: - kwargs[key] = config[key] - return kwargs - - -def load_state_dict_from_file(file: str, only_state_dict=True) -> dict[str, torch.Tensor]: - file = os.path.realpath(os.path.expanduser(file)) - checkpoint = torch.load(file, map_location="cpu", weights_only=True) - if only_state_dict and "state_dict" in checkpoint: - checkpoint = checkpoint["state_dict"] - return checkpoint - - -def get_submodule_weights(weights: collections.OrderedDict, prefix: str): - submodule_weights = collections.OrderedDict() - len_prefix = len(prefix) - for key, weight in weights.items(): - if key.startswith(prefix): - submodule_weights[key[len_prefix:]] = weight - return submodule_weights - - -def get_dtype_from_str(dtype: str) -> torch.dtype: - if dtype == "fp32": - return torch.float32 - if dtype == "fp16": - return torch.float16 - if dtype == "bf16": - return torch.bfloat16 - raise NotImplementedError(f"dtype {dtype} is not supported") diff --git a/src/diffusers/models/normalization.py b/src/diffusers/models/normalization.py index 029c147fcbac..558303f1653a 100644 --- a/src/diffusers/models/normalization.py +++ b/src/diffusers/models/normalization.py @@ -528,3 +528,11 @@ def forward(self, x): gx = torch.norm(x, p=2, dim=(1, 2), keepdim=True) nx = gx / (gx.mean(dim=-1, keepdim=True) + 1e-6) return self.gamma * (x * nx) + self.beta + x + + +class RMSNorm2d(nn.LayerNorm): + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = x / torch.sqrt(torch.square(x).mean(dim=1, keepdim=True) + self.eps) + if self.elementwise_affine: + x = x * self.weight.view(1, -1, 1, 1) + self.bias.view(1, -1, 1, 1) + return x From 1448681057091ad0daafe9fd721c8b175c799e33 Mon Sep 17 00:00:00 2001 From: Junyu Chen Date: Fri, 8 Nov 2024 19:47:17 -0800 Subject: [PATCH 011/141] update downsample and upsample --- src/diffusers/models/autoencoders/dc_ae.py | 183 ++++----------------- src/diffusers/models/downsampling.py | 47 ++++++ src/diffusers/models/normalization.py | 8 - src/diffusers/models/upsampling.py | 44 +++++ 4 files changed, 121 insertions(+), 161 deletions(-) diff --git a/src/diffusers/models/autoencoders/dc_ae.py b/src/diffusers/models/autoencoders/dc_ae.py index 3e8927ac1638..5f6946b5c12a 100644 --- a/src/diffusers/models/autoencoders/dc_ae.py +++ b/src/diffusers/models/autoencoders/dc_ae.py @@ -20,12 +20,14 @@ import torch.nn.functional as F from torch.nn import BatchNorm2d from huggingface_hub import PyTorchModelHubMixin +import ipdb from ...configuration_utils import ConfigMixin, register_to_config from ..modeling_utils import ModelMixin from ..activations import get_activation -from ..normalization import RMSNorm2d +from ..downsampling import ConvPixelUnshuffleDownsample2D, PixelUnshuffleChannelAveragingDownsample2D +from ..upsampling import ConvPixelShuffleUpsample2D, ChannelDuplicatingPixelUnshuffleUpsample2D, Upsample2D __all__ = ["DCAE", "dc_ae_f32c32", "dc_ae_f64c128", "dc_ae_f128c512"] @@ -47,6 +49,13 @@ def get_same_padding(kernel_size: int | tuple[int, ...]) -> int | tuple[int, ... return kernel_size // 2 +class RMSNorm2d(nn.LayerNorm): + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = (x / torch.sqrt(torch.square(x.float()).mean(dim=1, keepdim=True) + self.eps)).to(x.dtype) + if self.elementwise_affine: + x = x * self.weight.view(1, -1, 1, 1) + self.bias.view(1, -1, 1, 1) + return x + def build_norm(name: Optional[str]="bn2d", num_features: Optional[int]=None) -> Optional[nn.Module]: if name is None: norm = None @@ -103,133 +112,6 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: return x -class ConvPixelUnshuffleDownSampleLayer(nn.Module): - def __init__( - self, - in_channels: int, - out_channels: int, - kernel_size: int, - factor: int, - ): - super().__init__() - self.factor = factor - out_ratio = factor**2 - assert out_channels % out_ratio == 0 - self.conv = ConvLayer( - in_channels=in_channels, - out_channels=out_channels // out_ratio, - kernel_size=kernel_size, - use_bias=True, - norm=None, - act_func=None, - ) - - def forward(self, x: torch.Tensor) -> torch.Tensor: - x = self.conv(x) - x = F.pixel_unshuffle(x, self.factor) - return x - - -class PixelUnshuffleChannelAveragingDownSampleLayer(nn.Module): - def __init__( - self, - in_channels: int, - out_channels: int, - factor: int, - ): - super().__init__() - self.in_channels = in_channels - self.out_channels = out_channels - self.factor = factor - assert in_channels * factor**2 % out_channels == 0 - self.group_size = in_channels * factor**2 // out_channels - - def forward(self, x: torch.Tensor) -> torch.Tensor: - x = F.pixel_unshuffle(x, self.factor) - B, C, H, W = x.shape - x = x.view(B, self.out_channels, self.group_size, H, W) - x = x.mean(dim=2) - return x - - -class ConvPixelShuffleUpSampleLayer(nn.Module): - def __init__( - self, - in_channels: int, - out_channels: int, - kernel_size: int, - factor: int, - ): - super().__init__() - self.factor = factor - out_ratio = factor**2 - self.conv = ConvLayer( - in_channels=in_channels, - out_channels=out_channels * out_ratio, - kernel_size=kernel_size, - use_bias=True, - norm=None, - act_func=None, - ) - - def forward(self, x: torch.Tensor) -> torch.Tensor: - x = self.conv(x) - x = F.pixel_shuffle(x, self.factor) - return x - - -class InterpolateConvUpSampleLayer(nn.Module): - def __init__( - self, - in_channels: int, - out_channels: int, - kernel_size: int, - factor: int, - mode: str = "nearest", - ) -> None: - super().__init__() - self.factor = factor - self.mode = mode - self.conv = ConvLayer( - in_channels=in_channels, - out_channels=out_channels, - kernel_size=kernel_size, - use_bias=True, - norm=None, - act_func=None, - ) - - def forward(self, x: torch.Tensor) -> torch.Tensor: - x = torch.nn.functional.interpolate(x, scale_factor=self.factor, mode=self.mode) - x = self.conv(x) - return x - - -class ChannelDuplicatingPixelUnshuffleUpSampleLayer(nn.Module): - def __init__( - self, - in_channels: int, - out_channels: int, - factor: int, - ): - super().__init__() - self.in_channels = in_channels - self.out_channels = out_channels - self.factor = factor - assert out_channels * factor**2 % in_channels == 0 - self.repeats = out_channels * factor**2 // in_channels - - def forward(self, x: torch.Tensor) -> torch.Tensor: - x = x.repeat_interleave(self.repeats, dim=1) - x = F.pixel_shuffle(x, self.factor) - return x - - -class IdentityLayer(nn.Module): - def forward(self, x: torch.Tensor) -> torch.Tensor: - return x - - class GLUMBConv(nn.Module): def __init__( self, @@ -512,7 +394,7 @@ def __init__( norm=(None, norm), scales=scales, ), - IdentityLayer(), + nn.Identity(), ) else: raise ValueError(f"context_module {context_module} is not supported") @@ -526,7 +408,7 @@ def __init__( norm=(None, None, norm), act_func=(act_func, act_func, None), ), - IdentityLayer(), + nn.Identity(), ) else: raise NotImplementedError(f"local_module {local_module} is not supported") @@ -605,7 +487,7 @@ def build_block( norm=(None, norm), act_func=(act, None), ) - block = ResidualBlock(main_block, IdentityLayer()) + block = ResidualBlock(main_block, nn.Identity()) elif block_type == "EViT_GLU": assert in_channels == out_channels block = EfficientViTBlock(in_channels, norm=norm, act_func=act, local_module="GLUMBConv", scales=()) @@ -637,17 +519,15 @@ def build_stage_main( def build_downsample_block(block_type: str, in_channels: int, out_channels: int, shortcut: Optional[str]) -> nn.Module: if block_type == "Conv": - block = ConvLayer( + block = nn.Conv2d( in_channels=in_channels, out_channels=out_channels, kernel_size=3, stride=2, - use_bias=True, - norm=None, - act_func=None, + padding=1, ) elif block_type == "ConvPixelUnshuffle": - block = ConvPixelUnshuffleDownSampleLayer( + block = ConvPixelUnshuffleDownsample2D( in_channels=in_channels, out_channels=out_channels, kernel_size=3, factor=2 ) else: @@ -655,7 +535,7 @@ def build_downsample_block(block_type: str, in_channels: int, out_channels: int, if shortcut is None: pass elif shortcut == "averaging": - shortcut_block = PixelUnshuffleChannelAveragingDownSampleLayer( + shortcut_block = PixelUnshuffleChannelAveragingDownsample2D( in_channels=in_channels, out_channels=out_channels, factor=2 ) block = ResidualBlock(block, shortcut_block) @@ -666,19 +546,17 @@ def build_downsample_block(block_type: str, in_channels: int, out_channels: int, def build_upsample_block(block_type: str, in_channels: int, out_channels: int, shortcut: Optional[str]) -> nn.Module: if block_type == "ConvPixelShuffle": - block = ConvPixelShuffleUpSampleLayer( + block = ConvPixelShuffleUpsample2D( in_channels=in_channels, out_channels=out_channels, kernel_size=3, factor=2 ) elif block_type == "InterpolateConv": - block = InterpolateConvUpSampleLayer( - in_channels=in_channels, out_channels=out_channels, kernel_size=3, factor=2 - ) + block = Upsample2D(channels=in_channels, use_conv=True, out_channels=out_channels) else: raise ValueError(f"block_type {block_type} is not supported for upsampling") if shortcut is None: pass elif shortcut == "duplicating": - shortcut_block = ChannelDuplicatingPixelUnshuffleUpSampleLayer( + shortcut_block = ChannelDuplicatingPixelUnshuffleUpsample2D( in_channels=in_channels, out_channels=out_channels, factor=2 ) block = ResidualBlock(block, shortcut_block) @@ -689,14 +567,11 @@ def build_upsample_block(block_type: str, in_channels: int, out_channels: int, s def build_encoder_project_in_block(in_channels: int, out_channels: int, factor: int, downsample_block_type: str): if factor == 1: - block = ConvLayer( + block = nn.Conv2d( in_channels=in_channels, out_channels=out_channels, kernel_size=3, - stride=1, - use_bias=True, - norm=None, - act_func=None, + padding=1, ) elif factor == 2: block = build_downsample_block( @@ -728,7 +603,7 @@ def build_encoder_project_out_block( if shortcut is None: pass elif shortcut == "averaging": - shortcut_block = PixelUnshuffleChannelAveragingDownSampleLayer( + shortcut_block = PixelUnshuffleChannelAveragingDownsample2D( in_channels=in_channels, out_channels=out_channels, factor=1 ) block = ResidualBlock(block, shortcut_block) @@ -750,7 +625,7 @@ def build_decoder_project_in_block(in_channels: int, out_channels: int, shortcut if shortcut is None: pass elif shortcut == "duplicating": - shortcut_block = ChannelDuplicatingPixelUnshuffleUpSampleLayer( + shortcut_block = ChannelDuplicatingPixelUnshuffleUpsample2D( in_channels=in_channels, out_channels=out_channels, factor=1 ) block = ResidualBlock(block, shortcut_block) @@ -947,15 +822,15 @@ def __init__( self, in_channels: int = 3, latent_channels: int = 32, + encoder_block_type: str | list[str] = "ResBlock", encoder_width_list: list[int] = [128, 256, 512, 512, 1024, 1024], encoder_depth_list: list[int] = [2, 2, 2, 2, 2, 2], - encoder_block_type: str | list[str] = "ResBlock", encoder_norm: str = "rms2d", encoder_act: str = "silu", downsample_block_type: str = "ConvPixelUnshuffle", + decoder_block_type: str | list[str] = "ResBlock", decoder_width_list: list[int] = [128, 256, 512, 512, 1024, 1024], decoder_depth_list: list[int] = [2, 2, 2, 2, 2, 2], - decoder_block_type: str | list[str] = "ResBlock", decoder_norm: str = "rms2d", decoder_act: str = "silu", upsample_block_type: str = "ConvPixelShuffle", @@ -1103,16 +978,18 @@ def main(): torch.set_grad_enabled(False) device = torch.device("cuda") + dtype = torch.float32 transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), ]) image = Image.open("/home/junyuc/workspace/code/efficientvit/assets/fig/girl.png") - x = transform(image)[None].to(device) + x = transform(image)[None].to(device=device, dtype=dtype) for model_name in REGISTERED_DCAE_MODEL: dc_ae = DCAE_HF.from_pretrained(f"mit-han-lab/{model_name}") - dc_ae = dc_ae.to(device).eval() + dc_ae = dc_ae.to(device=device, dtype=dtype).eval() + ipdb.set_trace() latent = dc_ae.encode(x) print(latent.shape) y = dc_ae.decode(latent) diff --git a/src/diffusers/models/downsampling.py b/src/diffusers/models/downsampling.py index 3ac8953e3dcc..479e88ba374a 100644 --- a/src/diffusers/models/downsampling.py +++ b/src/diffusers/models/downsampling.py @@ -285,6 +285,53 @@ def forward(self, inputs: torch.Tensor) -> torch.Tensor: return F.conv2d(inputs, weight, stride=2) +class ConvPixelUnshuffleDownsample2D(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + kernel_size: int, + factor: int, + ): + super().__init__() + self.factor = factor + out_ratio = factor**2 + assert out_channels % out_ratio == 0 + self.conv = nn.Conv2d( + in_channels=in_channels, + out_channels=out_channels // out_ratio, + kernel_size=kernel_size, + padding=kernel_size // 2, + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = self.conv(x) + x = F.pixel_unshuffle(x, self.factor) + return x + + +class PixelUnshuffleChannelAveragingDownsample2D(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + factor: int, + ): + super().__init__() + self.in_channels = in_channels + self.out_channels = out_channels + self.factor = factor + assert in_channels * factor**2 % out_channels == 0 + self.group_size = in_channels * factor**2 // out_channels + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = F.pixel_unshuffle(x, self.factor) + B, C, H, W = x.shape + x = x.view(B, self.out_channels, self.group_size, H, W) + x = x.mean(dim=2) + return x + + class CogVideoXDownsample3D(nn.Module): # Todo: Wait for paper relase. r""" diff --git a/src/diffusers/models/normalization.py b/src/diffusers/models/normalization.py index 63da596a0607..87dec66935da 100644 --- a/src/diffusers/models/normalization.py +++ b/src/diffusers/models/normalization.py @@ -526,11 +526,3 @@ def forward(self, x): gx = torch.norm(x, p=2, dim=(1, 2), keepdim=True) nx = gx / (gx.mean(dim=-1, keepdim=True) + 1e-6) return self.gamma * (x * nx) + self.beta + x - - -class RMSNorm2d(nn.LayerNorm): - def forward(self, x: torch.Tensor) -> torch.Tensor: - x = x / torch.sqrt(torch.square(x).mean(dim=1, keepdim=True) + self.eps) - if self.elementwise_affine: - x = x * self.weight.view(1, -1, 1, 1) + self.bias.view(1, -1, 1, 1) - return x diff --git a/src/diffusers/models/upsampling.py b/src/diffusers/models/upsampling.py index cf07e45b0c5c..e24900e7a022 100644 --- a/src/diffusers/models/upsampling.py +++ b/src/diffusers/models/upsampling.py @@ -348,6 +348,50 @@ def forward(self, inputs: torch.Tensor) -> torch.Tensor: return F.conv_transpose2d(inputs, weight, stride=2, padding=self.pad * 2 + 1) +class ConvPixelShuffleUpsample2D(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + kernel_size: int, + factor: int, + ): + super().__init__() + self.factor = factor + out_ratio = factor**2 + self.conv = nn.Conv2d( + in_channels=in_channels, + out_channels=out_channels * out_ratio, + kernel_size=kernel_size, + padding=kernel_size // 2, + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = self.conv(x) + x = F.pixel_shuffle(x, self.factor) + return x + + +class ChannelDuplicatingPixelUnshuffleUpsample2D(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + factor: int, + ): + super().__init__() + self.in_channels = in_channels + self.out_channels = out_channels + self.factor = factor + assert out_channels * factor**2 % in_channels == 0 + self.repeats = out_channels * factor**2 // in_channels + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = x.repeat_interleave(self.repeats, dim=1) + x = F.pixel_shuffle(x, self.factor) + return x + + class CogVideoXUpsample3D(nn.Module): r""" A 3D Upsample layer using in CogVideoX by Tsinghua University & ZhipuAI # Todo: Wait for paper relase. From dd7718a29aeb0bbb3df0efb64291057905732654 Mon Sep 17 00:00:00 2001 From: Junyu Chen Date: Fri, 8 Nov 2024 19:59:09 -0800 Subject: [PATCH 012/141] clean code --- src/diffusers/models/autoencoders/dc_ae.py | 132 +-------------------- 1 file changed, 1 insertion(+), 131 deletions(-) diff --git a/src/diffusers/models/autoencoders/dc_ae.py b/src/diffusers/models/autoencoders/dc_ae.py index 5f6946b5c12a..0e62544f2087 100644 --- a/src/diffusers/models/autoencoders/dc_ae.py +++ b/src/diffusers/models/autoencoders/dc_ae.py @@ -30,9 +30,6 @@ from ..upsampling import ConvPixelShuffleUpsample2D, ChannelDuplicatingPixelUnshuffleUpsample2D, Upsample2D -__all__ = ["DCAE", "dc_ae_f32c32", "dc_ae_f64c128", "dc_ae_f128c512"] - - def val2tuple(x: list | tuple | Any, min_len: int = 1) -> tuple: x = list(x) if isinstance(x, (list, tuple)) else [x] # repeat elements if necessary @@ -56,6 +53,7 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: x = x * self.weight.view(1, -1, 1, 1) + self.bias.view(1, -1, 1, 1) return x + def build_norm(name: Optional[str]="bn2d", num_features: Optional[int]=None) -> Optional[nn.Module]: if name is None: norm = None @@ -472,7 +470,6 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: return x - def build_block( block_type: str, in_channels: int, out_channels: int, norm: Optional[str], act: Optional[str] ) -> nn.Module: @@ -874,130 +871,3 @@ def forward(self, x: torch.Tensor, global_step: int) -> torch.Tensor: x = self.encoder(x) x = self.decoder(x) return x, torch.tensor(0), {} - - -def dc_ae_f32c32(name: str) -> dict: - if name in ["dc-ae-f32c32-in-1.0", "dc-ae-f32c32-mix-1.0"]: - cfg = { - "latent_channels": 32, - "encoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViT_GLU", "EViT_GLU", "EViT_GLU"], - "encoder_width_list": [128, 256, 512, 512, 1024, 1024], - "encoder_depth_list": [0, 4, 8, 2, 2, 2], - "decoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViT_GLU", "EViT_GLU", "EViT_GLU"], - "decoder_width_list": [128, 256, 512, 512, 1024, 1024], - "decoder_depth_list": [0, 5, 10, 2, 2, 2], - "decoder_norm": ["bn2d", "bn2d", "bn2d", "rms2d", "rms2d", "rms2d"], - "decoder_act": ["relu", "relu", "relu", "silu", "silu", "silu"], - } - elif name in ["dc-ae-f32c32-sana-1.0"]: - cfg = { - "latent_channels": 32, - "encoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViTS5_GLU", "EViTS5_GLU", "EViTS5_GLU"], - "encoder_width_list": [128, 256, 512, 512, 1024, 1024], - "encoder_depth_list": [2, 2, 2, 3, 3, 3], - "downsample_block_type": "Conv", - "decoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViTS5_GLU", "EViTS5_GLU", "EViTS5_GLU"], - "decoder_width_list": [128, 256, 512, 512, 1024, 1024], - "decoder_depth_list": [3, 3, 3, 3, 3, 3], - "upsample_block_type": "InterpolateConv", - "scaling_factor": 0.41407, - } - else: - raise NotImplementedError - return cfg - - -def dc_ae_f64c128(name: str,) -> dict: - if name in ["dc-ae-f64c128-in-1.0", "dc-ae-f64c128-mix-1.0"]: - cfg = { - "latent_channels": 128, - "encoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViT_GLU", "EViT_GLU", "EViT_GLU", "EViT_GLU"], - "encoder_width_list": [128, 256, 512, 512, 1024, 1024, 2048], - "encoder_depth_list": [0, 4, 8, 2, 2, 2, 2], - "decoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViT_GLU", "EViT_GLU", "EViT_GLU", "EViT_GLU"], - "decoder_width_list": [128, 256, 512, 512, 1024, 1024, 2048], - "decoder_depth_list": [0, 5, 10, 2, 2, 2, 2], - "decoder_norm": ["bn2d", "bn2d", "bn2d", "rms2d", "rms2d", "rms2d", "rms2d"], - "decoder_act": ["relu", "relu", "relu", "silu", "silu", "silu", "silu"], - } - else: - raise NotImplementedError - return cfg - - -def dc_ae_f128c512(name: str,) -> dict: - if name in ["dc-ae-f128c512-in-1.0", "dc-ae-f128c512-mix-1.0"]: - cfg = { - "latent_channels": 512, - "encoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViT_GLU", "EViT_GLU", "EViT_GLU", "EViT_GLU", "EViT_GLU"], - "encoder_width_list": [128, 256, 512, 512, 1024, 1024, 2048, 2048], - "encoder_depth_list": [0, 4, 8, 2, 2, 2, 2, 2], - "decoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViT_GLU", "EViT_GLU", "EViT_GLU", "EViT_GLU", "EViT_GLU"], - "decoder_width_list": [128, 256, 512, 512, 1024, 1024, 2048, 2048], - "decoder_depth_list": [0, 5, 10, 2, 2, 2, 2, 2], - "decoder_norm": ["bn2d", "bn2d", "bn2d", "rms2d", "rms2d", "rms2d", "rms2d", "rms2d"], - "decoder_act": ["relu", "relu", "relu", "silu", "silu", "silu", "silu", "silu"], - } - else: - raise NotImplementedError - return cfg - - -REGISTERED_DCAE_MODEL: dict[str, Callable] = { - "dc-ae-f32c32-in-1.0": dc_ae_f32c32, - "dc-ae-f64c128-in-1.0": dc_ae_f64c128, - "dc-ae-f128c512-in-1.0": dc_ae_f128c512, - ################################################################################################# - "dc-ae-f32c32-mix-1.0": dc_ae_f32c32, - "dc-ae-f64c128-mix-1.0": dc_ae_f64c128, - "dc-ae-f128c512-mix-1.0": dc_ae_f128c512, - ################################################################################################# - "dc-ae-f32c32-sana-1.0": dc_ae_f32c32, -} - - -def create_dc_ae_model_cfg(name: str) -> dict: - assert name in REGISTERED_DCAE_MODEL, f"{name} is not supported" - dc_ae_cls = REGISTERED_DCAE_MODEL[name] - model_cfg = dc_ae_cls(name) - return model_cfg - - -class DCAE_HF(PyTorchModelHubMixin, DCAE): - def __init__(self, model_name: str): - cfg = create_dc_ae_model_cfg(model_name) - DCAE.__init__(self, **cfg) - - -def main(): - from PIL import Image - import torch - import torchvision.transforms as transforms - from torchvision.utils import save_image - import ipdb - - torch.set_grad_enabled(False) - device = torch.device("cuda") - dtype = torch.float32 - - transform = transforms.Compose([ - transforms.ToTensor(), - transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), - ]) - image = Image.open("/home/junyuc/workspace/code/efficientvit/assets/fig/girl.png") - x = transform(image)[None].to(device=device, dtype=dtype) - for model_name in REGISTERED_DCAE_MODEL: - dc_ae = DCAE_HF.from_pretrained(f"mit-han-lab/{model_name}") - dc_ae = dc_ae.to(device=device, dtype=dtype).eval() - ipdb.set_trace() - latent = dc_ae.encode(x) - print(latent.shape) - y = dc_ae.decode(latent) - save_image(y * 0.5 + 0.5, f"demo_{model_name}.png") - -if __name__ == "__main__": - main() - -""" -python -m src.diffusers.models.autoencoders.dc_ae -""" \ No newline at end of file From 19986a524ca52536c503c05ad16a0fad57064676 Mon Sep 17 00:00:00 2001 From: Junyu Chen Date: Fri, 8 Nov 2024 20:05:12 -0800 Subject: [PATCH 013/141] support DecoderOutput --- src/diffusers/models/autoencoders/dc_ae.py | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/src/diffusers/models/autoencoders/dc_ae.py b/src/diffusers/models/autoencoders/dc_ae.py index 0e62544f2087..dd912f7ea481 100644 --- a/src/diffusers/models/autoencoders/dc_ae.py +++ b/src/diffusers/models/autoencoders/dc_ae.py @@ -13,7 +13,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -from typing import Any, Optional, Callable +from typing import Any, Optional, Callable, Union import torch import torch.nn as nn @@ -29,6 +29,7 @@ from ..downsampling import ConvPixelUnshuffleDownsample2D, PixelUnshuffleChannelAveragingDownsample2D from ..upsampling import ConvPixelShuffleUpsample2D, ChannelDuplicatingPixelUnshuffleUpsample2D, Upsample2D +from .vae import DecoderOutput def val2tuple(x: list | tuple | Any, min_len: int = 1) -> tuple: x = list(x) if isinstance(x, (list, tuple)) else [x] @@ -863,9 +864,12 @@ def encode(self, x: torch.Tensor) -> torch.Tensor: x = self.encoder(x) return x - def decode(self, x: torch.Tensor) -> torch.Tensor: + def decode(self, x: torch.Tensor, return_dict: bool = True) -> Union[DecoderOutput, torch.Tensor]: x = self.decoder(x) - return x + if not return_dict: + return x + else: + return DecoderOutput(sample=x) def forward(self, x: torch.Tensor, global_step: int) -> torch.Tensor: x = self.encoder(x) From c6eb23361c612afe9d2f8083b84fbc8704a828a2 Mon Sep 17 00:00:00 2001 From: Junyu Chen Date: Wed, 13 Nov 2024 20:03:45 -0800 Subject: [PATCH 014/141] remove get_same_padding and val2tuple --- src/diffusers/models/autoencoders/dc_ae.py | 40 ++++------------------ 1 file changed, 7 insertions(+), 33 deletions(-) diff --git a/src/diffusers/models/autoencoders/dc_ae.py b/src/diffusers/models/autoencoders/dc_ae.py index dd912f7ea481..f0a82940392b 100644 --- a/src/diffusers/models/autoencoders/dc_ae.py +++ b/src/diffusers/models/autoencoders/dc_ae.py @@ -31,21 +31,6 @@ from .vae import DecoderOutput -def val2tuple(x: list | tuple | Any, min_len: int = 1) -> tuple: - x = list(x) if isinstance(x, (list, tuple)) else [x] - # repeat elements if necessary - if len(x) > 0: - x.extend([x[-1] for _ in range(min_len - len(x))]) - return tuple(x) - - -def get_same_padding(kernel_size: int | tuple[int, ...]) -> int | tuple[int, ...]: - if isinstance(kernel_size, tuple): - return tuple([get_same_padding(ks) for ks in kernel_size]) - else: - assert kernel_size % 2 > 0, "kernel size should be odd number" - return kernel_size // 2 - class RMSNorm2d(nn.LayerNorm): def forward(self, x: torch.Tensor) -> torch.Tensor: @@ -83,7 +68,7 @@ def __init__( ): super(ConvLayer, self).__init__() - padding = get_same_padding(kernel_size) + padding = kernel_size // 2 padding *= dilation self.dropout = nn.Dropout2d(dropout, inplace=False) if dropout > 0 else None @@ -120,14 +105,11 @@ def __init__( stride=1, mid_channels=None, expand_ratio=6, - use_bias=False, + use_bias=(False, False, False), norm=(None, None, "ln2d"), act_func=("silu", "silu", None), ): super().__init__() - use_bias = val2tuple(use_bias, 3) - norm = val2tuple(norm, 3) - act_func = val2tuple(act_func, 3) mid_channels = round(in_channels * expand_ratio) if mid_channels is None else mid_channels @@ -180,15 +162,11 @@ def __init__( stride=1, mid_channels=None, expand_ratio=1, - use_bias=False, + use_bias=(False, False), norm=("bn2d", "bn2d"), act_func=("relu6", None), ): super().__init__() - use_bias = val2tuple(use_bias, 2) - norm = val2tuple(norm, 2) - act_func = val2tuple(act_func, 2) - mid_channels = round(in_channels * expand_ratio) if mid_channels is None else mid_channels self.conv1 = ConvLayer( @@ -226,7 +204,7 @@ def __init__( heads: Optional[int] = None, heads_ratio: float = 1.0, dim=8, - use_bias=False, + use_bias=(False, False), norm=(None, "bn2d"), act_func=(None, None), kernel_func="relu", @@ -239,10 +217,6 @@ def __init__( total_dim = heads * dim - use_bias = val2tuple(use_bias, 2) - norm = val2tuple(norm, 2) - act_func = val2tuple(act_func, 2) - self.dim = dim self.qkv = ConvLayer( in_channels, @@ -259,7 +233,7 @@ def __init__( 3 * total_dim, 3 * total_dim, scale, - padding=get_same_padding(scale), + padding=scale // 2, groups=3 * total_dim, bias=use_bias[0], ), @@ -486,10 +460,10 @@ def build_block( act_func=(act, None), ) block = ResidualBlock(main_block, nn.Identity()) - elif block_type == "EViT_GLU": + elif block_type == "EViTGLU": assert in_channels == out_channels block = EfficientViTBlock(in_channels, norm=norm, act_func=act, local_module="GLUMBConv", scales=()) - elif block_type == "EViTS5_GLU": + elif block_type == "EViTS5GLU": assert in_channels == out_channels block = EfficientViTBlock(in_channels, norm=norm, act_func=act, local_module="GLUMBConv", scales=(5,)) else: From 59de0a347979bb37519b7374c49483979a277430 Mon Sep 17 00:00:00 2001 From: Junyu Chen Date: Wed, 13 Nov 2024 20:18:37 -0800 Subject: [PATCH 015/141] remove autocast and some assert --- src/diffusers/models/autoencoders/dc_ae.py | 32 ++++++++++++---------- 1 file changed, 17 insertions(+), 15 deletions(-) diff --git a/src/diffusers/models/autoencoders/dc_ae.py b/src/diffusers/models/autoencoders/dc_ae.py index f0a82940392b..b488aa4b1bc2 100644 --- a/src/diffusers/models/autoencoders/dc_ae.py +++ b/src/diffusers/models/autoencoders/dc_ae.py @@ -211,7 +211,7 @@ def __init__( scales: tuple[int, ...] = (5,), eps=1.0e-15, ): - super(LiteMLA, self).__init__() + super().__init__() self.eps = eps heads = int(in_channels // dim * heads_ratio) if heads is None else heads @@ -253,7 +253,6 @@ def __init__( act_func=act_func[1], ) - @torch.autocast(device_type="cuda", enabled=False) def relu_linear_att(self, qkv: torch.Tensor) -> torch.Tensor: B, _, H, W = list(qkv.size()) @@ -292,7 +291,6 @@ def relu_linear_att(self, qkv: torch.Tensor) -> torch.Tensor: out = torch.reshape(out, (B, -1, H, W)) return out - @torch.autocast(device_type="cuda", enabled=False) def relu_quadratic_att(self, qkv: torch.Tensor) -> torch.Tensor: B, _, H, W = list(qkv.size()) @@ -657,11 +655,12 @@ def __init__( super().__init__() num_stages = len(width_list) self.num_stages = num_stages - assert len(depth_list) == num_stages - assert len(width_list) == num_stages - assert isinstance(block_type, str) or ( - isinstance(block_type, list) and len(block_type) == num_stages - ) + + # validate config + if len(depth_list) != num_stages or len(width_list) != num_stages: + raise ValueError(f"len(depth_list) {len(depth_list)} and len(width_list) {len(width_list)} should be equal to num_stages {num_stages}") + if not isinstance(block_type, (str, list)) or (isinstance(block_type, list) and len(block_type) != num_stages): + raise ValueError(f"block_type should be either a str or a list of str with length {num_stages}, but got {block_type}") self.project_in = build_encoder_project_in_block( in_channels=in_channels, @@ -725,13 +724,16 @@ def __init__( super().__init__() num_stages = len(width_list) self.num_stages = num_stages - assert len(depth_list) == num_stages - assert len(width_list) == num_stages - assert isinstance(block_type, str) or ( - isinstance(block_type, list) and len(block_type) == num_stages - ) - assert isinstance(norm, str) or (isinstance(norm, list) and len(norm) == num_stages) - assert isinstance(act, str) or (isinstance(act, list) and len(act) == num_stages) + + # validate config + if len(depth_list) != num_stages or len(width_list) != num_stages: + raise ValueError(f"len(depth_list) {len(depth_list)} and len(width_list) {len(width_list)} should be equal to num_stages {num_stages}") + if not isinstance(block_type, (str, list)) or (isinstance(block_type, list) and len(block_type) != num_stages): + raise ValueError(f"block_type should be either a str or a list of str with length {num_stages}, but got {block_type}") + if not isinstance(norm, (str, list)) or (isinstance(norm, list) and len(norm) != num_stages): + raise ValueError(f"norm should be either a str or a list of str with length {num_stages}, but got {norm}") + if not isinstance(act, (str, list)) or (isinstance(act, list) and len(act) != num_stages): + raise ValueError(f"act should be either a str or a list of str with length {num_stages}, but got {act}") self.project_in = build_decoder_project_in_block( in_channels=latent_channels, From ea604a4dc2dd944a23ce8e15ee996412df240f5a Mon Sep 17 00:00:00 2001 From: Junyu Chen Date: Wed, 13 Nov 2024 21:23:14 -0800 Subject: [PATCH 016/141] update ResBlock --- src/diffusers/models/autoencoders/dc_ae.py | 46 +++++++++++----------- 1 file changed, 24 insertions(+), 22 deletions(-) diff --git a/src/diffusers/models/autoencoders/dc_ae.py b/src/diffusers/models/autoencoders/dc_ae.py index b488aa4b1bc2..329a75a2bfe4 100644 --- a/src/diffusers/models/autoencoders/dc_ae.py +++ b/src/diffusers/models/autoencoders/dc_ae.py @@ -14,6 +14,7 @@ # limitations under the License. from typing import Any, Optional, Callable, Union +from collections import OrderedDict import torch import torch.nn as nn @@ -169,28 +170,30 @@ def __init__( super().__init__() mid_channels = round(in_channels * expand_ratio) if mid_channels is None else mid_channels - self.conv1 = ConvLayer( - in_channels, - mid_channels, - kernel_size, - stride, - use_bias=use_bias[0], - norm=norm[0], - act_func=act_func[0], - ) - self.conv2 = ConvLayer( - mid_channels, - out_channels, - kernel_size, - 1, - use_bias=use_bias[1], - norm=norm[1], - act_func=act_func[1], - ) + self.main = nn.Sequential(OrderedDict([ + ("conv1", ConvLayer( + in_channels, + mid_channels, + kernel_size, + stride, + use_bias=use_bias[0], + norm=norm[0], + act_func=act_func[0], + )), + ("conv2", ConvLayer( + mid_channels, + out_channels, + kernel_size, + 1, + use_bias=use_bias[1], + norm=norm[1], + act_func=act_func[1], + )), + ])) + self.shortcut = nn.Identity() def forward(self, x: torch.Tensor) -> torch.Tensor: - x = self.conv1(x) - x = self.conv2(x) + x = self.main(x) + self.shortcut(x) return x @@ -448,7 +451,7 @@ def build_block( ) -> nn.Module: if block_type == "ResBlock": assert in_channels == out_channels - main_block = ResBlock( + block = ResBlock( in_channels=in_channels, out_channels=out_channels, kernel_size=3, @@ -457,7 +460,6 @@ def build_block( norm=(None, norm), act_func=(act, None), ) - block = ResidualBlock(main_block, nn.Identity()) elif block_type == "EViTGLU": assert in_channels == out_channels block = EfficientViTBlock(in_channels, norm=norm, act_func=act, local_module="GLUMBConv", scales=()) From 80dce027cb15fcc30cec1226c3714c5a53407b66 Mon Sep 17 00:00:00 2001 From: Junyu Chen Date: Wed, 13 Nov 2024 21:29:45 -0800 Subject: [PATCH 017/141] remove contents within super().__init__ --- src/diffusers/models/autoencoders/dc_ae.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/diffusers/models/autoencoders/dc_ae.py b/src/diffusers/models/autoencoders/dc_ae.py index 329a75a2bfe4..571b5a180aac 100644 --- a/src/diffusers/models/autoencoders/dc_ae.py +++ b/src/diffusers/models/autoencoders/dc_ae.py @@ -67,7 +67,7 @@ def __init__( norm="bn2d", act_func="relu", ): - super(ConvLayer, self).__init__() + super().__init__() padding = kernel_size // 2 padding *= dilation @@ -357,7 +357,7 @@ def __init__( context_module: str = "LiteMLA", local_module: str = "MBConv", ): - super(EfficientViTBlock, self).__init__() + super().__init__() if context_module == "LiteMLA": self.context_module = ResidualBlock( LiteMLA( @@ -406,7 +406,7 @@ def __init__( post_act=None, pre_norm: Optional[nn.Module] = None, ): - super(ResidualBlock, self).__init__() + super().__init__() self.pre_norm = pre_norm self.main = main @@ -433,7 +433,7 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: class OpSequential(nn.Module): def __init__(self, op_list: list[Optional[nn.Module]]): - super(OpSequential, self).__init__() + super().__init__() valid_op_list = [] for op in op_list: if op is not None: From 1752afdda982e14e6bc0adeec28084f602636a46 Mon Sep 17 00:00:00 2001 From: Junsong Chen Date: Sat, 16 Nov 2024 17:32:06 +0800 Subject: [PATCH 018/141] Update src/diffusers/models/autoencoders/dc_ae.py Co-authored-by: YiYi Xu --- src/diffusers/models/autoencoders/dc_ae.py | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/src/diffusers/models/autoencoders/dc_ae.py b/src/diffusers/models/autoencoders/dc_ae.py index 571b5a180aac..e78e0fc2a231 100644 --- a/src/diffusers/models/autoencoders/dc_ae.py +++ b/src/diffusers/models/autoencoders/dc_ae.py @@ -41,16 +41,6 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: return x -def build_norm(name: Optional[str]="bn2d", num_features: Optional[int]=None) -> Optional[nn.Module]: - if name is None: - norm = None - elif name == "rms2d": - norm = RMSNorm2d(normalized_shape=num_features) - elif name == "bn2d": - norm = BatchNorm2d(num_features=num_features) - else: - raise ValueError(f"norm {name} is not supported") - return norm class ConvLayer(nn.Module): From 883bcf4f81b8dd20fe1bd58d93458472ee817655 Mon Sep 17 00:00:00 2001 From: Junyu Chen Date: Sat, 16 Nov 2024 01:40:48 -0800 Subject: [PATCH 019/141] remove opsequential --- src/diffusers/models/autoencoders/dc_ae.py | 67 +++++++++------------- 1 file changed, 28 insertions(+), 39 deletions(-) diff --git a/src/diffusers/models/autoencoders/dc_ae.py b/src/diffusers/models/autoencoders/dc_ae.py index 571b5a180aac..11f60b9bb06f 100644 --- a/src/diffusers/models/autoencoders/dc_ae.py +++ b/src/diffusers/models/autoencoders/dc_ae.py @@ -431,21 +431,6 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: return res -class OpSequential(nn.Module): - def __init__(self, op_list: list[Optional[nn.Module]]): - super().__init__() - valid_op_list = [] - for op in op_list: - if op is not None: - valid_op_list.append(op) - self.op_list = nn.ModuleList(valid_op_list) - - def forward(self, x: torch.Tensor) -> torch.Tensor: - for op in self.op_list: - x = op(x) - return x - - def build_block( block_type: str, in_channels: int, out_channels: int, norm: Optional[str], act: Optional[str] ) -> nn.Module: @@ -557,21 +542,22 @@ def build_encoder_project_in_block(in_channels: int, out_channels: int, factor: def build_encoder_project_out_block( in_channels: int, out_channels: int, norm: Optional[str], act: Optional[str], shortcut: Optional[str] ): - block = OpSequential( - [ - build_norm(norm), - get_activation(act) if act is not None else None, - ConvLayer( - in_channels=in_channels, - out_channels=out_channels, - kernel_size=3, - stride=1, - use_bias=True, - norm=None, - act_func=None, - ), - ] - ) + layers = [] + if norm is not None: + layers.append(build_norm(norm)) + if act is not None: + layers.append(get_activation(act)) + layers.append(ConvLayer( + in_channels=in_channels, + out_channels=out_channels, + kernel_size=3, + stride=1, + use_bias=True, + norm=None, + act_func=None, + )) + block = nn.Sequential(OrderedDict([("op_list", nn.Sequential(*layers))])) + if shortcut is None: pass elif shortcut == "averaging": @@ -609,10 +595,12 @@ def build_decoder_project_in_block(in_channels: int, out_channels: int, shortcut def build_decoder_project_out_block( in_channels: int, out_channels: int, factor: int, upsample_block_type: str, norm: Optional[str], act: Optional[str] ): - layers: list[nn.Module] = [ - build_norm(norm, in_channels), - get_activation(act) if act is not None else None, - ] + layers: list[nn.Module] = [] + if norm is not None: + layers.append(build_norm(norm, in_channels)) + if act is not None: + layers.append(get_activation(act)) + if factor == 1: layers.append( ConvLayer( @@ -633,7 +621,8 @@ def build_decoder_project_out_block( ) else: raise ValueError(f"upsample factor {factor} is not supported for decoder project out") - return OpSequential(layers) + block = nn.Sequential(OrderedDict([("op_list", nn.Sequential(*layers))])) + return block class Encoder(nn.Module): @@ -671,7 +660,7 @@ def __init__( downsample_block_type=downsample_block_type, ) - self.stages: list[OpSequential] = [] + self.stages: list[nn.Module] = [] for stage_id, (width, depth) in enumerate(zip(width_list, depth_list)): stage_block_type = block_type[stage_id] if isinstance(block_type, list) else block_type stage = build_stage_main( @@ -685,7 +674,7 @@ def __init__( shortcut=downsample_shortcut, ) stage.append(downsample_block) - self.stages.append(OpSequential(stage)) + self.stages.append(nn.Sequential(OrderedDict([("op_list", nn.Sequential(*stage))]))) self.stages = nn.ModuleList(self.stages) self.project_out = build_encoder_project_out_block( @@ -743,7 +732,7 @@ def __init__( shortcut=in_shortcut, ) - self.stages: list[OpSequential] = [] + self.stages: list[nn.Module] = [] for stage_id, (width, depth) in reversed(list(enumerate(zip(width_list, depth_list)))): stage = [] if stage_id < num_stages - 1 and depth > 0: @@ -770,7 +759,7 @@ def __init__( ), ) ) - self.stages.insert(0, OpSequential(stage)) + self.stages.insert(0, nn.Sequential(OrderedDict([("op_list", nn.Sequential(*stage))]))) self.stages = nn.ModuleList(self.stages) self.project_out = build_decoder_project_out_block( From 96e844b7866e912613a4d078f7962b70a08cd100 Mon Sep 17 00:00:00 2001 From: Junyu Chen Date: Sat, 16 Nov 2024 01:52:14 -0800 Subject: [PATCH 020/141] update other blocks to support the removal of build_norm --- src/diffusers/models/autoencoders/dc_ae.py | 35 ++++++++++++++++++---- 1 file changed, 29 insertions(+), 6 deletions(-) diff --git a/src/diffusers/models/autoencoders/dc_ae.py b/src/diffusers/models/autoencoders/dc_ae.py index 958ed1bb1963..2421c1d98684 100644 --- a/src/diffusers/models/autoencoders/dc_ae.py +++ b/src/diffusers/models/autoencoders/dc_ae.py @@ -73,7 +73,14 @@ def __init__( groups=groups, bias=use_bias, ) - self.norm = build_norm(norm, num_features=out_channels) + if norm is None: + self.norm = None + elif norm == "rms2d": + self.norm = RMSNorm2d(normalized_shape=out_channels) + elif norm == "bn2d": + self.norm = BatchNorm2d(num_features=out_channels) + else: + raise ValueError(f"norm {norm} is not supported") self.act = get_activation(act_func) if act_func is not None else None def forward(self, x: torch.Tensor) -> torch.Tensor: @@ -532,9 +539,17 @@ def build_encoder_project_in_block(in_channels: int, out_channels: int, factor: def build_encoder_project_out_block( in_channels: int, out_channels: int, norm: Optional[str], act: Optional[str], shortcut: Optional[str] ): - layers = [] - if norm is not None: - layers.append(build_norm(norm)) + layers: list[nn.Module] = [] + + if norm is None: + pass + elif norm == "rms2d": + layers.append(RMSNorm2d(normalized_shape=in_channels)) + elif norm == "bn2d": + layers.append(BatchNorm2d(num_features=in_channels)) + else: + raise ValueError(f"norm {norm} is not supported") + if act is not None: layers.append(get_activation(act)) layers.append(ConvLayer( @@ -586,8 +601,16 @@ def build_decoder_project_out_block( in_channels: int, out_channels: int, factor: int, upsample_block_type: str, norm: Optional[str], act: Optional[str] ): layers: list[nn.Module] = [] - if norm is not None: - layers.append(build_norm(norm, in_channels)) + + if norm is None: + pass + elif norm == "rms2d": + layers.append(RMSNorm2d(normalized_shape=in_channels)) + elif norm == "bn2d": + layers.append(BatchNorm2d(num_features=in_channels)) + else: + raise ValueError(f"norm {norm} is not supported") + if act is not None: layers.append(get_activation(act)) From 7ce9ff2fe0707d23065fef351990c5e56b001992 Mon Sep 17 00:00:00 2001 From: Junyu Chen Date: Sat, 16 Nov 2024 05:48:28 -0800 Subject: [PATCH 021/141] remove build encoder/decoder project in/out --- src/diffusers/models/autoencoders/dc_ae.py | 248 +++++++++------------ 1 file changed, 104 insertions(+), 144 deletions(-) diff --git a/src/diffusers/models/autoencoders/dc_ae.py b/src/diffusers/models/autoencoders/dc_ae.py index 2421c1d98684..93928eec6fdf 100644 --- a/src/diffusers/models/autoencoders/dc_ae.py +++ b/src/diffusers/models/autoencoders/dc_ae.py @@ -41,8 +41,6 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: return x - - class ConvLayer(nn.Module): def __init__( self, @@ -519,125 +517,6 @@ def build_upsample_block(block_type: str, in_channels: int, out_channels: int, s return block -def build_encoder_project_in_block(in_channels: int, out_channels: int, factor: int, downsample_block_type: str): - if factor == 1: - block = nn.Conv2d( - in_channels=in_channels, - out_channels=out_channels, - kernel_size=3, - padding=1, - ) - elif factor == 2: - block = build_downsample_block( - block_type=downsample_block_type, in_channels=in_channels, out_channels=out_channels, shortcut=None - ) - else: - raise ValueError(f"downsample factor {factor} is not supported for encoder project in") - return block - - -def build_encoder_project_out_block( - in_channels: int, out_channels: int, norm: Optional[str], act: Optional[str], shortcut: Optional[str] -): - layers: list[nn.Module] = [] - - if norm is None: - pass - elif norm == "rms2d": - layers.append(RMSNorm2d(normalized_shape=in_channels)) - elif norm == "bn2d": - layers.append(BatchNorm2d(num_features=in_channels)) - else: - raise ValueError(f"norm {norm} is not supported") - - if act is not None: - layers.append(get_activation(act)) - layers.append(ConvLayer( - in_channels=in_channels, - out_channels=out_channels, - kernel_size=3, - stride=1, - use_bias=True, - norm=None, - act_func=None, - )) - block = nn.Sequential(OrderedDict([("op_list", nn.Sequential(*layers))])) - - if shortcut is None: - pass - elif shortcut == "averaging": - shortcut_block = PixelUnshuffleChannelAveragingDownsample2D( - in_channels=in_channels, out_channels=out_channels, factor=1 - ) - block = ResidualBlock(block, shortcut_block) - else: - raise ValueError(f"shortcut {shortcut} is not supported for encoder project out") - return block - - -def build_decoder_project_in_block(in_channels: int, out_channels: int, shortcut: Optional[str]): - block = ConvLayer( - in_channels=in_channels, - out_channels=out_channels, - kernel_size=3, - stride=1, - use_bias=True, - norm=None, - act_func=None, - ) - if shortcut is None: - pass - elif shortcut == "duplicating": - shortcut_block = ChannelDuplicatingPixelUnshuffleUpsample2D( - in_channels=in_channels, out_channels=out_channels, factor=1 - ) - block = ResidualBlock(block, shortcut_block) - else: - raise ValueError(f"shortcut {shortcut} is not supported for decoder project in") - return block - - -def build_decoder_project_out_block( - in_channels: int, out_channels: int, factor: int, upsample_block_type: str, norm: Optional[str], act: Optional[str] -): - layers: list[nn.Module] = [] - - if norm is None: - pass - elif norm == "rms2d": - layers.append(RMSNorm2d(normalized_shape=in_channels)) - elif norm == "bn2d": - layers.append(BatchNorm2d(num_features=in_channels)) - else: - raise ValueError(f"norm {norm} is not supported") - - if act is not None: - layers.append(get_activation(act)) - - if factor == 1: - layers.append( - ConvLayer( - in_channels=in_channels, - out_channels=out_channels, - kernel_size=3, - stride=1, - use_bias=True, - norm=None, - act_func=None, - ) - ) - elif factor == 2: - layers.append( - build_upsample_block( - block_type=upsample_block_type, in_channels=in_channels, out_channels=out_channels, shortcut=None - ) - ) - else: - raise ValueError(f"upsample factor {factor} is not supported for decoder project out") - block = nn.Sequential(OrderedDict([("op_list", nn.Sequential(*layers))])) - return block - - class Encoder(nn.Module): def __init__( self, @@ -665,14 +544,23 @@ def __init__( raise ValueError(f"len(depth_list) {len(depth_list)} and len(width_list) {len(width_list)} should be equal to num_stages {num_stages}") if not isinstance(block_type, (str, list)) or (isinstance(block_type, list) and len(block_type) != num_stages): raise ValueError(f"block_type should be either a str or a list of str with length {num_stages}, but got {block_type}") + + # project in + if depth_list[0] > 0: + self.project_in = nn.Conv2d( + in_channels=in_channels, + out_channels=width_list[0], + kernel_size=3, + padding=1, + ) + elif depth_list[1] > 0: + self.project_in = build_downsample_block( + block_type=downsample_block_type, in_channels=in_channels, out_channels=width_list[1], shortcut=None + ) + else: + raise ValueError(f"depth list {depth_list} is not supported for encoder project in") - self.project_in = build_encoder_project_in_block( - in_channels=in_channels, - out_channels=width_list[0] if depth_list[0] > 0 else width_list[1], - factor=1 if depth_list[0] > 0 else 2, - downsample_block_type=downsample_block_type, - ) - + # stages self.stages: list[nn.Module] = [] for stage_id, (width, depth) in enumerate(zip(width_list, depth_list)): stage_block_type = block_type[stage_id] if isinstance(block_type, list) else block_type @@ -690,13 +578,39 @@ def __init__( self.stages.append(nn.Sequential(OrderedDict([("op_list", nn.Sequential(*stage))]))) self.stages = nn.ModuleList(self.stages) - self.project_out = build_encoder_project_out_block( + # project out + project_out_layers: list[nn.Module] = [] + if out_norm is None: + pass + elif out_norm == "rms2d": + project_out_layers.append(RMSNorm2d(normalized_shape=width_list[-1])) + elif out_norm == "bn2d": + project_out_layers.append(BatchNorm2d(num_features=width_list[-1])) + else: + raise ValueError(f"norm {out_norm} is not supported for encoder project out") + if out_act is not None: + project_out_layers.append(get_activation(out_act)) + project_out_out_channels = 2 * latent_channels if double_latent else latent_channels + project_out_layers.append(ConvLayer( in_channels=width_list[-1], - out_channels=2 * latent_channels if double_latent else latent_channels, - norm=out_norm, - act=out_act, - shortcut=out_shortcut, - ) + out_channels=project_out_out_channels, + kernel_size=3, + stride=1, + use_bias=True, + norm=None, + act_func=None, + )) + project_out_block = nn.Sequential(OrderedDict([("op_list", nn.Sequential(*project_out_layers))])) + if out_shortcut is None: + pass + elif out_shortcut == "averaging": + shortcut_block = PixelUnshuffleChannelAveragingDownsample2D( + in_channels=width_list[-1], out_channels=project_out_out_channels, factor=1 + ) + project_out_block = ResidualBlock(project_out_block, shortcut_block) + else: + raise ValueError(f"shortcut {out_shortcut} is not supported for encoder project out") + self.project_out = project_out_block def forward(self, x: torch.Tensor) -> torch.Tensor: x = self.project_in(x) @@ -739,12 +653,28 @@ def __init__( if not isinstance(act, (str, list)) or (isinstance(act, list) and len(act) != num_stages): raise ValueError(f"act should be either a str or a list of str with length {num_stages}, but got {act}") - self.project_in = build_decoder_project_in_block( + # project in + project_in_block = ConvLayer( in_channels=latent_channels, out_channels=width_list[-1], - shortcut=in_shortcut, + kernel_size=3, + stride=1, + use_bias=True, + norm=None, + act_func=None, ) + if in_shortcut is None: + pass + elif in_shortcut == "duplicating": + shortcut_block = ChannelDuplicatingPixelUnshuffleUpsample2D( + in_channels=latent_channels, out_channels=width_list[-1], factor=1 + ) + project_in_block = ResidualBlock(project_in_block, shortcut_block) + else: + raise ValueError(f"shortcut {in_shortcut} is not supported for decoder project in") + self.project_in = project_in_block + # stages self.stages: list[nn.Module] = [] for stage_id, (width, depth) in reversed(list(enumerate(zip(width_list, depth_list)))): stage = [] @@ -775,14 +705,44 @@ def __init__( self.stages.insert(0, nn.Sequential(OrderedDict([("op_list", nn.Sequential(*stage))]))) self.stages = nn.ModuleList(self.stages) - self.project_out = build_decoder_project_out_block( - in_channels=width_list[0] if depth_list[0] > 0 else width_list[1], - out_channels=in_channels, - factor=1 if depth_list[0] > 0 else 2, - upsample_block_type=upsample_block_type, - norm=out_norm, - act=out_act, - ) + # project out + project_out_layers: list[nn.Module] = [] + if depth_list[0] > 0: + project_out_in_channels = width_list[0] + elif depth_list[1] > 0: + project_out_in_channels = width_list[1] + else: + raise ValueError(f"depth list {depth_list} is not supported for decoder project out") + if out_norm is None: + pass + elif out_norm == "rms2d": + project_out_layers.append(RMSNorm2d(normalized_shape=project_out_in_channels)) + elif out_norm == "bn2d": + project_out_layers.append(BatchNorm2d(num_features=project_out_in_channels)) + else: + raise ValueError(f"norm {out_norm} is not supported for decoder project out") + project_out_layers.append(get_activation(out_act)) + if depth_list[0] > 0: + project_out_layers.append( + ConvLayer( + in_channels=project_out_in_channels, + out_channels=in_channels, + kernel_size=3, + stride=1, + use_bias=True, + norm=None, + act_func=None, + ) + ) + elif depth_list[1] > 0: + project_out_layers.append( + build_upsample_block( + block_type=upsample_block_type, in_channels=project_out_in_channels, out_channels=in_channels, shortcut=None + ) + ) + else: + raise ValueError(f"depth list {depth_list} is not supported for decoder project out") + self.project_out = nn.Sequential(OrderedDict([("op_list", nn.Sequential(*project_out_layers))])) def forward(self, x: torch.Tensor) -> torch.Tensor: x = self.project_in(x) From cab56b1657066edb61aa86134e97081068667a86 Mon Sep 17 00:00:00 2001 From: Junyu Chen Date: Sat, 16 Nov 2024 06:42:59 -0800 Subject: [PATCH 022/141] remove inheritance of RMSNorm2d from LayerNorm --- src/diffusers/models/autoencoders/dc_ae.py | 167 ++++++++++++--------- 1 file changed, 95 insertions(+), 72 deletions(-) diff --git a/src/diffusers/models/autoencoders/dc_ae.py b/src/diffusers/models/autoencoders/dc_ae.py index 93928eec6fdf..6bc16262f13e 100644 --- a/src/diffusers/models/autoencoders/dc_ae.py +++ b/src/diffusers/models/autoencoders/dc_ae.py @@ -33,7 +33,31 @@ from .vae import DecoderOutput -class RMSNorm2d(nn.LayerNorm): +class RMSNorm2d(nn.Module): + def __init__(self, num_features: int, eps: float = 1e-5, elementwise_affine: bool = True, bias: bool = True, device=None, dtype=None) -> None: + factory_kwargs = {'device': device, 'dtype': dtype} + super().__init__() + self.num_features = num_features + self.eps = eps + self.elementwise_affine = elementwise_affine + if self.elementwise_affine: + self.weight = torch.nn.parameter.Parameter(torch.empty(self.num_features, **factory_kwargs)) + if bias: + self.bias = torch.nn.parameter.Parameter(torch.empty(self.num_features, **factory_kwargs)) + else: + self.register_parameter('bias', None) + else: + self.register_parameter('weight', None) + self.register_parameter('bias', None) + + self.reset_parameters() + + def reset_parameters(self) -> None: + if self.elementwise_affine: + torch.nn.init.ones_(self.weight) + if self.bias is not None: + torch.nn.init.zeros_(self.bias) + def forward(self, x: torch.Tensor) -> torch.Tensor: x = (x / torch.sqrt(torch.square(x.float()).mean(dim=1, keepdim=True) + self.eps)).to(x.dtype) if self.elementwise_affine: @@ -74,7 +98,7 @@ def __init__( if norm is None: self.norm = None elif norm == "rms2d": - self.norm = RMSNorm2d(normalized_shape=out_channels) + self.norm = RMSNorm2d(num_features=out_channels) elif norm == "bn2d": self.norm = BatchNorm2d(num_features=out_channels) else: @@ -469,54 +493,6 @@ def build_stage_main( return stage -def build_downsample_block(block_type: str, in_channels: int, out_channels: int, shortcut: Optional[str]) -> nn.Module: - if block_type == "Conv": - block = nn.Conv2d( - in_channels=in_channels, - out_channels=out_channels, - kernel_size=3, - stride=2, - padding=1, - ) - elif block_type == "ConvPixelUnshuffle": - block = ConvPixelUnshuffleDownsample2D( - in_channels=in_channels, out_channels=out_channels, kernel_size=3, factor=2 - ) - else: - raise ValueError(f"block_type {block_type} is not supported for downsampling") - if shortcut is None: - pass - elif shortcut == "averaging": - shortcut_block = PixelUnshuffleChannelAveragingDownsample2D( - in_channels=in_channels, out_channels=out_channels, factor=2 - ) - block = ResidualBlock(block, shortcut_block) - else: - raise ValueError(f"shortcut {shortcut} is not supported for downsample") - return block - - -def build_upsample_block(block_type: str, in_channels: int, out_channels: int, shortcut: Optional[str]) -> nn.Module: - if block_type == "ConvPixelShuffle": - block = ConvPixelShuffleUpsample2D( - in_channels=in_channels, out_channels=out_channels, kernel_size=3, factor=2 - ) - elif block_type == "InterpolateConv": - block = Upsample2D(channels=in_channels, use_conv=True, out_channels=out_channels) - else: - raise ValueError(f"block_type {block_type} is not supported for upsampling") - if shortcut is None: - pass - elif shortcut == "duplicating": - shortcut_block = ChannelDuplicatingPixelUnshuffleUpsample2D( - in_channels=in_channels, out_channels=out_channels, factor=2 - ) - block = ResidualBlock(block, shortcut_block) - else: - raise ValueError(f"shortcut {shortcut} is not supported for upsample") - return block - - class Encoder(nn.Module): def __init__( self, @@ -547,18 +523,30 @@ def __init__( # project in if depth_list[0] > 0: - self.project_in = nn.Conv2d( + project_in_block = nn.Conv2d( in_channels=in_channels, out_channels=width_list[0], kernel_size=3, padding=1, ) elif depth_list[1] > 0: - self.project_in = build_downsample_block( - block_type=downsample_block_type, in_channels=in_channels, out_channels=width_list[1], shortcut=None - ) + if downsample_block_type == "Conv": + project_in_block = nn.Conv2d( + in_channels=in_channels, + out_channels=width_list[1], + kernel_size=3, + stride=2, + padding=1, + ) + elif downsample_block_type == "ConvPixelUnshuffle": + project_in_block = ConvPixelUnshuffleDownsample2D( + in_channels=in_channels, out_channels=width_list[1], kernel_size=3, factor=2 + ) + else: + raise ValueError(f"block_type {downsample_block_type} is not supported for downsampling") else: raise ValueError(f"depth list {depth_list} is not supported for encoder project in") + self.project_in = project_in_block # stages self.stages: list[nn.Module] = [] @@ -568,12 +556,30 @@ def __init__( width=width, depth=depth, block_type=stage_block_type, norm=norm, act=act, input_width=width ) if stage_id < num_stages - 1 and depth > 0: - downsample_block = build_downsample_block( - block_type=downsample_block_type, - in_channels=width, - out_channels=width_list[stage_id + 1] if downsample_match_channel else width, - shortcut=downsample_shortcut, - ) + downsample_out_channels = width_list[stage_id + 1] if downsample_match_channel else width + if downsample_block_type == "Conv": + downsample_block = nn.Conv2d( + in_channels=width, + out_channels=downsample_out_channels, + kernel_size=3, + stride=2, + padding=1, + ) + elif downsample_block_type == "ConvPixelUnshuffle": + downsample_block = ConvPixelUnshuffleDownsample2D( + in_channels=width, out_channels=downsample_out_channels, kernel_size=3, factor=2 + ) + else: + raise ValueError(f"downsample_block_type {downsample_block_type} is not supported for downsampling") + if downsample_shortcut is None: + pass + elif downsample_shortcut == "averaging": + shortcut_block = PixelUnshuffleChannelAveragingDownsample2D( + in_channels=width, out_channels=downsample_out_channels, factor=2 + ) + downsample_block = ResidualBlock(downsample_block, shortcut_block) + else: + raise ValueError(f"shortcut {downsample_shortcut} is not supported for downsample") stage.append(downsample_block) self.stages.append(nn.Sequential(OrderedDict([("op_list", nn.Sequential(*stage))]))) self.stages = nn.ModuleList(self.stages) @@ -583,7 +589,7 @@ def __init__( if out_norm is None: pass elif out_norm == "rms2d": - project_out_layers.append(RMSNorm2d(normalized_shape=width_list[-1])) + project_out_layers.append(RMSNorm2d(num_features=width_list[-1])) elif out_norm == "bn2d": project_out_layers.append(BatchNorm2d(num_features=width_list[-1])) else: @@ -679,12 +685,24 @@ def __init__( for stage_id, (width, depth) in reversed(list(enumerate(zip(width_list, depth_list)))): stage = [] if stage_id < num_stages - 1 and depth > 0: - upsample_block = build_upsample_block( - block_type=upsample_block_type, - in_channels=width_list[stage_id + 1], - out_channels=width if upsample_match_channel else width_list[stage_id + 1], - shortcut=upsample_shortcut, - ) + upsample_out_channels = width if upsample_match_channel else width_list[stage_id + 1] + if upsample_block_type == "ConvPixelShuffle": + upsample_block = ConvPixelShuffleUpsample2D( + in_channels=width_list[stage_id + 1], out_channels=upsample_out_channels, kernel_size=3, factor=2 + ) + elif upsample_block_type == "InterpolateConv": + upsample_block = Upsample2D(channels=width_list[stage_id + 1], use_conv=True, out_channels=upsample_out_channels) + else: + raise ValueError(f"upsample_block_type {upsample_block_type} is not supported") + if upsample_shortcut is None: + pass + elif upsample_shortcut == "duplicating": + shortcut_block = ChannelDuplicatingPixelUnshuffleUpsample2D( + in_channels=width_list[stage_id + 1], out_channels=upsample_out_channels, factor=2 + ) + upsample_block = ResidualBlock(upsample_block, shortcut_block) + else: + raise ValueError(f"shortcut {upsample_shortcut} is not supported for upsample") stage.append(upsample_block) stage_block_type = block_type[stage_id] if isinstance(block_type, list) else block_type @@ -716,7 +734,7 @@ def __init__( if out_norm is None: pass elif out_norm == "rms2d": - project_out_layers.append(RMSNorm2d(normalized_shape=project_out_in_channels)) + project_out_layers.append(RMSNorm2d(num_features=project_out_in_channels)) elif out_norm == "bn2d": project_out_layers.append(BatchNorm2d(num_features=project_out_in_channels)) else: @@ -735,11 +753,16 @@ def __init__( ) ) elif depth_list[1] > 0: - project_out_layers.append( - build_upsample_block( - block_type=upsample_block_type, in_channels=project_out_in_channels, out_channels=in_channels, shortcut=None + if upsample_block_type == "ConvPixelShuffle": + project_out_conv = ConvPixelShuffleUpsample2D( + in_channels=project_out_in_channels, out_channels=in_channels, kernel_size=3, factor=2 ) - ) + elif upsample_block_type == "InterpolateConv": + project_out_conv = Upsample2D(channels=project_out_in_channels, use_conv=True, out_channels=in_channels) + else: + raise ValueError(f"upsample_block_type {upsample_block_type} is not supported for upsampling") + + project_out_layers.append(project_out_conv) else: raise ValueError(f"depth list {depth_list} is not supported for decoder project out") self.project_out = nn.Sequential(OrderedDict([("op_list", nn.Sequential(*project_out_layers))])) From b42bb54854b1a0e39f94ed472e175285c3723231 Mon Sep 17 00:00:00 2001 From: chenjy2003 <70215701+chenjy2003@users.noreply.github.com> Date: Wed, 20 Nov 2024 19:17:15 +0800 Subject: [PATCH 023/141] remove reset_parameters for RMSNorm2d Co-authored-by: YiYi Xu --- src/diffusers/models/autoencoders/dc_ae.py | 5 ----- 1 file changed, 5 deletions(-) diff --git a/src/diffusers/models/autoencoders/dc_ae.py b/src/diffusers/models/autoencoders/dc_ae.py index 6bc16262f13e..fcb2f4aedaa1 100644 --- a/src/diffusers/models/autoencoders/dc_ae.py +++ b/src/diffusers/models/autoencoders/dc_ae.py @@ -52,11 +52,6 @@ def __init__(self, num_features: int, eps: float = 1e-5, elementwise_affine: boo self.reset_parameters() - def reset_parameters(self) -> None: - if self.elementwise_affine: - torch.nn.init.ones_(self.weight) - if self.bias is not None: - torch.nn.init.zeros_(self.bias) def forward(self, x: torch.Tensor) -> torch.Tensor: x = (x / torch.sqrt(torch.square(x.float()).mean(dim=1, keepdim=True) + self.eps)).to(x.dtype) From 2e04a9967fc6ee144419c036a06cf0ddaf3641e8 Mon Sep 17 00:00:00 2001 From: chenjy2003 <70215701+chenjy2003@users.noreply.github.com> Date: Wed, 20 Nov 2024 19:17:43 +0800 Subject: [PATCH 024/141] remove device and dtype in RMSNorm2d __init__ Co-authored-by: YiYi Xu --- src/diffusers/models/autoencoders/dc_ae.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/diffusers/models/autoencoders/dc_ae.py b/src/diffusers/models/autoencoders/dc_ae.py index fcb2f4aedaa1..112473b16902 100644 --- a/src/diffusers/models/autoencoders/dc_ae.py +++ b/src/diffusers/models/autoencoders/dc_ae.py @@ -34,7 +34,7 @@ class RMSNorm2d(nn.Module): - def __init__(self, num_features: int, eps: float = 1e-5, elementwise_affine: bool = True, bias: bool = True, device=None, dtype=None) -> None: + def __init__(self, num_features: int, eps: float = 1e-5, elementwise_affine: bool = True, bias: bool = True) -> None: factory_kwargs = {'device': device, 'dtype': dtype} super().__init__() self.num_features = num_features From b4f75f22e46bc55e95dd5eed670a7b4e8903aa5d Mon Sep 17 00:00:00 2001 From: Junsong Chen Date: Thu, 21 Nov 2024 13:58:07 +0800 Subject: [PATCH 025/141] Update src/diffusers/models/autoencoders/dc_ae.py Co-authored-by: YiYi Xu --- src/diffusers/models/autoencoders/dc_ae.py | 1 - 1 file changed, 1 deletion(-) diff --git a/src/diffusers/models/autoencoders/dc_ae.py b/src/diffusers/models/autoencoders/dc_ae.py index 112473b16902..e6f02aaacda3 100644 --- a/src/diffusers/models/autoencoders/dc_ae.py +++ b/src/diffusers/models/autoencoders/dc_ae.py @@ -35,7 +35,6 @@ class RMSNorm2d(nn.Module): def __init__(self, num_features: int, eps: float = 1e-5, elementwise_affine: bool = True, bias: bool = True) -> None: - factory_kwargs = {'device': device, 'dtype': dtype} super().__init__() self.num_features = num_features self.eps = eps From c82f828b06374278996a174b375f65a897226a5d Mon Sep 17 00:00:00 2001 From: Junsong Chen Date: Thu, 21 Nov 2024 13:58:16 +0800 Subject: [PATCH 026/141] Update src/diffusers/models/autoencoders/dc_ae.py Co-authored-by: YiYi Xu --- src/diffusers/models/autoencoders/dc_ae.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/diffusers/models/autoencoders/dc_ae.py b/src/diffusers/models/autoencoders/dc_ae.py index e6f02aaacda3..2962d097933b 100644 --- a/src/diffusers/models/autoencoders/dc_ae.py +++ b/src/diffusers/models/autoencoders/dc_ae.py @@ -40,7 +40,7 @@ def __init__(self, num_features: int, eps: float = 1e-5, elementwise_affine: boo self.eps = eps self.elementwise_affine = elementwise_affine if self.elementwise_affine: - self.weight = torch.nn.parameter.Parameter(torch.empty(self.num_features, **factory_kwargs)) + self.weight = torch.nn.parameter.Parameter(torch.empty(self.num_features)) if bias: self.bias = torch.nn.parameter.Parameter(torch.empty(self.num_features, **factory_kwargs)) else: From 22ea5fd7f7adb89604db4713c63497eb71ecf5ba Mon Sep 17 00:00:00 2001 From: Junsong Chen Date: Thu, 21 Nov 2024 13:58:24 +0800 Subject: [PATCH 027/141] Update src/diffusers/models/autoencoders/dc_ae.py Co-authored-by: YiYi Xu --- src/diffusers/models/autoencoders/dc_ae.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/diffusers/models/autoencoders/dc_ae.py b/src/diffusers/models/autoencoders/dc_ae.py index 2962d097933b..245bf1052d01 100644 --- a/src/diffusers/models/autoencoders/dc_ae.py +++ b/src/diffusers/models/autoencoders/dc_ae.py @@ -42,7 +42,7 @@ def __init__(self, num_features: int, eps: float = 1e-5, elementwise_affine: boo if self.elementwise_affine: self.weight = torch.nn.parameter.Parameter(torch.empty(self.num_features)) if bias: - self.bias = torch.nn.parameter.Parameter(torch.empty(self.num_features, **factory_kwargs)) + self.bias = torch.nn.parameter.Parameter(torch.empty(self.num_features)) else: self.register_parameter('bias', None) else: From 4f5cbb43805cc62eefe6d54e01033aa154bd0a14 Mon Sep 17 00:00:00 2001 From: Junyu Chen Date: Tue, 26 Nov 2024 04:24:24 -0800 Subject: [PATCH 028/141] remove op_list & build_block --- src/diffusers/models/autoencoders/dc_ae.py | 111 +++++++++------------ 1 file changed, 49 insertions(+), 62 deletions(-) diff --git a/src/diffusers/models/autoencoders/dc_ae.py b/src/diffusers/models/autoencoders/dc_ae.py index 245bf1052d01..2e0230314a7c 100644 --- a/src/diffusers/models/autoencoders/dc_ae.py +++ b/src/diffusers/models/autoencoders/dc_ae.py @@ -49,9 +49,6 @@ def __init__(self, num_features: int, eps: float = 1e-5, elementwise_affine: boo self.register_parameter('weight', None) self.register_parameter('bias', None) - self.reset_parameters() - - def forward(self, x: torch.Tensor) -> torch.Tensor: x = (x / torch.sqrt(torch.square(x.float()).mean(dim=1, keepdim=True) + self.eps)).to(x.dtype) if self.elementwise_affine: @@ -183,30 +180,28 @@ def __init__( super().__init__() mid_channels = round(in_channels * expand_ratio) if mid_channels is None else mid_channels - self.main = nn.Sequential(OrderedDict([ - ("conv1", ConvLayer( - in_channels, - mid_channels, - kernel_size, - stride, - use_bias=use_bias[0], - norm=norm[0], - act_func=act_func[0], - )), - ("conv2", ConvLayer( - mid_channels, - out_channels, - kernel_size, - 1, - use_bias=use_bias[1], - norm=norm[1], - act_func=act_func[1], - )), - ])) + self.conv1 = ConvLayer( + in_channels, + mid_channels, + kernel_size, + stride, + use_bias=use_bias[0], + norm=norm[0], + act_func=act_func[0], + ) + self.conv2 = ConvLayer( + mid_channels, + out_channels, + kernel_size, + 1, + use_bias=use_bias[1], + norm=norm[1], + act_func=act_func[1], + ) self.shortcut = nn.Identity() def forward(self, x: torch.Tensor) -> torch.Tensor: - x = self.main(x) + self.shortcut(x) + x = self.conv2(self.conv1(x)) + x return x @@ -444,31 +439,6 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: return res -def build_block( - block_type: str, in_channels: int, out_channels: int, norm: Optional[str], act: Optional[str] -) -> nn.Module: - if block_type == "ResBlock": - assert in_channels == out_channels - block = ResBlock( - in_channels=in_channels, - out_channels=out_channels, - kernel_size=3, - stride=1, - use_bias=(True, False), - norm=(None, norm), - act_func=(act, None), - ) - elif block_type == "EViTGLU": - assert in_channels == out_channels - block = EfficientViTBlock(in_channels, norm=norm, act_func=act, local_module="GLUMBConv", scales=()) - elif block_type == "EViTS5GLU": - assert in_channels == out_channels - block = EfficientViTBlock(in_channels, norm=norm, act_func=act, local_module="GLUMBConv", scales=(5,)) - else: - raise ValueError(f"block_type {block_type} is not supported") - return block - - def build_stage_main( width: int, depth: int, block_type: str | list[str], norm: str, act: str, input_width: int ) -> list[nn.Module]: @@ -476,13 +446,30 @@ def build_stage_main( stage = [] for d in range(depth): current_block_type = block_type[d] if isinstance(block_type, list) else block_type - block = build_block( - block_type=current_block_type, - in_channels=width if d > 0 else input_width, - out_channels=width, - norm=norm, - act=act, - ) + + in_channels = width if d > 0 else input_width + out_channels = width + + if current_block_type == "ResBlock": + assert in_channels == out_channels + block = ResBlock( + in_channels=in_channels, + out_channels=out_channels, + kernel_size=3, + stride=1, + use_bias=(True, False), + norm=(None, norm), + act_func=(act, None), + ) + elif current_block_type == "EViTGLU": + assert in_channels == out_channels + block = EfficientViTBlock(in_channels, norm=norm, act_func=act, local_module="GLUMBConv", scales=()) + elif current_block_type == "EViTS5GLU": + assert in_channels == out_channels + block = EfficientViTBlock(in_channels, norm=norm, act_func=act, local_module="GLUMBConv", scales=(5,)) + else: + raise ValueError(f"block_type {current_block_type} is not supported") + stage.append(block) return stage @@ -575,7 +562,7 @@ def __init__( else: raise ValueError(f"shortcut {downsample_shortcut} is not supported for downsample") stage.append(downsample_block) - self.stages.append(nn.Sequential(OrderedDict([("op_list", nn.Sequential(*stage))]))) + self.stages.append(nn.Sequential(*stage)) self.stages = nn.ModuleList(self.stages) # project out @@ -600,7 +587,7 @@ def __init__( norm=None, act_func=None, )) - project_out_block = nn.Sequential(OrderedDict([("op_list", nn.Sequential(*project_out_layers))])) + project_out_block = nn.Sequential(*project_out_layers) if out_shortcut is None: pass elif out_shortcut == "averaging": @@ -615,7 +602,7 @@ def __init__( def forward(self, x: torch.Tensor) -> torch.Tensor: x = self.project_in(x) for stage in self.stages: - if len(stage.op_list) == 0: + if len(stage) == 0: continue x = stage(x) x = self.project_out(x) @@ -714,7 +701,7 @@ def __init__( ), ) ) - self.stages.insert(0, nn.Sequential(OrderedDict([("op_list", nn.Sequential(*stage))]))) + self.stages.insert(0, nn.Sequential(*stage)) self.stages = nn.ModuleList(self.stages) # project out @@ -759,12 +746,12 @@ def __init__( project_out_layers.append(project_out_conv) else: raise ValueError(f"depth list {depth_list} is not supported for decoder project out") - self.project_out = nn.Sequential(OrderedDict([("op_list", nn.Sequential(*project_out_layers))])) + self.project_out = nn.Sequential(*project_out_layers) def forward(self, x: torch.Tensor) -> torch.Tensor: x = self.project_in(x) for stage in reversed(self.stages): - if len(stage.op_list) == 0: + if len(stage) == 0: continue x = stage(x) x = self.project_out(x) From 2f6bbad8f0a5379644c3d43a00e817a61afc9055 Mon Sep 17 00:00:00 2001 From: Junyu Chen Date: Tue, 26 Nov 2024 04:36:57 -0800 Subject: [PATCH 029/141] remove build_stage_main --- src/diffusers/models/autoencoders/dc_ae.py | 103 ++++++++++----------- 1 file changed, 48 insertions(+), 55 deletions(-) diff --git a/src/diffusers/models/autoencoders/dc_ae.py b/src/diffusers/models/autoencoders/dc_ae.py index 2e0230314a7c..2b96de5fda02 100644 --- a/src/diffusers/models/autoencoders/dc_ae.py +++ b/src/diffusers/models/autoencoders/dc_ae.py @@ -439,41 +439,6 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: return res -def build_stage_main( - width: int, depth: int, block_type: str | list[str], norm: str, act: str, input_width: int -) -> list[nn.Module]: - assert isinstance(block_type, str) or (isinstance(block_type, list) and depth == len(block_type)) - stage = [] - for d in range(depth): - current_block_type = block_type[d] if isinstance(block_type, list) else block_type - - in_channels = width if d > 0 else input_width - out_channels = width - - if current_block_type == "ResBlock": - assert in_channels == out_channels - block = ResBlock( - in_channels=in_channels, - out_channels=out_channels, - kernel_size=3, - stride=1, - use_bias=(True, False), - norm=(None, norm), - act_func=(act, None), - ) - elif current_block_type == "EViTGLU": - assert in_channels == out_channels - block = EfficientViTBlock(in_channels, norm=norm, act_func=act, local_module="GLUMBConv", scales=()) - elif current_block_type == "EViTS5GLU": - assert in_channels == out_channels - block = EfficientViTBlock(in_channels, norm=norm, act_func=act, local_module="GLUMBConv", scales=(5,)) - else: - raise ValueError(f"block_type {current_block_type} is not supported") - - stage.append(block) - return stage - - class Encoder(nn.Module): def __init__( self, @@ -485,7 +450,6 @@ def __init__( norm: str = "rms2d", act: str = "silu", downsample_block_type: str = "ConvPixelUnshuffle", - downsample_match_channel: bool = True, downsample_shortcut: Optional[str] = "averaging", out_norm: Optional[str] = None, out_act: Optional[str] = None, @@ -533,11 +497,32 @@ def __init__( self.stages: list[nn.Module] = [] for stage_id, (width, depth) in enumerate(zip(width_list, depth_list)): stage_block_type = block_type[stage_id] if isinstance(block_type, list) else block_type - stage = build_stage_main( - width=width, depth=depth, block_type=stage_block_type, norm=norm, act=act, input_width=width - ) + if not (isinstance(stage_block_type, str) or (isinstance(stage_block_type, list) and depth == len(stage_block_type))): + raise ValueError(f"block type {stage_block_type} is not supported for encoder stage {stage_id} with depth {depth}") + stage = [] + # stage main + for d in range(depth): + current_block_type = stage_block_type[d] if isinstance(stage_block_type, list) else stage_block_type + if current_block_type == "ResBlock": + block = ResBlock( + in_channels=width, + out_channels=width, + kernel_size=3, + stride=1, + use_bias=(True, False), + norm=(None, norm), + act_func=(act, None), + ) + elif current_block_type == "EViTGLU": + block = EfficientViTBlock(width, norm=norm, act_func=act, local_module="GLUMBConv", scales=()) + elif current_block_type == "EViTS5GLU": + block = EfficientViTBlock(width, norm=norm, act_func=act, local_module="GLUMBConv", scales=(5,)) + else: + raise ValueError(f"block type {current_block_type} is not supported") + stage.append(block) + # downsample if stage_id < num_stages - 1 and depth > 0: - downsample_out_channels = width_list[stage_id + 1] if downsample_match_channel else width + downsample_out_channels = width_list[stage_id + 1] if downsample_block_type == "Conv": downsample_block = nn.Conv2d( in_channels=width, @@ -621,7 +606,6 @@ def __init__( norm: str | list[str] = "rms2d", act: str | list[str] = "silu", upsample_block_type: str = "ConvPixelShuffle", - upsample_match_channel: bool = True, upsample_shortcut: str = "duplicating", out_norm: str = "rms2d", out_act: str = "relu", @@ -665,8 +649,9 @@ def __init__( self.stages: list[nn.Module] = [] for stage_id, (width, depth) in reversed(list(enumerate(zip(width_list, depth_list)))): stage = [] + # upsample if stage_id < num_stages - 1 and depth > 0: - upsample_out_channels = width if upsample_match_channel else width_list[stage_id + 1] + upsample_out_channels = width if upsample_block_type == "ConvPixelShuffle": upsample_block = ConvPixelShuffleUpsample2D( in_channels=width_list[stage_id + 1], out_channels=upsample_out_channels, kernel_size=3, factor=2 @@ -685,22 +670,30 @@ def __init__( else: raise ValueError(f"shortcut {upsample_shortcut} is not supported for upsample") stage.append(upsample_block) - + # stage main stage_block_type = block_type[stage_id] if isinstance(block_type, list) else block_type stage_norm = norm[stage_id] if isinstance(norm, list) else norm stage_act = act[stage_id] if isinstance(act, list) else act - stage.extend( - build_stage_main( - width=width, - depth=depth, - block_type=stage_block_type, - norm=stage_norm, - act=stage_act, - input_width=( - width if upsample_match_channel else width_list[min(stage_id + 1, num_stages - 1)] - ), - ) - ) + for d in range(depth): + current_block_type = stage_block_type[d] if isinstance(stage_block_type, list) else stage_block_type + if current_block_type == "ResBlock": + block = ResBlock( + in_channels=width, + out_channels=width, + kernel_size=3, + stride=1, + use_bias=(True, False), + norm=(None, stage_norm), + act_func=(stage_act, None), + ) + elif current_block_type == "EViTGLU": + block = EfficientViTBlock(width, norm=stage_norm, act_func=stage_act, local_module="GLUMBConv", scales=()) + elif current_block_type == "EViTS5GLU": + block = EfficientViTBlock(width, norm=stage_norm, act_func=stage_act, local_module="GLUMBConv", scales=(5,)) + else: + raise ValueError(f"block type {current_block_type} is not supported") + stage.append(block) + self.stages.insert(0, nn.Sequential(*stage)) self.stages = nn.ModuleList(self.stages) From 4d3c026622e6ab99698f9eb3c132cd69b51cf3e1 Mon Sep 17 00:00:00 2001 From: Junyu Chen Date: Thu, 28 Nov 2024 01:01:01 -0800 Subject: [PATCH 030/141] change file name to autoencoder_dc --- .../{dc_ae.py => autoencoder_dc.py} | 48 ++++++++----------- 1 file changed, 21 insertions(+), 27 deletions(-) rename src/diffusers/models/autoencoders/{dc_ae.py => autoencoder_dc.py} (96%) diff --git a/src/diffusers/models/autoencoders/dc_ae.py b/src/diffusers/models/autoencoders/autoencoder_dc.py similarity index 96% rename from src/diffusers/models/autoencoders/dc_ae.py rename to src/diffusers/models/autoencoders/autoencoder_dc.py index 2b96de5fda02..27f058472af0 100644 --- a/src/diffusers/models/autoencoders/dc_ae.py +++ b/src/diffusers/models/autoencoders/autoencoder_dc.py @@ -153,15 +153,15 @@ def __init__( ) def forward(self, x: torch.Tensor) -> torch.Tensor: - x = self.inverted_conv(x) - x = self.depth_conv(x) + y = self.inverted_conv(x) + y = self.depth_conv(y) - x, gate = torch.chunk(x, 2, dim=1) + y, gate = torch.chunk(y, 2, dim=1) gate = self.glu_act(gate) - x = x * gate + y = y * gate - x = self.point_conv(x) - return x + y = self.point_conv(y) + return x + y class ResBlock(nn.Module): @@ -349,7 +349,7 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: out = self.relu_quadratic_att(qkv) out = self.proj(out) - return out + return x + out class EfficientViTBlock(nn.Module): @@ -367,30 +367,24 @@ def __init__( ): super().__init__() if context_module == "LiteMLA": - self.context_module = ResidualBlock( - LiteMLA( - in_channels=in_channels, - out_channels=in_channels, - heads_ratio=heads_ratio, - dim=dim, - norm=(None, norm), - scales=scales, - ), - nn.Identity(), + self.context_module = LiteMLA( + in_channels=in_channels, + out_channels=in_channels, + heads_ratio=heads_ratio, + dim=dim, + norm=(None, norm), + scales=scales, ) else: raise ValueError(f"context_module {context_module} is not supported") if local_module == "GLUMBConv": - self.local_module = ResidualBlock( - GLUMBConv( - in_channels=in_channels, - out_channels=in_channels, - expand_ratio=expand_ratio, - use_bias=(True, True, False), - norm=(None, None, norm), - act_func=(act_func, act_func, None), - ), - nn.Identity(), + self.local_module = GLUMBConv( + in_channels=in_channels, + out_channels=in_channels, + expand_ratio=expand_ratio, + use_bias=(True, True, False), + norm=(None, None, norm), + act_func=(act_func, act_func, None), ) else: raise NotImplementedError(f"local_module {local_module} is not supported") From d3d9c8406811595b963e5e38640b03b4834a778f Mon Sep 17 00:00:00 2001 From: Junyu Chen Date: Thu, 28 Nov 2024 01:25:32 -0800 Subject: [PATCH 031/141] move LiteMLA to attention.py --- src/diffusers/models/attention.py | 161 +++++++++++++++- .../models/autoencoders/autoencoder_dc.py | 174 +----------------- src/diffusers/models/normalization.py | 23 +++ 3 files changed, 185 insertions(+), 173 deletions(-) diff --git a/src/diffusers/models/attention.py b/src/diffusers/models/attention.py index 02ed1f965abf..ca6611a8977b 100644 --- a/src/diffusers/models/attention.py +++ b/src/diffusers/models/attention.py @@ -19,10 +19,10 @@ from ..utils import deprecate, logging from ..utils.torch_utils import maybe_allow_in_graph -from .activations import GEGLU, GELU, ApproximateGELU, FP32SiLU, SwiGLU +from .activations import GEGLU, GELU, ApproximateGELU, FP32SiLU, SwiGLU, get_activation from .attention_processor import Attention, JointAttnProcessor2_0 from .embeddings import SinusoidalPositionalEmbedding -from .normalization import AdaLayerNorm, AdaLayerNormContinuous, AdaLayerNormZero, RMSNorm, SD35AdaLayerNormZeroX +from .normalization import AdaLayerNorm, AdaLayerNormContinuous, AdaLayerNormZero, RMSNorm, SD35AdaLayerNormZeroX, RMSNorm2d logger = logging.get_logger(__name__) @@ -1241,3 +1241,160 @@ def forward(self, hidden_states: torch.Tensor, *args, **kwargs) -> torch.Tensor: for module in self.net: hidden_states = module(hidden_states) return hidden_states + + +class DCAELiteMLA(nn.Module): + r"""Lightweight multi-scale linear attention used in DC-AE""" + + def __init__( + self, + in_channels: int, + out_channels: int, + heads: Optional[int] = None, + heads_ratio: float = 1.0, + dim=8, + use_bias=(False, False), + norm=(None, "bn2d"), + act_func=(None, None), + kernel_func="relu", + scales: Tuple[int, ...] = (5,), + eps=1.0e-15, + ): + super().__init__() + self.eps = eps + heads = int(in_channels // dim * heads_ratio) if heads is None else heads + + total_dim = heads * dim + + self.dim = dim + + qkv = [nn.Conv2d(in_channels=in_channels, out_channels=3 * total_dim, kernel_size=1, bias=use_bias[0])] + if norm[0] is None: + pass + elif norm[0] == "rms2d": + qkv.append(RMSNorm2d(num_features=3 * total_dim)) + elif norm[0] == "bn2d": + qkv.append(nn.BatchNorm2d(num_features=3 * total_dim)) + else: + raise ValueError(f"norm {norm[0]} is not supported") + if act_func[0] is not None: + qkv.append(get_activation(act_func[0])) + self.qkv = nn.Sequential(*qkv) + + self.aggreg = nn.ModuleList( + [ + nn.Sequential( + nn.Conv2d( + 3 * total_dim, + 3 * total_dim, + scale, + padding=scale // 2, + groups=3 * total_dim, + bias=use_bias[0], + ), + nn.Conv2d(3 * total_dim, 3 * total_dim, 1, groups=3 * heads, bias=use_bias[0]), + ) + for scale in scales + ] + ) + self.kernel_func = get_activation(kernel_func) + + proj = [nn.Conv2d(in_channels=total_dim * (1 + len(scales)), out_channels=out_channels, kernel_size=1, bias=use_bias[1])] + if norm[1] is None: + pass + elif norm[1] == "rms2d": + proj.append(RMSNorm2d(num_features=out_channels)) + elif norm[1] == "bn2d": + proj.append(nn.BatchNorm2d(num_features=out_channels)) + else: + raise ValueError(f"norm {norm[1]} is not supported") + if act_func[1] is not None: + proj.append(get_activation(act_func[1])) + self.proj = nn.Sequential(*proj) + + def relu_linear_att(self, qkv: torch.Tensor) -> torch.Tensor: + B, _, H, W = list(qkv.size()) + + if qkv.dtype == torch.float16: + qkv = qkv.float() + + qkv = torch.reshape( + qkv, + ( + B, + -1, + 3 * self.dim, + H * W, + ), + ) + q, k, v = ( + qkv[:, :, 0 : self.dim], + qkv[:, :, self.dim : 2 * self.dim], + qkv[:, :, 2 * self.dim :], + ) + + # lightweight linear attention + q = self.kernel_func(q) + k = self.kernel_func(k) + + # linear matmul + trans_k = k.transpose(-1, -2) + + v = F.pad(v, (0, 0, 0, 1), mode="constant", value=1) + vk = torch.matmul(v, trans_k) + out = torch.matmul(vk, q) + if out.dtype == torch.bfloat16: + out = out.float() + out = out[:, :, :-1] / (out[:, :, -1:] + self.eps) + + out = torch.reshape(out, (B, -1, H, W)) + return out + + def relu_quadratic_att(self, qkv: torch.Tensor) -> torch.Tensor: + B, _, H, W = list(qkv.size()) + + qkv = torch.reshape( + qkv, + ( + B, + -1, + 3 * self.dim, + H * W, + ), + ) + q, k, v = ( + qkv[:, :, 0 : self.dim], + qkv[:, :, self.dim : 2 * self.dim], + qkv[:, :, 2 * self.dim :], + ) + + q = self.kernel_func(q) + k = self.kernel_func(k) + + att_map = torch.matmul(k.transpose(-1, -2), q) # b h n n + original_dtype = att_map.dtype + if original_dtype in [torch.float16, torch.bfloat16]: + att_map = att_map.float() + att_map = att_map / (torch.sum(att_map, dim=2, keepdim=True) + self.eps) # b h n n + att_map = att_map.to(original_dtype) + out = torch.matmul(v, att_map) # b h d n + + out = torch.reshape(out, (B, -1, H, W)) + return out + + def forward(self, x: torch.Tensor) -> torch.Tensor: + # generate multi-scale q, k, v + qkv = self.qkv(x) + multi_scale_qkv = [qkv] + for op in self.aggreg: + multi_scale_qkv.append(op(qkv)) + qkv = torch.cat(multi_scale_qkv, dim=1) + + H, W = list(qkv.size())[-2:] + if H * W > self.dim: + out = self.relu_linear_att(qkv).to(qkv.dtype) + else: + out = self.relu_quadratic_att(qkv) + out = self.proj(out) + + return x + out diff --git a/src/diffusers/models/autoencoders/autoencoder_dc.py b/src/diffusers/models/autoencoders/autoencoder_dc.py index 27f058472af0..abb5376f6ba0 100644 --- a/src/diffusers/models/autoencoders/autoencoder_dc.py +++ b/src/diffusers/models/autoencoders/autoencoder_dc.py @@ -27,35 +27,14 @@ from ..modeling_utils import ModelMixin from ..activations import get_activation +from ..normalization import RMSNorm2d from ..downsampling import ConvPixelUnshuffleDownsample2D, PixelUnshuffleChannelAveragingDownsample2D from ..upsampling import ConvPixelShuffleUpsample2D, ChannelDuplicatingPixelUnshuffleUpsample2D, Upsample2D +from ..attention import DCAELiteMLA from .vae import DecoderOutput -class RMSNorm2d(nn.Module): - def __init__(self, num_features: int, eps: float = 1e-5, elementwise_affine: bool = True, bias: bool = True) -> None: - super().__init__() - self.num_features = num_features - self.eps = eps - self.elementwise_affine = elementwise_affine - if self.elementwise_affine: - self.weight = torch.nn.parameter.Parameter(torch.empty(self.num_features)) - if bias: - self.bias = torch.nn.parameter.Parameter(torch.empty(self.num_features)) - else: - self.register_parameter('bias', None) - else: - self.register_parameter('weight', None) - self.register_parameter('bias', None) - - def forward(self, x: torch.Tensor) -> torch.Tensor: - x = (x / torch.sqrt(torch.square(x.float()).mean(dim=1, keepdim=True) + self.eps)).to(x.dtype) - if self.elementwise_affine: - x = x * self.weight.view(1, -1, 1, 1) + self.bias.view(1, -1, 1, 1) - return x - - class ConvLayer(nn.Module): def __init__( self, @@ -205,153 +184,6 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: return x -class LiteMLA(nn.Module): - r"""Lightweight multi-scale linear attention""" - - def __init__( - self, - in_channels: int, - out_channels: int, - heads: Optional[int] = None, - heads_ratio: float = 1.0, - dim=8, - use_bias=(False, False), - norm=(None, "bn2d"), - act_func=(None, None), - kernel_func="relu", - scales: tuple[int, ...] = (5,), - eps=1.0e-15, - ): - super().__init__() - self.eps = eps - heads = int(in_channels // dim * heads_ratio) if heads is None else heads - - total_dim = heads * dim - - self.dim = dim - self.qkv = ConvLayer( - in_channels, - 3 * total_dim, - 1, - use_bias=use_bias[0], - norm=norm[0], - act_func=act_func[0], - ) - self.aggreg = nn.ModuleList( - [ - nn.Sequential( - nn.Conv2d( - 3 * total_dim, - 3 * total_dim, - scale, - padding=scale // 2, - groups=3 * total_dim, - bias=use_bias[0], - ), - nn.Conv2d(3 * total_dim, 3 * total_dim, 1, groups=3 * heads, bias=use_bias[0]), - ) - for scale in scales - ] - ) - self.kernel_func = get_activation(kernel_func) - - self.proj = ConvLayer( - total_dim * (1 + len(scales)), - out_channels, - 1, - use_bias=use_bias[1], - norm=norm[1], - act_func=act_func[1], - ) - - def relu_linear_att(self, qkv: torch.Tensor) -> torch.Tensor: - B, _, H, W = list(qkv.size()) - - if qkv.dtype == torch.float16: - qkv = qkv.float() - - qkv = torch.reshape( - qkv, - ( - B, - -1, - 3 * self.dim, - H * W, - ), - ) - q, k, v = ( - qkv[:, :, 0 : self.dim], - qkv[:, :, self.dim : 2 * self.dim], - qkv[:, :, 2 * self.dim :], - ) - - # lightweight linear attention - q = self.kernel_func(q) - k = self.kernel_func(k) - - # linear matmul - trans_k = k.transpose(-1, -2) - - v = F.pad(v, (0, 0, 0, 1), mode="constant", value=1) - vk = torch.matmul(v, trans_k) - out = torch.matmul(vk, q) - if out.dtype == torch.bfloat16: - out = out.float() - out = out[:, :, :-1] / (out[:, :, -1:] + self.eps) - - out = torch.reshape(out, (B, -1, H, W)) - return out - - def relu_quadratic_att(self, qkv: torch.Tensor) -> torch.Tensor: - B, _, H, W = list(qkv.size()) - - qkv = torch.reshape( - qkv, - ( - B, - -1, - 3 * self.dim, - H * W, - ), - ) - q, k, v = ( - qkv[:, :, 0 : self.dim], - qkv[:, :, self.dim : 2 * self.dim], - qkv[:, :, 2 * self.dim :], - ) - - q = self.kernel_func(q) - k = self.kernel_func(k) - - att_map = torch.matmul(k.transpose(-1, -2), q) # b h n n - original_dtype = att_map.dtype - if original_dtype in [torch.float16, torch.bfloat16]: - att_map = att_map.float() - att_map = att_map / (torch.sum(att_map, dim=2, keepdim=True) + self.eps) # b h n n - att_map = att_map.to(original_dtype) - out = torch.matmul(v, att_map) # b h d n - - out = torch.reshape(out, (B, -1, H, W)) - return out - - def forward(self, x: torch.Tensor) -> torch.Tensor: - # generate multi-scale q, k, v - qkv = self.qkv(x) - multi_scale_qkv = [qkv] - for op in self.aggreg: - multi_scale_qkv.append(op(qkv)) - qkv = torch.cat(multi_scale_qkv, dim=1) - - H, W = list(qkv.size())[-2:] - if H * W > self.dim: - out = self.relu_linear_att(qkv).to(qkv.dtype) - else: - out = self.relu_quadratic_att(qkv) - out = self.proj(out) - - return x + out - - class EfficientViTBlock(nn.Module): def __init__( self, @@ -367,7 +199,7 @@ def __init__( ): super().__init__() if context_module == "LiteMLA": - self.context_module = LiteMLA( + self.context_module = DCAELiteMLA( in_channels=in_channels, out_channels=in_channels, heads_ratio=heads_ratio, diff --git a/src/diffusers/models/normalization.py b/src/diffusers/models/normalization.py index 817b3fff2ea6..d5c9e8e87595 100644 --- a/src/diffusers/models/normalization.py +++ b/src/diffusers/models/normalization.py @@ -566,3 +566,26 @@ def __init__(self, p: int = 2, dim: int = -1, eps: float = 1e-12): def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: return F.normalize(hidden_states, p=self.p, dim=self.dim, eps=self.eps) + + +class RMSNorm2d(nn.Module): + def __init__(self, num_features: int, eps: float = 1e-5, elementwise_affine: bool = True, bias: bool = True) -> None: + super().__init__() + self.num_features = num_features + self.eps = eps + self.elementwise_affine = elementwise_affine + if self.elementwise_affine: + self.weight = torch.nn.parameter.Parameter(torch.empty(self.num_features)) + if bias: + self.bias = torch.nn.parameter.Parameter(torch.empty(self.num_features)) + else: + self.register_parameter('bias', None) + else: + self.register_parameter('weight', None) + self.register_parameter('bias', None) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = (x / torch.sqrt(torch.square(x.float()).mean(dim=1, keepdim=True) + self.eps)).to(x.dtype) + if self.elementwise_affine: + x = x * self.weight.view(1, -1, 1, 1) + self.bias.view(1, -1, 1, 1) + return x From be9826c5bec5d5a994d62ac4dbe8b1ad81454f94 Mon Sep 17 00:00:00 2001 From: lawrence-cj Date: Thu, 28 Nov 2024 22:35:01 +0800 Subject: [PATCH 032/141] align with other vae decode output; --- src/diffusers/models/autoencoders/autoencoder_dc.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/diffusers/models/autoencoders/autoencoder_dc.py b/src/diffusers/models/autoencoders/autoencoder_dc.py index abb5376f6ba0..952d92d097f4 100644 --- a/src/diffusers/models/autoencoders/autoencoder_dc.py +++ b/src/diffusers/models/autoencoders/autoencoder_dc.py @@ -630,7 +630,7 @@ def encode(self, x: torch.Tensor) -> torch.Tensor: def decode(self, x: torch.Tensor, return_dict: bool = True) -> Union[DecoderOutput, torch.Tensor]: x = self.decoder(x) if not return_dict: - return x + return (x, ) else: return DecoderOutput(sample=x) From 20da201225ecba79fbba205e6fa47528ee1e1c8b Mon Sep 17 00:00:00 2001 From: lawrence-cj Date: Thu, 28 Nov 2024 22:36:53 +0800 Subject: [PATCH 033/141] add DC-AE into init files; --- src/diffusers/__init__.py | 2 ++ src/diffusers/models/__init__.py | 2 ++ src/diffusers/models/autoencoders/__init__.py | 1 + 3 files changed, 5 insertions(+) diff --git a/src/diffusers/__init__.py b/src/diffusers/__init__.py index a4749af5f61b..63ff7d660e45 100644 --- a/src/diffusers/__init__.py +++ b/src/diffusers/__init__.py @@ -128,6 +128,7 @@ "UNetSpatioTemporalConditionModel", "UVit2DModel", "VQModel", + "DCAE", ] ) _import_structure["optimization"] = [ @@ -568,6 +569,7 @@ from .utils.dummy_pt_objects import * # noqa F403 else: from .models import ( + DCAE, AllegroTransformer3DModel, AsymmetricAutoencoderKL, AuraFlowTransformer2DModel, diff --git a/src/diffusers/models/__init__.py b/src/diffusers/models/__init__.py index 65e2418ac794..e37953fd8a99 100644 --- a/src/diffusers/models/__init__.py +++ b/src/diffusers/models/__init__.py @@ -36,6 +36,7 @@ _import_structure["autoencoders.autoencoder_tiny"] = ["AutoencoderTiny"] _import_structure["autoencoders.consistency_decoder_vae"] = ["ConsistencyDecoderVAE"] _import_structure["autoencoders.vq_model"] = ["VQModel"] + _import_structure["autoencoders.autoencoder_dc"] = ["DCAE", "DCAE_HF"] _import_structure["controlnets.controlnet"] = ["ControlNetModel"] _import_structure["controlnets.controlnet_flux"] = ["FluxControlNetModel", "FluxMultiControlNetModel"] _import_structure["controlnets.controlnet_hunyuan"] = [ @@ -87,6 +88,7 @@ if is_torch_available(): from .adapter import MultiAdapter, T2IAdapter from .autoencoders import ( + DCAE, AsymmetricAutoencoderKL, AutoencoderKL, AutoencoderKLAllegro, diff --git a/src/diffusers/models/autoencoders/__init__.py b/src/diffusers/models/autoencoders/__init__.py index ba45d6671252..c6f737ab25b5 100644 --- a/src/diffusers/models/autoencoders/__init__.py +++ b/src/diffusers/models/autoencoders/__init__.py @@ -7,4 +7,5 @@ from .autoencoder_oobleck import AutoencoderOobleck from .autoencoder_tiny import AutoencoderTiny from .consistency_decoder_vae import ConsistencyDecoderVAE +from .autoencoder_dc import DCAE from .vq_model import VQModel From 5ed50e9825b63c3e10e34de80cf19b4b7496c3b7 Mon Sep 17 00:00:00 2001 From: Aryan Date: Thu, 28 Nov 2024 16:32:18 +0100 Subject: [PATCH 034/141] update --- scripts/convert_dcae_to_diffusers.py | 166 ++++ src/diffusers/__init__.py | 2 + src/diffusers/models/__init__.py | 2 + src/diffusers/models/attention.py | 159 +-- src/diffusers/models/autoencoders/__init__.py | 1 + .../models/autoencoders/autoencoder_dc.py | 938 ++++++++++++------ src/diffusers/models/normalization.py | 50 +- 7 files changed, 837 insertions(+), 481 deletions(-) create mode 100644 scripts/convert_dcae_to_diffusers.py diff --git a/scripts/convert_dcae_to_diffusers.py b/scripts/convert_dcae_to_diffusers.py new file mode 100644 index 000000000000..699ef3f42b2c --- /dev/null +++ b/scripts/convert_dcae_to_diffusers.py @@ -0,0 +1,166 @@ +import argparse +from typing import Any, Dict + +import torch +from safetensors.torch import load_file +from transformers import T5EncoderModel, T5Tokenizer + +from diffusers import AutoencoderDC + + +def remove_keys_(key: str, state_dict: Dict[str, Any]): + state_dict.pop(key) + + +TOKENIZER_MAX_LENGTH = 128 + +TRANSFORMER_KEYS_RENAME_DICT = {} + +TRANSFORMER_SPECIAL_KEYS_REMAP = {} + +VAE_KEYS_RENAME_DICT = { + # common + "norm.": "norm.norm.", + # encoder + "encoder.project_in": "encoder.conv_in", + "encoder.project_out.main.op_list.0": "encoder.conv_out", + # decoder + "decoder.project_in.main": "decoder.conv_in", + "decoder.project_out.op_list.0": "decoder.norm_out.norm", + "decoder.project_out.op_list.2": "decoder.conv_out", +} + +VAE_SPECIAL_KEYS_REMAP = {} + + +def get_state_dict(saved_dict: Dict[str, Any]) -> Dict[str, Any]: + state_dict = saved_dict + if "model" in saved_dict.keys(): + state_dict = state_dict["model"] + if "module" in saved_dict.keys(): + state_dict = state_dict["module"] + if "state_dict" in saved_dict.keys(): + state_dict = state_dict["state_dict"] + return state_dict + + +def update_state_dict_inplace(state_dict: Dict[str, Any], old_key: str, new_key: str) -> Dict[str, Any]: + state_dict[new_key] = state_dict.pop(old_key) + + +# def convert_transformer( +# ckpt_path: str, +# dtype: torch.dtype, +# ): +# PREFIX_KEY = "" + +# original_state_dict = get_state_dict(load_file(ckpt_path)) +# transformer = LTXTransformer3DModel().to(dtype=dtype) + +# for key in list(original_state_dict.keys()): +# new_key = key[len(PREFIX_KEY) :] +# for replace_key, rename_key in TRANSFORMER_KEYS_RENAME_DICT.items(): +# new_key = new_key.replace(replace_key, rename_key) +# update_state_dict_inplace(original_state_dict, key, new_key) + +# for key in list(original_state_dict.keys()): +# for special_key, handler_fn_inplace in TRANSFORMER_SPECIAL_KEYS_REMAP.items(): +# if special_key not in key: +# continue +# handler_fn_inplace(key, original_state_dict) + +# transformer.load_state_dict(original_state_dict, strict=True) +# return transformer + + +def convert_vae(ckpt_path: str, dtype: torch.dtype): + original_state_dict = get_state_dict(load_file(ckpt_path)) + vae = AutoencoderDC( + in_channels=3, + latent_channels=32, + encoder_width_list=[128, 256, 512, 512, 1024, 1024], + encoder_depth_list=[2, 2, 2, 3, 3, 3], + encoder_block_type=["ResBlock", "ResBlock", "ResBlock", "EViTS5_GLU", "EViTS5_GLU", "EViTS5_GLU"], + encoder_norm="rms2d", + encoder_act="silu", + downsample_block_type="Conv", + decoder_width_list=[128, 256, 512, 512, 1024, 1024], + decoder_depth_list=[3, 3, 3, 3, 3, 3], + decoder_block_type=["ResBlock", "ResBlock", "ResBlock", "EViTS5_GLU", "EViTS5_GLU", "EViTS5_GLU"], + decoder_norm="rms2d", + decoder_act="silu", + upsample_block_type="InterpolateConv", + scaling_factor=0.41407, + ).to(dtype=dtype) + + for key in list(original_state_dict.keys()): + new_key = key[:] + for replace_key, rename_key in VAE_KEYS_RENAME_DICT.items(): + new_key = new_key.replace(replace_key, rename_key) + update_state_dict_inplace(original_state_dict, key, new_key) + + for key in list(original_state_dict.keys()): + for special_key, handler_fn_inplace in VAE_SPECIAL_KEYS_REMAP.items(): + if special_key not in key: + continue + handler_fn_inplace(key, original_state_dict) + + vae.load_state_dict(original_state_dict, strict=True) + return vae + + +def get_args(): + parser = argparse.ArgumentParser() + parser.add_argument( + "--transformer_ckpt_path", type=str, default=None, help="Path to original transformer checkpoint" + ) + parser.add_argument("--vae_ckpt_path", type=str, default=None, help="Path to original vae checkpoint") + parser.add_argument( + "--text_encoder_cache_dir", type=str, default=None, help="Path to text encoder cache directory" + ) + parser.add_argument( + "--typecast_text_encoder", + action="store_true", + default=False, + help="Whether or not to apply fp16/bf16 precision to text_encoder", + ) + parser.add_argument("--save_pipeline", action="store_true") + parser.add_argument("--output_path", type=str, required=True, help="Path where converted model should be saved") + parser.add_argument("--dtype", default="fp32", help="Torch dtype to save the model in.") + return parser.parse_args() + + +DTYPE_MAPPING = { + "fp32": torch.float32, + "fp16": torch.float16, + "bf16": torch.bfloat16, +} + +VARIANT_MAPPING = { + "fp32": None, + "fp16": "fp16", + "bf16": "bf16", +} + + +if __name__ == "__main__": + args = get_args() + + transformer = None + dtype = DTYPE_MAPPING[args.dtype] + variant = VARIANT_MAPPING[args.dtype] + + if args.save_pipeline: + assert args.transformer_ckpt_path is not None and args.vae_ckpt_path is not None + + # if args.transformer_ckpt_path is not None: + # transformer = convert_transformer(args.transformer_ckpt_path, dtype) + # if not args.save_pipeline: + # transformer.save_pretrained( + # args.output_path, safe_serialization=True, max_shard_size="5GB", variant=variant + # ) + + if args.vae_ckpt_path is not None: + vae = convert_vae(args.vae_ckpt_path, dtype) + if not args.save_pipeline: + vae.save_pretrained(args.output_path, safe_serialization=True, max_shard_size="5GB", variant=variant) diff --git a/src/diffusers/__init__.py b/src/diffusers/__init__.py index a4749af5f61b..4e2b3c0baea8 100644 --- a/src/diffusers/__init__.py +++ b/src/diffusers/__init__.py @@ -80,6 +80,7 @@ "AllegroTransformer3DModel", "AsymmetricAutoencoderKL", "AuraFlowTransformer2DModel", + "AutoencoderDC", "AutoencoderKL", "AutoencoderKLAllegro", "AutoencoderKLCogVideoX", @@ -572,6 +573,7 @@ AsymmetricAutoencoderKL, AuraFlowTransformer2DModel, AutoencoderKL, + AutoencoderDC, AutoencoderKLAllegro, AutoencoderKLCogVideoX, AutoencoderKLMochi, diff --git a/src/diffusers/models/__init__.py b/src/diffusers/models/__init__.py index 65e2418ac794..7183d40b6f91 100644 --- a/src/diffusers/models/__init__.py +++ b/src/diffusers/models/__init__.py @@ -27,6 +27,7 @@ if is_torch_available(): _import_structure["adapter"] = ["MultiAdapter", "T2IAdapter"] _import_structure["autoencoders.autoencoder_asym_kl"] = ["AsymmetricAutoencoderKL"] + _import_structure["autoencoders.autoencoder_dc"] = ["AutoencoderDC"] _import_structure["autoencoders.autoencoder_kl"] = ["AutoencoderKL"] _import_structure["autoencoders.autoencoder_kl_allegro"] = ["AutoencoderKLAllegro"] _import_structure["autoencoders.autoencoder_kl_cogvideox"] = ["AutoencoderKLCogVideoX"] @@ -88,6 +89,7 @@ from .adapter import MultiAdapter, T2IAdapter from .autoencoders import ( AsymmetricAutoencoderKL, + AutoencoderDC, AutoencoderKL, AutoencoderKLAllegro, AutoencoderKLCogVideoX, diff --git a/src/diffusers/models/attention.py b/src/diffusers/models/attention.py index ca6611a8977b..6a07f7659fd9 100644 --- a/src/diffusers/models/attention.py +++ b/src/diffusers/models/attention.py @@ -22,7 +22,7 @@ from .activations import GEGLU, GELU, ApproximateGELU, FP32SiLU, SwiGLU, get_activation from .attention_processor import Attention, JointAttnProcessor2_0 from .embeddings import SinusoidalPositionalEmbedding -from .normalization import AdaLayerNorm, AdaLayerNormContinuous, AdaLayerNormZero, RMSNorm, SD35AdaLayerNormZeroX, RMSNorm2d +from .normalization import AdaLayerNorm, AdaLayerNormContinuous, AdaLayerNormZero, RMSNorm, SD35AdaLayerNormZeroX, RMSNormNd logger = logging.get_logger(__name__) @@ -1241,160 +1241,3 @@ def forward(self, hidden_states: torch.Tensor, *args, **kwargs) -> torch.Tensor: for module in self.net: hidden_states = module(hidden_states) return hidden_states - - -class DCAELiteMLA(nn.Module): - r"""Lightweight multi-scale linear attention used in DC-AE""" - - def __init__( - self, - in_channels: int, - out_channels: int, - heads: Optional[int] = None, - heads_ratio: float = 1.0, - dim=8, - use_bias=(False, False), - norm=(None, "bn2d"), - act_func=(None, None), - kernel_func="relu", - scales: Tuple[int, ...] = (5,), - eps=1.0e-15, - ): - super().__init__() - self.eps = eps - heads = int(in_channels // dim * heads_ratio) if heads is None else heads - - total_dim = heads * dim - - self.dim = dim - - qkv = [nn.Conv2d(in_channels=in_channels, out_channels=3 * total_dim, kernel_size=1, bias=use_bias[0])] - if norm[0] is None: - pass - elif norm[0] == "rms2d": - qkv.append(RMSNorm2d(num_features=3 * total_dim)) - elif norm[0] == "bn2d": - qkv.append(nn.BatchNorm2d(num_features=3 * total_dim)) - else: - raise ValueError(f"norm {norm[0]} is not supported") - if act_func[0] is not None: - qkv.append(get_activation(act_func[0])) - self.qkv = nn.Sequential(*qkv) - - self.aggreg = nn.ModuleList( - [ - nn.Sequential( - nn.Conv2d( - 3 * total_dim, - 3 * total_dim, - scale, - padding=scale // 2, - groups=3 * total_dim, - bias=use_bias[0], - ), - nn.Conv2d(3 * total_dim, 3 * total_dim, 1, groups=3 * heads, bias=use_bias[0]), - ) - for scale in scales - ] - ) - self.kernel_func = get_activation(kernel_func) - - proj = [nn.Conv2d(in_channels=total_dim * (1 + len(scales)), out_channels=out_channels, kernel_size=1, bias=use_bias[1])] - if norm[1] is None: - pass - elif norm[1] == "rms2d": - proj.append(RMSNorm2d(num_features=out_channels)) - elif norm[1] == "bn2d": - proj.append(nn.BatchNorm2d(num_features=out_channels)) - else: - raise ValueError(f"norm {norm[1]} is not supported") - if act_func[1] is not None: - proj.append(get_activation(act_func[1])) - self.proj = nn.Sequential(*proj) - - def relu_linear_att(self, qkv: torch.Tensor) -> torch.Tensor: - B, _, H, W = list(qkv.size()) - - if qkv.dtype == torch.float16: - qkv = qkv.float() - - qkv = torch.reshape( - qkv, - ( - B, - -1, - 3 * self.dim, - H * W, - ), - ) - q, k, v = ( - qkv[:, :, 0 : self.dim], - qkv[:, :, self.dim : 2 * self.dim], - qkv[:, :, 2 * self.dim :], - ) - - # lightweight linear attention - q = self.kernel_func(q) - k = self.kernel_func(k) - - # linear matmul - trans_k = k.transpose(-1, -2) - - v = F.pad(v, (0, 0, 0, 1), mode="constant", value=1) - vk = torch.matmul(v, trans_k) - out = torch.matmul(vk, q) - if out.dtype == torch.bfloat16: - out = out.float() - out = out[:, :, :-1] / (out[:, :, -1:] + self.eps) - - out = torch.reshape(out, (B, -1, H, W)) - return out - - def relu_quadratic_att(self, qkv: torch.Tensor) -> torch.Tensor: - B, _, H, W = list(qkv.size()) - - qkv = torch.reshape( - qkv, - ( - B, - -1, - 3 * self.dim, - H * W, - ), - ) - q, k, v = ( - qkv[:, :, 0 : self.dim], - qkv[:, :, self.dim : 2 * self.dim], - qkv[:, :, 2 * self.dim :], - ) - - q = self.kernel_func(q) - k = self.kernel_func(k) - - att_map = torch.matmul(k.transpose(-1, -2), q) # b h n n - original_dtype = att_map.dtype - if original_dtype in [torch.float16, torch.bfloat16]: - att_map = att_map.float() - att_map = att_map / (torch.sum(att_map, dim=2, keepdim=True) + self.eps) # b h n n - att_map = att_map.to(original_dtype) - out = torch.matmul(v, att_map) # b h d n - - out = torch.reshape(out, (B, -1, H, W)) - return out - - def forward(self, x: torch.Tensor) -> torch.Tensor: - # generate multi-scale q, k, v - qkv = self.qkv(x) - multi_scale_qkv = [qkv] - for op in self.aggreg: - multi_scale_qkv.append(op(qkv)) - qkv = torch.cat(multi_scale_qkv, dim=1) - - H, W = list(qkv.size())[-2:] - if H * W > self.dim: - out = self.relu_linear_att(qkv).to(qkv.dtype) - else: - out = self.relu_quadratic_att(qkv) - out = self.proj(out) - - return x + out diff --git a/src/diffusers/models/autoencoders/__init__.py b/src/diffusers/models/autoencoders/__init__.py index ba45d6671252..7a36e88f1a36 100644 --- a/src/diffusers/models/autoencoders/__init__.py +++ b/src/diffusers/models/autoencoders/__init__.py @@ -1,4 +1,5 @@ from .autoencoder_asym_kl import AsymmetricAutoencoderKL +from .autoencoder_dc import AutoencoderDC from .autoencoder_kl import AutoencoderKL from .autoencoder_kl_allegro import AutoencoderKLAllegro from .autoencoder_kl_cogvideox import AutoencoderKLCogVideoX diff --git a/src/diffusers/models/autoencoders/autoencoder_dc.py b/src/diffusers/models/autoencoders/autoencoder_dc.py index abb5376f6ba0..6a54dc1332ba 100644 --- a/src/diffusers/models/autoencoders/autoencoder_dc.py +++ b/src/diffusers/models/autoencoders/autoencoder_dc.py @@ -13,26 +13,37 @@ # See the License for the specific language governing permissions and # limitations under the License. -from typing import Any, Optional, Callable, Union -from collections import OrderedDict +from typing import Any, Callable, Tuple, Optional import torch import torch.nn as nn import torch.nn.functional as F from torch.nn import BatchNorm2d -from huggingface_hub import PyTorchModelHubMixin -import ipdb from ...configuration_utils import ConfigMixin, register_to_config +from ..activations import get_activation from ..modeling_utils import ModelMixin +from ..normalization import RMSNormNd + + +def val2tuple(x: list | tuple | Any, min_len: int = 1) -> tuple: + x = list(x) if isinstance(x, (list, tuple)) else [x] + # repeat elements if necessary + if len(x) > 0: + x.extend([x[-1] for _ in range(min_len - len(x))]) + return tuple(x) -from ..activations import get_activation -from ..normalization import RMSNorm2d -from ..downsampling import ConvPixelUnshuffleDownsample2D, PixelUnshuffleChannelAveragingDownsample2D -from ..upsampling import ConvPixelShuffleUpsample2D, ChannelDuplicatingPixelUnshuffleUpsample2D, Upsample2D -from ..attention import DCAELiteMLA -from .vae import DecoderOutput +def build_norm(name: Optional[str]="bn2d", num_features: Optional[int]=None) -> Optional[nn.Module]: + if name is None: + norm = None + elif name == "rms2d": + norm = RMSNormNd(num_features, eps=1e-5, elementwise_affine=True, bias=True, channel_dim=1) + elif name == "bn2d": + norm = BatchNorm2d(num_features=num_features) + else: + raise ValueError(f"norm {name} is not supported") + return norm class ConvLayer(nn.Module): @@ -49,7 +60,7 @@ def __init__( norm="bn2d", act_func="relu", ): - super().__init__() + super(ConvLayer, self).__init__() padding = kernel_size // 2 padding *= dilation @@ -65,14 +76,7 @@ def __init__( groups=groups, bias=use_bias, ) - if norm is None: - self.norm = None - elif norm == "rms2d": - self.norm = RMSNorm2d(num_features=out_channels) - elif norm == "bn2d": - self.norm = BatchNorm2d(num_features=out_channels) - else: - raise ValueError(f"norm {norm} is not supported") + self.norm = build_norm(norm, num_features=out_channels) self.act = get_activation(act_func) if act_func is not None else None def forward(self, x: torch.Tensor) -> torch.Tensor: @@ -86,6 +90,132 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: return x +class ConvPixelUnshuffleDownSampleLayer(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + kernel_size: int, + factor: int, + ): + super().__init__() + self.factor = factor + out_ratio = factor**2 + assert out_channels % out_ratio == 0 + self.conv = ConvLayer( + in_channels=in_channels, + out_channels=out_channels // out_ratio, + kernel_size=kernel_size, + use_bias=True, + norm=None, + act_func=None, + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = self.conv(x) + x = F.pixel_unshuffle(x, self.factor) + return x + + +class DownsamplePixelUnshuffleChannelAveraging(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + factor: int, + ): + super().__init__() + self.in_channels = in_channels + self.out_channels = out_channels + self.factor = factor + assert in_channels * factor**2 % out_channels == 0 + self.group_size = in_channels * factor**2 // out_channels + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = F.pixel_unshuffle(x, self.factor) + x = x.unflatten(1, (-1, self.group_size)) + x = x.mean(dim=2) + return x + + +class ConvPixelShuffleUpSampleLayer(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + kernel_size: int, + factor: int, + ): + super().__init__() + self.factor = factor + out_ratio = factor**2 + self.conv = ConvLayer( + in_channels=in_channels, + out_channels=out_channels * out_ratio, + kernel_size=kernel_size, + use_bias=True, + norm=None, + act_func=None, + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = self.conv(x) + x = F.pixel_shuffle(x, self.factor) + return x + + +class InterpolateConvUpSampleLayer(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + kernel_size: int, + factor: int, + mode: str = "nearest", + ) -> None: + super().__init__() + self.factor = factor + self.mode = mode + self.conv = ConvLayer( + in_channels=in_channels, + out_channels=out_channels, + kernel_size=kernel_size, + use_bias=True, + norm=None, + act_func=None, + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = torch.nn.functional.interpolate(x, scale_factor=self.factor, mode=self.mode) + x = self.conv(x) + return x + + +class ChannelDuplicatingPixelUnshuffleUpSampleLayer(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + factor: int, + ): + super().__init__() + self.in_channels = in_channels + self.out_channels = out_channels + self.factor = factor + assert out_channels * factor**2 % in_channels == 0 + self.repeats = out_channels * factor**2 // in_channels + + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = x.repeat_interleave(self.repeats, dim=1) + x = F.pixel_shuffle(x, self.factor) + return x + + +class IdentityLayer(nn.Module): + def forward(self, x: torch.Tensor) -> torch.Tensor: + return x + + class GLUMBConv(nn.Module): def __init__( self, @@ -95,11 +225,14 @@ def __init__( stride=1, mid_channels=None, expand_ratio=6, - use_bias=(False, False, False), + use_bias=False, norm=(None, None, "ln2d"), act_func=("silu", "silu", None), ): super().__init__() + use_bias = val2tuple(use_bias, 3) + norm = val2tuple(norm, 3) + act_func = val2tuple(act_func, 3) mid_channels = round(in_channels * expand_ratio) if mid_channels is None else mid_channels @@ -132,15 +265,15 @@ def __init__( ) def forward(self, x: torch.Tensor) -> torch.Tensor: - y = self.inverted_conv(x) - y = self.depth_conv(y) + x = self.inverted_conv(x) + x = self.depth_conv(x) - y, gate = torch.chunk(y, 2, dim=1) + x, gate = torch.chunk(x, 2, dim=1) gate = self.glu_act(gate) - y = y * gate + x = x * gate - y = self.point_conv(y) - return x + y + x = self.point_conv(x) + return x class ResBlock(nn.Module): @@ -152,11 +285,15 @@ def __init__( stride=1, mid_channels=None, expand_ratio=1, - use_bias=(False, False), + use_bias=False, norm=("bn2d", "bn2d"), act_func=("relu6", None), ): super().__init__() + use_bias = val2tuple(use_bias, 2) + norm = val2tuple(norm, 2) + act_func = val2tuple(act_func, 2) + mid_channels = round(in_channels * expand_ratio) if mid_channels is None else mid_channels self.conv1 = ConvLayer( @@ -177,13 +314,165 @@ def __init__( norm=norm[1], act_func=act_func[1], ) - self.shortcut = nn.Identity() def forward(self, x: torch.Tensor) -> torch.Tensor: - x = self.conv2(self.conv1(x)) + x + x = self.conv1(x) + x = self.conv2(x) return x +class LiteMLA(nn.Module): + r"""Lightweight multi-scale linear attention""" + + def __init__( + self, + in_channels: int, + out_channels: int, + heads: Optional[int] = None, + heads_ratio: float = 1.0, + dim=8, + use_bias=False, + norm=(None, "bn2d"), + act_func=(None, None), + kernel_func="relu", + scales: tuple[int, ...] = (5,), + eps=1.0e-15, + ): + super(LiteMLA, self).__init__() + self.eps = eps + heads = int(in_channels // dim * heads_ratio) if heads is None else heads + + total_dim = heads * dim + + use_bias = val2tuple(use_bias, 2) + norm = val2tuple(norm, 2) + act_func = val2tuple(act_func, 2) + + self.dim = dim + self.qkv = ConvLayer( + in_channels, + 3 * total_dim, + 1, + use_bias=use_bias[0], + norm=norm[0], + act_func=act_func[0], + ) + self.aggreg = nn.ModuleList( + [ + nn.Sequential( + nn.Conv2d( + 3 * total_dim, + 3 * total_dim, + scale, + padding=scale // 2, + groups=3 * total_dim, + bias=use_bias[0], + ), + nn.Conv2d(3 * total_dim, 3 * total_dim, 1, groups=3 * heads, bias=use_bias[0]), + ) + for scale in scales + ] + ) + self.kernel_func = get_activation(kernel_func) + + self.proj = ConvLayer( + total_dim * (1 + len(scales)), + out_channels, + 1, + use_bias=use_bias[1], + norm=norm[1], + act_func=act_func[1], + ) + + @torch.autocast(device_type="cuda", enabled=False) + def relu_linear_att(self, qkv: torch.Tensor) -> torch.Tensor: + B, _, H, W = list(qkv.size()) + + if qkv.dtype == torch.float16: + qkv = qkv.float() + + qkv = torch.reshape( + qkv, + ( + B, + -1, + 3 * self.dim, + H * W, + ), + ) + q, k, v = ( + qkv[:, :, 0 : self.dim], + qkv[:, :, self.dim : 2 * self.dim], + qkv[:, :, 2 * self.dim :], + ) + + # lightweight linear attention + q = self.kernel_func(q) + k = self.kernel_func(k) + + # linear matmul + trans_k = k.transpose(-1, -2) + + v = F.pad(v, (0, 0, 0, 1), mode="constant", value=1) + vk = torch.matmul(v, trans_k) + out = torch.matmul(vk, q) + if out.dtype == torch.bfloat16: + out = out.float() + out = out[:, :, :-1] / (out[:, :, -1:] + self.eps) + + out = torch.reshape(out, (B, -1, H, W)) + return out + + def relu_quadratic_att(self, qkv: torch.Tensor) -> torch.Tensor: + B, _, H, W = list(qkv.size()) + + qkv = torch.reshape( + qkv, + ( + B, + -1, + 3 * self.dim, + H * W, + ), + ) + q, k, v = ( + qkv[:, :, 0 : self.dim], + qkv[:, :, self.dim : 2 * self.dim], + qkv[:, :, 2 * self.dim :], + ) + + q = self.kernel_func(q) + k = self.kernel_func(k) + + att_map = torch.matmul(k.transpose(-1, -2), q) # b h n n + original_dtype = att_map.dtype + if original_dtype in [torch.float16, torch.bfloat16]: + att_map = att_map.float() + att_map = att_map / (torch.sum(att_map, dim=2, keepdim=True) + self.eps) # b h n n + att_map = att_map.to(original_dtype) + out = torch.matmul(v, att_map) # b h d n + + out = torch.reshape(out, (B, -1, H, W)) + return out + + def forward(self, x: torch.Tensor) -> torch.Tensor: + # generate multi-scale q, k, v + qkv = self.qkv(x) + multi_scale_qkv = [qkv] + for op in self.aggreg: + multi_scale_qkv.append(op(qkv)) + qkv = torch.cat(multi_scale_qkv, dim=1) + + H, W = list(qkv.size())[-2:] + if H * W > self.dim: + out = self.relu_linear_att(qkv).to(qkv.dtype) + else: + out = self.relu_quadratic_att(qkv) + out = self.proj(out) + + return out + + class EfficientViTBlock(nn.Module): def __init__( self, @@ -197,26 +486,32 @@ def __init__( context_module: str = "LiteMLA", local_module: str = "MBConv", ): - super().__init__() + super(EfficientViTBlock, self).__init__() if context_module == "LiteMLA": - self.context_module = DCAELiteMLA( - in_channels=in_channels, - out_channels=in_channels, - heads_ratio=heads_ratio, - dim=dim, - norm=(None, norm), - scales=scales, + self.context_module = ResidualBlock( + LiteMLA( + in_channels=in_channels, + out_channels=in_channels, + heads_ratio=heads_ratio, + dim=dim, + norm=(None, norm), + scales=scales, + ), + IdentityLayer(), ) else: raise ValueError(f"context_module {context_module} is not supported") if local_module == "GLUMBConv": - self.local_module = GLUMBConv( - in_channels=in_channels, - out_channels=in_channels, - expand_ratio=expand_ratio, - use_bias=(True, True, False), - norm=(None, None, norm), - act_func=(act_func, act_func, None), + self.local_module = ResidualBlock( + GLUMBConv( + in_channels=in_channels, + out_channels=in_channels, + expand_ratio=expand_ratio, + use_bias=(True, True, False), + norm=(None, None, norm), + act_func=(act_func, act_func, None), + ), + IdentityLayer(), ) else: raise NotImplementedError(f"local_module {local_module} is not supported") @@ -265,354 +560,320 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: return res +class OpSequential(nn.Module): + def __init__(self, op_list: list[Optional[nn.Module]]): + super(OpSequential, self).__init__() + valid_op_list = [] + for op in op_list: + if op is not None: + valid_op_list.append(op) + self.op_list = nn.ModuleList(valid_op_list) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + for op in self.op_list: + x = op(x) + return x + + +def build_stage_main( + width: int, depth: int, block_type: str | list[str], norm: str, act: str, input_width: int +) -> list[nn.Module]: + assert isinstance(block_type, str) or (isinstance(block_type, list) and depth == len(block_type)) + stage = [] + for d in range(depth): + current_block_type = block_type[d] if isinstance(block_type, list) else block_type + + in_channels = width if d > 0 else input_width + out_channels = width + + if current_block_type == "ResBlock": + assert in_channels == out_channels + main_block = ResBlock( + in_channels=in_channels, + out_channels=out_channels, + kernel_size=3, + stride=1, + use_bias=(True, False), + norm=(None, norm), + act_func=(act, None), + ) + block = ResidualBlock(main_block, IdentityLayer()) + elif current_block_type == "EViT_GLU": + assert in_channels == out_channels + block = EfficientViTBlock(in_channels, norm=norm, act_func=act, local_module="GLUMBConv", scales=()) + elif current_block_type == "EViTS5_GLU": + assert in_channels == out_channels + block = EfficientViTBlock(in_channels, norm=norm, act_func=act, local_module="GLUMBConv", scales=(5,)) + else: + raise ValueError(f"block_type {current_block_type} is not supported") + + stage.append(block) + return stage + + +def build_downsample_block(block_type: str, in_channels: int, out_channels: int, shortcut: Optional[str]) -> nn.Module: + if block_type == "Conv": + block = ConvLayer( + in_channels=in_channels, + out_channels=out_channels, + kernel_size=3, + stride=2, + use_bias=True, + norm=None, + act_func=None, + ) + elif block_type == "ConvPixelUnshuffle": + block = ConvPixelUnshuffleDownSampleLayer( + in_channels=in_channels, out_channels=out_channels, kernel_size=3, factor=2 + ) + else: + raise ValueError(f"block_type {block_type} is not supported for downsampling") + if shortcut is None: + pass + elif shortcut == "averaging": + shortcut_block = DownsamplePixelUnshuffleChannelAveraging( + in_channels=in_channels, out_channels=out_channels, factor=2 + ) + block = ResidualBlock(block, shortcut_block) + else: + raise ValueError(f"shortcut {shortcut} is not supported for downsample") + return block + + +def build_upsample_block(block_type: str, in_channels: int, out_channels: int, shortcut: Optional[str]) -> nn.Module: + if block_type == "ConvPixelShuffle": + block = ConvPixelShuffleUpSampleLayer( + in_channels=in_channels, out_channels=out_channels, kernel_size=3, factor=2 + ) + elif block_type == "InterpolateConv": + block = InterpolateConvUpSampleLayer( + in_channels=in_channels, out_channels=out_channels, kernel_size=3, factor=2 + ) + else: + raise ValueError(f"block_type {block_type} is not supported for upsampling") + if shortcut is None: + pass + elif shortcut == "duplicating": + shortcut_block = ChannelDuplicatingPixelUnshuffleUpSampleLayer( + in_channels=in_channels, out_channels=out_channels, factor=2 + ) + block = ResidualBlock(block, shortcut_block) + else: + raise ValueError(f"shortcut {shortcut} is not supported for upsample") + return block + + class Encoder(nn.Module): def __init__( - self, + self, in_channels: int, latent_channels: int, - width_list: list[int] = [128, 256, 512, 512, 1024, 1024], - depth_list: list[int] = [2, 2, 2, 2, 2, 2], + block_out_channels: list[int] = [128, 256, 512, 512, 1024, 1024], + layers_per_block: list[int] = [2, 2, 2, 2, 2, 2], block_type: str | list[str] = "ResBlock", - norm: str = "rms2d", - act: str = "silu", downsample_block_type: str = "ConvPixelUnshuffle", - downsample_shortcut: Optional[str] = "averaging", - out_norm: Optional[str] = None, - out_act: Optional[str] = None, - out_shortcut: Optional[str] = "averaging", - double_latent: bool = False, ): super().__init__() - num_stages = len(width_list) + num_stages = len(block_out_channels) self.num_stages = num_stages + assert len(layers_per_block) == num_stages + assert len(block_out_channels) == num_stages + assert isinstance(block_type, str) or ( + isinstance(block_type, list) and len(block_type) == num_stages + ) - # validate config - if len(depth_list) != num_stages or len(width_list) != num_stages: - raise ValueError(f"len(depth_list) {len(depth_list)} and len(width_list) {len(width_list)} should be equal to num_stages {num_stages}") - if not isinstance(block_type, (str, list)) or (isinstance(block_type, list) and len(block_type) != num_stages): - raise ValueError(f"block_type should be either a str or a list of str with length {num_stages}, but got {block_type}") - - # project in - if depth_list[0] > 0: - project_in_block = nn.Conv2d( + factor = 1 if layers_per_block[0] > 0 else 2 + + if factor == 1: + self.conv_in = ConvLayer( in_channels=in_channels, - out_channels=width_list[0], + out_channels=block_out_channels[0] if layers_per_block[0] > 0 else block_out_channels[1], kernel_size=3, - padding=1, + stride=1, + use_bias=True, + norm=None, + act_func=None, + ) + elif factor == 2: + self.conv_in = build_downsample_block( + block_type=downsample_block_type, in_channels=in_channels, out_channels=block_out_channels[0] if layers_per_block[0] > 0 else block_out_channels[1], shortcut=None ) - elif depth_list[1] > 0: - if downsample_block_type == "Conv": - project_in_block = nn.Conv2d( - in_channels=in_channels, - out_channels=width_list[1], - kernel_size=3, - stride=2, - padding=1, - ) - elif downsample_block_type == "ConvPixelUnshuffle": - project_in_block = ConvPixelUnshuffleDownsample2D( - in_channels=in_channels, out_channels=width_list[1], kernel_size=3, factor=2 - ) - else: - raise ValueError(f"block_type {downsample_block_type} is not supported for downsampling") else: - raise ValueError(f"depth list {depth_list} is not supported for encoder project in") - self.project_in = project_in_block + raise - # stages - self.stages: list[nn.Module] = [] - for stage_id, (width, depth) in enumerate(zip(width_list, depth_list)): + self.stages: list[OpSequential] = [] + for stage_id, (width, depth) in enumerate(zip(block_out_channels, layers_per_block)): stage_block_type = block_type[stage_id] if isinstance(block_type, list) else block_type - if not (isinstance(stage_block_type, str) or (isinstance(stage_block_type, list) and depth == len(stage_block_type))): - raise ValueError(f"block type {stage_block_type} is not supported for encoder stage {stage_id} with depth {depth}") - stage = [] - # stage main - for d in range(depth): - current_block_type = stage_block_type[d] if isinstance(stage_block_type, list) else stage_block_type - if current_block_type == "ResBlock": - block = ResBlock( - in_channels=width, - out_channels=width, - kernel_size=3, - stride=1, - use_bias=(True, False), - norm=(None, norm), - act_func=(act, None), - ) - elif current_block_type == "EViTGLU": - block = EfficientViTBlock(width, norm=norm, act_func=act, local_module="GLUMBConv", scales=()) - elif current_block_type == "EViTS5GLU": - block = EfficientViTBlock(width, norm=norm, act_func=act, local_module="GLUMBConv", scales=(5,)) - else: - raise ValueError(f"block type {current_block_type} is not supported") - stage.append(block) - # downsample + stage = build_stage_main( + width=width, depth=depth, block_type=stage_block_type, norm="rms2d", act="silu", input_width=width + ) if stage_id < num_stages - 1 and depth > 0: - downsample_out_channels = width_list[stage_id + 1] - if downsample_block_type == "Conv": - downsample_block = nn.Conv2d( - in_channels=width, - out_channels=downsample_out_channels, - kernel_size=3, - stride=2, - padding=1, - ) - elif downsample_block_type == "ConvPixelUnshuffle": - downsample_block = ConvPixelUnshuffleDownsample2D( - in_channels=width, out_channels=downsample_out_channels, kernel_size=3, factor=2 - ) - else: - raise ValueError(f"downsample_block_type {downsample_block_type} is not supported for downsampling") - if downsample_shortcut is None: - pass - elif downsample_shortcut == "averaging": - shortcut_block = PixelUnshuffleChannelAveragingDownsample2D( - in_channels=width, out_channels=downsample_out_channels, factor=2 - ) - downsample_block = ResidualBlock(downsample_block, shortcut_block) - else: - raise ValueError(f"shortcut {downsample_shortcut} is not supported for downsample") + downsample_block = build_downsample_block( + block_type=downsample_block_type, + in_channels=width, + out_channels=block_out_channels[stage_id + 1], + shortcut="averaging", + ) stage.append(downsample_block) - self.stages.append(nn.Sequential(*stage)) + self.stages.append(OpSequential(stage)) self.stages = nn.ModuleList(self.stages) - # project out - project_out_layers: list[nn.Module] = [] - if out_norm is None: - pass - elif out_norm == "rms2d": - project_out_layers.append(RMSNorm2d(num_features=width_list[-1])) - elif out_norm == "bn2d": - project_out_layers.append(BatchNorm2d(num_features=width_list[-1])) - else: - raise ValueError(f"norm {out_norm} is not supported for encoder project out") - if out_act is not None: - project_out_layers.append(get_activation(out_act)) - project_out_out_channels = 2 * latent_channels if double_latent else latent_channels - project_out_layers.append(ConvLayer( - in_channels=width_list[-1], - out_channels=project_out_out_channels, + self.norm_out = DownsamplePixelUnshuffleChannelAveraging( + in_channels=block_out_channels[-1], out_channels=latent_channels, factor=1 + ) + self.conv_out = ConvLayer( + in_channels=block_out_channels[-1], + out_channels=latent_channels, kernel_size=3, stride=1, use_bias=True, norm=None, act_func=None, - )) - project_out_block = nn.Sequential(*project_out_layers) - if out_shortcut is None: - pass - elif out_shortcut == "averaging": - shortcut_block = PixelUnshuffleChannelAveragingDownsample2D( - in_channels=width_list[-1], out_channels=project_out_out_channels, factor=1 - ) - project_out_block = ResidualBlock(project_out_block, shortcut_block) - else: - raise ValueError(f"shortcut {out_shortcut} is not supported for encoder project out") - self.project_out = project_out_block + ) def forward(self, x: torch.Tensor) -> torch.Tensor: - x = self.project_in(x) + x = self.conv_in(x) for stage in self.stages: - if len(stage) == 0: + if len(stage.op_list) == 0: continue x = stage(x) - x = self.project_out(x) + x = self.conv_out(x) + self.norm_out(x) return x class Decoder(nn.Module): def __init__( - self, + self, in_channels: int, latent_channels: int, - in_shortcut: Optional[str] = "duplicating", - width_list: list[int] = [128, 256, 512, 512, 1024, 1024], - depth_list: list[int] = [2, 2, 2, 2, 2, 2], + block_out_channels: list[int] = [128, 256, 512, 512, 1024, 1024], + layers_per_block: list[int] = [2, 2, 2, 2, 2, 2], block_type: str | list[str] = "ResBlock", norm: str | list[str] = "rms2d", act: str | list[str] = "silu", upsample_block_type: str = "ConvPixelShuffle", + upsample_match_channel: bool = True, upsample_shortcut: str = "duplicating", - out_norm: str = "rms2d", - out_act: str = "relu", ): super().__init__() - num_stages = len(width_list) + num_stages = len(block_out_channels) self.num_stages = num_stages + assert len(layers_per_block) == num_stages + assert len(block_out_channels) == num_stages + assert isinstance(block_type, str) or ( + isinstance(block_type, list) and len(block_type) == num_stages + ) + assert isinstance(norm, str) or (isinstance(norm, list) and len(norm) == num_stages) + assert isinstance(act, str) or (isinstance(act, list) and len(act) == num_stages) - # validate config - if len(depth_list) != num_stages or len(width_list) != num_stages: - raise ValueError(f"len(depth_list) {len(depth_list)} and len(width_list) {len(width_list)} should be equal to num_stages {num_stages}") - if not isinstance(block_type, (str, list)) or (isinstance(block_type, list) and len(block_type) != num_stages): - raise ValueError(f"block_type should be either a str or a list of str with length {num_stages}, but got {block_type}") - if not isinstance(norm, (str, list)) or (isinstance(norm, list) and len(norm) != num_stages): - raise ValueError(f"norm should be either a str or a list of str with length {num_stages}, but got {norm}") - if not isinstance(act, (str, list)) or (isinstance(act, list) and len(act) != num_stages): - raise ValueError(f"act should be either a str or a list of str with length {num_stages}, but got {act}") - - # project in - project_in_block = ConvLayer( + self.conv_in = ConvLayer( in_channels=latent_channels, - out_channels=width_list[-1], + out_channels=block_out_channels[-1], kernel_size=3, stride=1, use_bias=True, norm=None, act_func=None, ) - if in_shortcut is None: - pass - elif in_shortcut == "duplicating": - shortcut_block = ChannelDuplicatingPixelUnshuffleUpsample2D( - in_channels=latent_channels, out_channels=width_list[-1], factor=1 - ) - project_in_block = ResidualBlock(project_in_block, shortcut_block) - else: - raise ValueError(f"shortcut {in_shortcut} is not supported for decoder project in") - self.project_in = project_in_block + self.norm_in = ChannelDuplicatingPixelUnshuffleUpSampleLayer( + in_channels=latent_channels, out_channels=block_out_channels[-1], factor=1 + ) - # stages - self.stages: list[nn.Module] = [] - for stage_id, (width, depth) in reversed(list(enumerate(zip(width_list, depth_list)))): + self.stages: list[OpSequential] = [] + for stage_id, (width, depth) in reversed(list(enumerate(zip(block_out_channels, layers_per_block)))): stage = [] - # upsample if stage_id < num_stages - 1 and depth > 0: - upsample_out_channels = width - if upsample_block_type == "ConvPixelShuffle": - upsample_block = ConvPixelShuffleUpsample2D( - in_channels=width_list[stage_id + 1], out_channels=upsample_out_channels, kernel_size=3, factor=2 - ) - elif upsample_block_type == "InterpolateConv": - upsample_block = Upsample2D(channels=width_list[stage_id + 1], use_conv=True, out_channels=upsample_out_channels) - else: - raise ValueError(f"upsample_block_type {upsample_block_type} is not supported") - if upsample_shortcut is None: - pass - elif upsample_shortcut == "duplicating": - shortcut_block = ChannelDuplicatingPixelUnshuffleUpsample2D( - in_channels=width_list[stage_id + 1], out_channels=upsample_out_channels, factor=2 - ) - upsample_block = ResidualBlock(upsample_block, shortcut_block) - else: - raise ValueError(f"shortcut {upsample_shortcut} is not supported for upsample") + upsample_block = build_upsample_block( + block_type=upsample_block_type, + in_channels=block_out_channels[stage_id + 1], + out_channels=width if upsample_match_channel else block_out_channels[stage_id + 1], + shortcut=upsample_shortcut, + ) stage.append(upsample_block) - # stage main + stage_block_type = block_type[stage_id] if isinstance(block_type, list) else block_type stage_norm = norm[stage_id] if isinstance(norm, list) else norm stage_act = act[stage_id] if isinstance(act, list) else act - for d in range(depth): - current_block_type = stage_block_type[d] if isinstance(stage_block_type, list) else stage_block_type - if current_block_type == "ResBlock": - block = ResBlock( - in_channels=width, - out_channels=width, - kernel_size=3, - stride=1, - use_bias=(True, False), - norm=(None, stage_norm), - act_func=(stage_act, None), - ) - elif current_block_type == "EViTGLU": - block = EfficientViTBlock(width, norm=stage_norm, act_func=stage_act, local_module="GLUMBConv", scales=()) - elif current_block_type == "EViTS5GLU": - block = EfficientViTBlock(width, norm=stage_norm, act_func=stage_act, local_module="GLUMBConv", scales=(5,)) - else: - raise ValueError(f"block type {current_block_type} is not supported") - stage.append(block) - - self.stages.insert(0, nn.Sequential(*stage)) - self.stages = nn.ModuleList(self.stages) - - # project out - project_out_layers: list[nn.Module] = [] - if depth_list[0] > 0: - project_out_in_channels = width_list[0] - elif depth_list[1] > 0: - project_out_in_channels = width_list[1] - else: - raise ValueError(f"depth list {depth_list} is not supported for decoder project out") - if out_norm is None: - pass - elif out_norm == "rms2d": - project_out_layers.append(RMSNorm2d(num_features=project_out_in_channels)) - elif out_norm == "bn2d": - project_out_layers.append(BatchNorm2d(num_features=project_out_in_channels)) - else: - raise ValueError(f"norm {out_norm} is not supported for decoder project out") - project_out_layers.append(get_activation(out_act)) - if depth_list[0] > 0: - project_out_layers.append( - ConvLayer( - in_channels=project_out_in_channels, - out_channels=in_channels, - kernel_size=3, - stride=1, - use_bias=True, - norm=None, - act_func=None, + stage.extend( + build_stage_main( + width=width, + depth=depth, + block_type=stage_block_type, + norm=stage_norm, + act=stage_act, + input_width=( + width if upsample_match_channel else block_out_channels[min(stage_id + 1, num_stages - 1)] + ), ) ) - elif depth_list[1] > 0: - if upsample_block_type == "ConvPixelShuffle": - project_out_conv = ConvPixelShuffleUpsample2D( - in_channels=project_out_in_channels, out_channels=in_channels, kernel_size=3, factor=2 - ) - elif upsample_block_type == "InterpolateConv": - project_out_conv = Upsample2D(channels=project_out_in_channels, use_conv=True, out_channels=in_channels) - else: - raise ValueError(f"upsample_block_type {upsample_block_type} is not supported for upsampling") + self.stages.insert(0, OpSequential(stage)) + self.stages = nn.ModuleList(self.stages) + + factor = 1 if layers_per_block[0] > 0 else 2 - project_out_layers.append(project_out_conv) + self.norm_out = RMSNormNd(block_out_channels[0] if layers_per_block[0] > 0 else block_out_channels[1], eps=1e-5, elementwise_affine=True, bias=True, channel_dim=1) + self.conv_act = nn.ReLU() + self.conv_out = None + + if factor == 1: + self.conv_out = ConvLayer( + in_channels=block_out_channels[0] if layers_per_block[0] > 0 else block_out_channels[1], + out_channels=in_channels, + kernel_size=3, + stride=1, + use_bias=True, + norm=None, + act_func=None, + ) else: - raise ValueError(f"depth list {depth_list} is not supported for decoder project out") - self.project_out = nn.Sequential(*project_out_layers) + self.conv_out = build_upsample_block( + block_type=upsample_block_type, in_channels=block_out_channels[0] if layers_per_block[0] > 0 else block_out_channels[1], out_channels=in_channels, shortcut=None + ) def forward(self, x: torch.Tensor) -> torch.Tensor: - x = self.project_in(x) + x = self.conv_in(x) + self.norm_in(x) for stage in reversed(self.stages): - if len(stage) == 0: + if len(stage.op_list) == 0: continue x = stage(x) - x = self.project_out(x) + x = self.norm_out(x) + x = self.conv_act(x) + x = self.conv_out(x) return x -class DCAE(ModelMixin, ConfigMixin): +class AutoencoderDC(ModelMixin, ConfigMixin): @register_to_config def __init__( self, in_channels: int = 3, latent_channels: int = 32, + block_out_channels: Tuple[int, ...] = (128, 256, 512, 512, 1024, 1024), + encoder_layers_per_block: Tuple[int] = (2, 2, 2, 3, 3, 3), + decoder_layers_per_block: Tuple[int] = (3, 3, 3, 3, 3, 3), encoder_block_type: str | list[str] = "ResBlock", - encoder_width_list: list[int] = [128, 256, 512, 512, 1024, 1024], - encoder_depth_list: list[int] = [2, 2, 2, 2, 2, 2], - encoder_norm: str = "rms2d", - encoder_act: str = "silu", downsample_block_type: str = "ConvPixelUnshuffle", decoder_block_type: str | list[str] = "ResBlock", - decoder_width_list: list[int] = [128, 256, 512, 512, 1024, 1024], - decoder_depth_list: list[int] = [2, 2, 2, 2, 2, 2], decoder_norm: str = "rms2d", decoder_act: str = "silu", upsample_block_type: str = "ConvPixelShuffle", scaling_factor: Optional[float] = None, + **kwargs, ): super().__init__() self.encoder = Encoder( in_channels=in_channels, latent_channels=latent_channels, - width_list=encoder_width_list, - depth_list=encoder_depth_list, + block_out_channels=block_out_channels, + layers_per_block=encoder_layers_per_block, block_type=encoder_block_type, - norm=encoder_norm, - act=encoder_act, downsample_block_type=downsample_block_type, ) self.decoder = Decoder( in_channels=in_channels, latent_channels=latent_channels, - width_list=decoder_width_list, - depth_list=decoder_depth_list, + block_out_channels=block_out_channels, + layers_per_block=decoder_layers_per_block, block_type=decoder_block_type, norm=decoder_norm, act=decoder_act, @@ -627,14 +888,87 @@ def encode(self, x: torch.Tensor) -> torch.Tensor: x = self.encoder(x) return x - def decode(self, x: torch.Tensor, return_dict: bool = True) -> Union[DecoderOutput, torch.Tensor]: + def decode(self, x: torch.Tensor) -> torch.Tensor: x = self.decoder(x) - if not return_dict: - return x - else: - return DecoderOutput(sample=x) + return x def forward(self, x: torch.Tensor, global_step: int) -> torch.Tensor: x = self.encoder(x) x = self.decoder(x) return x, torch.tensor(0), {} + + +def dc_ae_f32c32(name: str) -> dict: + if name in ["dc-ae-f32c32-in-1.0", "dc-ae-f32c32-mix-1.0"]: + cfg = { + "latent_channels": 32, + "encoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViT_GLU", "EViT_GLU", "EViT_GLU"], + "block_out_channels": [128, 256, 512, 512, 1024, 1024], + "encoder_layers_per_block": [0, 4, 8, 2, 2, 2], + "decoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViT_GLU", "EViT_GLU", "EViT_GLU"], + "decoder_layers_per_block": [0, 5, 10, 2, 2, 2], + "decoder_norm": ["bn2d", "bn2d", "bn2d", "rms2d", "rms2d", "rms2d"], + "decoder_act": ["relu", "relu", "relu", "silu", "silu", "silu"], + } + elif name in ["dc-ae-f32c32-sana-1.0"]: + cfg = { + "latent_channels": 32, + "encoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViTS5_GLU", "EViTS5_GLU", "EViTS5_GLU"], + "block_out_channels": [128, 256, 512, 512, 1024, 1024], + "encoder_layers_per_block": [2, 2, 2, 3, 3, 3], + "downsample_block_type": "Conv", + "decoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViTS5_GLU", "EViTS5_GLU", "EViTS5_GLU"], + "decoder_layers_per_block": [3, 3, 3, 3, 3, 3], + "upsample_block_type": "InterpolateConv", + "scaling_factor": 0.41407, + } + else: + raise NotImplementedError + return cfg + + +def dc_ae_f64c128(name: str,) -> dict: + if name in ["dc-ae-f64c128-in-1.0", "dc-ae-f64c128-mix-1.0"]: + cfg = { + "latent_channels": 128, + "encoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViT_GLU", "EViT_GLU", "EViT_GLU", "EViT_GLU"], + "block_out_channels": [128, 256, 512, 512, 1024, 1024, 2048], + "encoder_layers_per_block": [0, 4, 8, 2, 2, 2, 2], + "decoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViT_GLU", "EViT_GLU", "EViT_GLU", "EViT_GLU"], + "decoder_layers_per_block": [0, 5, 10, 2, 2, 2, 2], + "decoder_norm": ["bn2d", "bn2d", "bn2d", "rms2d", "rms2d", "rms2d", "rms2d"], + "decoder_act": ["relu", "relu", "relu", "silu", "silu", "silu", "silu"], + } + else: + raise NotImplementedError + return cfg + + +def dc_ae_f128c512(name: str,) -> dict: + if name in ["dc-ae-f128c512-in-1.0", "dc-ae-f128c512-mix-1.0"]: + cfg = { + "latent_channels": 512, + "encoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViT_GLU", "EViT_GLU", "EViT_GLU", "EViT_GLU", "EViT_GLU"], + "block_out_channels": [128, 256, 512, 512, 1024, 1024, 2048, 2048], + "encoder_layers_per_block": [0, 4, 8, 2, 2, 2, 2, 2], + "decoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViT_GLU", "EViT_GLU", "EViT_GLU", "EViT_GLU", "EViT_GLU"], + "decoder_layers_per_block": [0, 5, 10, 2, 2, 2, 2, 2], + "decoder_norm": ["bn2d", "bn2d", "bn2d", "rms2d", "rms2d", "rms2d", "rms2d", "rms2d"], + "decoder_act": ["relu", "relu", "relu", "silu", "silu", "silu", "silu", "silu"], + } + else: + raise NotImplementedError + return cfg + + +REGISTERED_DCAE_MODEL: dict[str, Callable] = { + "dc-ae-f32c32-in-1.0": dc_ae_f32c32, + "dc-ae-f64c128-in-1.0": dc_ae_f64c128, + "dc-ae-f128c512-in-1.0": dc_ae_f128c512, + ################################################################################################# + "dc-ae-f32c32-mix-1.0": dc_ae_f32c32, + "dc-ae-f64c128-mix-1.0": dc_ae_f64c128, + "dc-ae-f128c512-mix-1.0": dc_ae_f128c512, + ################################################################################################# + "dc-ae-f32c32-sana-1.0": dc_ae_f32c32, +} diff --git a/src/diffusers/models/normalization.py b/src/diffusers/models/normalization.py index d5c9e8e87595..d6f63b536d4e 100644 --- a/src/diffusers/models/normalization.py +++ b/src/diffusers/models/normalization.py @@ -512,20 +512,24 @@ def forward(self, input): class RMSNorm(nn.Module): - def __init__(self, dim, eps: float, elementwise_affine: bool = True): + def __init__(self, dim, eps: float, elementwise_affine: bool = True, bias: bool = False): super().__init__() self.eps = eps + self.elementwise_affine = elementwise_affine if isinstance(dim, numbers.Integral): dim = (dim,) self.dim = torch.Size(dim) + self.weight = None + self.bias = None + if elementwise_affine: self.weight = nn.Parameter(torch.ones(dim)) - else: - self.weight = None + if bias: + self.bias = nn.Parameter(torch.zeros(dim)) def forward(self, hidden_states): input_dtype = hidden_states.dtype @@ -537,6 +541,8 @@ def forward(self, hidden_states): if self.weight.dtype in [torch.float16, torch.bfloat16]: hidden_states = hidden_states.to(self.weight.dtype) hidden_states = hidden_states * self.weight + if self.bias is not None: + hidden_states = hidden_states + self.bias else: hidden_states = hidden_states.to(input_dtype) @@ -568,24 +574,26 @@ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: return F.normalize(hidden_states, p=self.p, dim=self.dim, eps=self.eps) -class RMSNorm2d(nn.Module): - def __init__(self, num_features: int, eps: float = 1e-5, elementwise_affine: bool = True, bias: bool = True) -> None: +class RMSNormNd(nn.Module): + def __init__( + self, + dim: int, + eps: float, + elementwise_affine: bool = True, + bias: bool = False, + channel_dim: int = -1, + ) -> None: super().__init__() - self.num_features = num_features - self.eps = eps - self.elementwise_affine = elementwise_affine - if self.elementwise_affine: - self.weight = torch.nn.parameter.Parameter(torch.empty(self.num_features)) - if bias: - self.bias = torch.nn.parameter.Parameter(torch.empty(self.num_features)) - else: - self.register_parameter('bias', None) + + self.norm = RMSNorm(dim, eps=eps, elementwise_affine=elementwise_affine, bias=bias) + self.channel_dim = channel_dim + + def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: + if self.channel_dim != -1: + hidden_states = hidden_states.movedim(self.channel_dim, -1) + hidden_states = self.norm(hidden_states) + hidden_states = hidden_states.movedim(-1, self.channel_dim) else: - self.register_parameter('weight', None) - self.register_parameter('bias', None) + hidden_states = self.norm(hidden_states) - def forward(self, x: torch.Tensor) -> torch.Tensor: - x = (x / torch.sqrt(torch.square(x.float()).mean(dim=1, keepdim=True) + self.eps)).to(x.dtype) - if self.elementwise_affine: - x = x * self.weight.view(1, -1, 1, 1) + self.bias.view(1, -1, 1, 1) - return x + return hidden_states From 2d59056c6c8b9641c7a232bad60516ac0a871ecf Mon Sep 17 00:00:00 2001 From: lawrence-cj Date: Fri, 29 Nov 2024 02:23:52 +0800 Subject: [PATCH 035/141] make quality && make style; --- src/diffusers/models/attention.py | 11 ++++++++-- src/diffusers/models/autoencoders/__init__.py | 2 +- .../models/autoencoders/autoencoder_dc.py | 22 +++++++------------ 3 files changed, 18 insertions(+), 17 deletions(-) diff --git a/src/diffusers/models/attention.py b/src/diffusers/models/attention.py index ca6611a8977b..282976c5e976 100644 --- a/src/diffusers/models/attention.py +++ b/src/diffusers/models/attention.py @@ -22,7 +22,14 @@ from .activations import GEGLU, GELU, ApproximateGELU, FP32SiLU, SwiGLU, get_activation from .attention_processor import Attention, JointAttnProcessor2_0 from .embeddings import SinusoidalPositionalEmbedding -from .normalization import AdaLayerNorm, AdaLayerNormContinuous, AdaLayerNormZero, RMSNorm, SD35AdaLayerNormZeroX, RMSNorm2d +from .normalization import ( + AdaLayerNorm, + AdaLayerNormContinuous, + AdaLayerNormZero, + RMSNorm, + RMSNorm2d, + SD35AdaLayerNormZeroX, +) logger = logging.get_logger(__name__) @@ -1267,7 +1274,7 @@ def __init__( total_dim = heads * dim self.dim = dim - + qkv = [nn.Conv2d(in_channels=in_channels, out_channels=3 * total_dim, kernel_size=1, bias=use_bias[0])] if norm[0] is None: pass diff --git a/src/diffusers/models/autoencoders/__init__.py b/src/diffusers/models/autoencoders/__init__.py index c6f737ab25b5..7e983b526d8b 100644 --- a/src/diffusers/models/autoencoders/__init__.py +++ b/src/diffusers/models/autoencoders/__init__.py @@ -1,4 +1,5 @@ from .autoencoder_asym_kl import AsymmetricAutoencoderKL +from .autoencoder_dc import DCAE from .autoencoder_kl import AutoencoderKL from .autoencoder_kl_allegro import AutoencoderKLAllegro from .autoencoder_kl_cogvideox import AutoencoderKLCogVideoX @@ -7,5 +8,4 @@ from .autoencoder_oobleck import AutoencoderOobleck from .autoencoder_tiny import AutoencoderTiny from .consistency_decoder_vae import ConsistencyDecoderVAE -from .autoencoder_dc import DCAE from .vq_model import VQModel diff --git a/src/diffusers/models/autoencoders/autoencoder_dc.py b/src/diffusers/models/autoencoders/autoencoder_dc.py index 952d92d097f4..ac3cb899a782 100644 --- a/src/diffusers/models/autoencoders/autoencoder_dc.py +++ b/src/diffusers/models/autoencoders/autoencoder_dc.py @@ -13,25 +13,19 @@ # See the License for the specific language governing permissions and # limitations under the License. -from typing import Any, Optional, Callable, Union -from collections import OrderedDict +from typing import Optional, Union import torch import torch.nn as nn -import torch.nn.functional as F from torch.nn import BatchNorm2d -from huggingface_hub import PyTorchModelHubMixin -import ipdb from ...configuration_utils import ConfigMixin, register_to_config -from ..modeling_utils import ModelMixin - from ..activations import get_activation -from ..normalization import RMSNorm2d -from ..downsampling import ConvPixelUnshuffleDownsample2D, PixelUnshuffleChannelAveragingDownsample2D -from ..upsampling import ConvPixelShuffleUpsample2D, ChannelDuplicatingPixelUnshuffleUpsample2D, Upsample2D from ..attention import DCAELiteMLA - +from ..downsampling import ConvPixelUnshuffleDownsample2D, PixelUnshuffleChannelAveragingDownsample2D +from ..modeling_utils import ModelMixin +from ..normalization import RMSNorm2d +from ..upsampling import ChannelDuplicatingPixelUnshuffleUpsample2D, ConvPixelShuffleUpsample2D, Upsample2D from .vae import DecoderOutput @@ -267,7 +261,7 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: class Encoder(nn.Module): def __init__( - self, + self, in_channels: int, latent_channels: int, width_list: list[int] = [128, 256, 512, 512, 1024, 1024], @@ -291,7 +285,7 @@ def __init__( raise ValueError(f"len(depth_list) {len(depth_list)} and len(width_list) {len(width_list)} should be equal to num_stages {num_stages}") if not isinstance(block_type, (str, list)) or (isinstance(block_type, list) and len(block_type) != num_stages): raise ValueError(f"block_type should be either a str or a list of str with length {num_stages}, but got {block_type}") - + # project in if depth_list[0] > 0: project_in_block = nn.Conv2d( @@ -422,7 +416,7 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: class Decoder(nn.Module): def __init__( - self, + self, in_channels: int, latent_channels: int, in_shortcut: Optional[str] = "duplicating", From c1c02a20b724b4615053a784cd7336ad3d97ddca Mon Sep 17 00:00:00 2001 From: Aryan Date: Thu, 28 Nov 2024 20:01:24 +0100 Subject: [PATCH 036/141] quick push before dgx disappears again --- scripts/convert_dcae_to_diffusers.py | 11 +- .../models/autoencoders/autoencoder_dc.py | 337 ++++++++++-------- 2 files changed, 190 insertions(+), 158 deletions(-) diff --git a/scripts/convert_dcae_to_diffusers.py b/scripts/convert_dcae_to_diffusers.py index 699ef3f42b2c..e0a2a4119ec4 100644 --- a/scripts/convert_dcae_to_diffusers.py +++ b/scripts/convert_dcae_to_diffusers.py @@ -20,14 +20,15 @@ def remove_keys_(key: str, state_dict: Dict[str, Any]): VAE_KEYS_RENAME_DICT = { # common + "op_list.": "", "norm.": "norm.norm.", # encoder - "encoder.project_in": "encoder.conv_in", - "encoder.project_out.main.op_list.0": "encoder.conv_out", + "encoder.project_in.conv": "encoder.conv_in", + "encoder.project_out.main.0.conv": "encoder.conv_out", # decoder - "decoder.project_in.main": "decoder.conv_in", - "decoder.project_out.op_list.0": "decoder.norm_out.norm", - "decoder.project_out.op_list.2": "decoder.conv_out", + "decoder.project_in.main.conv": "decoder.conv_in", + "decoder.project_out.0": "decoder.norm_out.norm", + "decoder.project_out.2.conv": "decoder.conv_out", } VAE_SPECIAL_KEYS_REMAP = {} diff --git a/src/diffusers/models/autoencoders/autoencoder_dc.py b/src/diffusers/models/autoencoders/autoencoder_dc.py index 6a54dc1332ba..8c77097ed0ce 100644 --- a/src/diffusers/models/autoencoders/autoencoder_dc.py +++ b/src/diffusers/models/autoencoders/autoencoder_dc.py @@ -46,7 +46,7 @@ def build_norm(name: Optional[str]="bn2d", num_features: Optional[int]=None) -> return norm -class ConvLayer(nn.Module): +class DCConv2d(nn.Module): def __init__( self, in_channels: int, @@ -60,7 +60,7 @@ def __init__( norm="bn2d", act_func="relu", ): - super(ConvLayer, self).__init__() + super(DCConv2d, self).__init__() padding = kernel_size // 2 padding *= dilation @@ -90,33 +90,6 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: return x -class ConvPixelUnshuffleDownSampleLayer(nn.Module): - def __init__( - self, - in_channels: int, - out_channels: int, - kernel_size: int, - factor: int, - ): - super().__init__() - self.factor = factor - out_ratio = factor**2 - assert out_channels % out_ratio == 0 - self.conv = ConvLayer( - in_channels=in_channels, - out_channels=out_channels // out_ratio, - kernel_size=kernel_size, - use_bias=True, - norm=None, - act_func=None, - ) - - def forward(self, x: torch.Tensor) -> torch.Tensor: - x = self.conv(x) - x = F.pixel_unshuffle(x, self.factor) - return x - - class DownsamplePixelUnshuffleChannelAveraging(nn.Module): def __init__( self, @@ -138,7 +111,7 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: return x -class ConvPixelShuffleUpSampleLayer(nn.Module): +class UpsamplePixelShuffle(nn.Module): def __init__( self, in_channels: int, @@ -149,7 +122,7 @@ def __init__( super().__init__() self.factor = factor out_ratio = factor**2 - self.conv = ConvLayer( + self.conv = DCConv2d( in_channels=in_channels, out_channels=out_channels * out_ratio, kernel_size=kernel_size, @@ -164,7 +137,7 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: return x -class InterpolateConvUpSampleLayer(nn.Module): +class UpsampleInterpolate(nn.Module): def __init__( self, in_channels: int, @@ -176,7 +149,7 @@ def __init__( super().__init__() self.factor = factor self.mode = mode - self.conv = ConvLayer( + self.conv = DCConv2d( in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, @@ -191,7 +164,7 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: return x -class ChannelDuplicatingPixelUnshuffleUpSampleLayer(nn.Module): +class UpsampleChannelDuplicatingPixelUnshuffle(nn.Module): def __init__( self, in_channels: int, @@ -237,7 +210,7 @@ def __init__( mid_channels = round(in_channels * expand_ratio) if mid_channels is None else mid_channels self.glu_act = get_activation(act_func[1]) - self.inverted_conv = ConvLayer( + self.inverted_conv = DCConv2d( in_channels, mid_channels * 2, 1, @@ -245,7 +218,7 @@ def __init__( norm=norm[0], act_func=act_func[0], ) - self.depth_conv = ConvLayer( + self.depth_conv = DCConv2d( mid_channels * 2, mid_channels * 2, kernel_size, @@ -255,7 +228,7 @@ def __init__( norm=norm[1], act_func=None, ) - self.point_conv = ConvLayer( + self.point_conv = DCConv2d( mid_channels, out_channels, 1, @@ -296,7 +269,7 @@ def __init__( mid_channels = round(in_channels * expand_ratio) if mid_channels is None else mid_channels - self.conv1 = ConvLayer( + self.conv1 = DCConv2d( in_channels, mid_channels, kernel_size, @@ -305,7 +278,7 @@ def __init__( norm=norm[0], act_func=act_func[0], ) - self.conv2 = ConvLayer( + self.conv2 = DCConv2d( mid_channels, out_channels, kernel_size, @@ -349,7 +322,7 @@ def __init__( act_func = val2tuple(act_func, 2) self.dim = dim - self.qkv = ConvLayer( + self.qkv = DCConv2d( in_channels, 3 * total_dim, 1, @@ -375,7 +348,7 @@ def __init__( ) self.kernel_func = get_activation(kernel_func) - self.proj = ConvLayer( + self.proj = DCConv2d( total_dim * (1 + len(scales)), out_channels, 1, @@ -486,7 +459,7 @@ def __init__( context_module: str = "LiteMLA", local_module: str = "MBConv", ): - super(EfficientViTBlock, self).__init__() + super().__init__() if context_module == "LiteMLA": self.context_module = ResidualBlock( LiteMLA( @@ -560,21 +533,6 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: return res -class OpSequential(nn.Module): - def __init__(self, op_list: list[Optional[nn.Module]]): - super(OpSequential, self).__init__() - valid_op_list = [] - for op in op_list: - if op is not None: - valid_op_list.append(op) - self.op_list = nn.ModuleList(valid_op_list) - - def forward(self, x: torch.Tensor) -> torch.Tensor: - for op in self.op_list: - x = op(x) - return x - - def build_stage_main( width: int, depth: int, block_type: str | list[str], norm: str, act: str, input_width: int ) -> list[nn.Module]: @@ -611,56 +569,135 @@ def build_stage_main( return stage -def build_downsample_block(block_type: str, in_channels: int, out_channels: int, shortcut: Optional[str]) -> nn.Module: - if block_type == "Conv": - block = ConvLayer( +class DownsamplePixelUnshuffle(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + kernel_size: int, + factor: int, + ): + super().__init__() + self.factor = factor + out_ratio = factor**2 + assert out_channels % out_ratio == 0 + self.conv = DCConv2d( in_channels=in_channels, - out_channels=out_channels, - kernel_size=3, - stride=2, + out_channels=out_channels // out_ratio, + kernel_size=kernel_size, use_bias=True, norm=None, act_func=None, ) - elif block_type == "ConvPixelUnshuffle": - block = ConvPixelUnshuffleDownSampleLayer( - in_channels=in_channels, out_channels=out_channels, kernel_size=3, factor=2 - ) - else: - raise ValueError(f"block_type {block_type} is not supported for downsampling") - if shortcut is None: - pass - elif shortcut == "averaging": - shortcut_block = DownsamplePixelUnshuffleChannelAveraging( - in_channels=in_channels, out_channels=out_channels, factor=2 - ) - block = ResidualBlock(block, shortcut_block) - else: - raise ValueError(f"shortcut {shortcut} is not supported for downsample") - return block + def forward(self, x: torch.Tensor) -> torch.Tensor: + x = self.conv(x) + x = F.pixel_unshuffle(x, self.factor) + return x -def build_upsample_block(block_type: str, in_channels: int, out_channels: int, shortcut: Optional[str]) -> nn.Module: - if block_type == "ConvPixelShuffle": - block = ConvPixelShuffleUpSampleLayer( - in_channels=in_channels, out_channels=out_channels, kernel_size=3, factor=2 - ) - elif block_type == "InterpolateConv": - block = InterpolateConvUpSampleLayer( - in_channels=in_channels, out_channels=out_channels, kernel_size=3, factor=2 - ) - else: - raise ValueError(f"block_type {block_type} is not supported for upsampling") - if shortcut is None: - pass - elif shortcut == "duplicating": - shortcut_block = ChannelDuplicatingPixelUnshuffleUpSampleLayer( - in_channels=in_channels, out_channels=out_channels, factor=2 + +class DCDownBlock2d(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + kernel_size: int = 3, + downsample: bool = False, + shortcut: bool = True, + ) -> None: + super().__init__() + + self.downsample = downsample + self.factor = 2 + self.stride = 1 if downsample else 2 + + out_ratio = self.factor**2 + if downsample: + assert out_channels % out_ratio == 0 + out_channels = out_channels // out_ratio + + self.conv = nn.Conv2d( + in_channels, + out_channels, + kernel_size=(kernel_size, kernel_size), + stride=self.stride, + padding=kernel_size // 2, ) - block = ResidualBlock(block, shortcut_block) - else: - raise ValueError(f"shortcut {shortcut} is not supported for upsample") - return block + + self.shortcut = None + if shortcut: + self.shortcut = DownsamplePixelUnshuffleChannelAveraging( + in_channels=in_channels, out_channels=out_channels, factor=2 + ) + + def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: + x = self.conv(hidden_states) + if self.downsample: + x = F.pixel_unshuffle(x, self.factor) + if self.shortcut is not None: + hidden_states = x + self.shortcut(hidden_states) + else: + hidden_states = x + return hidden_states + + +class DCUpBlock2d(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + kernel_size: int = 3, + interpolate: bool = False, + shortcut: bool = True, + interpolation_mode: str = "nearest", + ) -> None: + super().__init__() + + self.interpolate = interpolate + self.interpolation_method = interpolation_mode + self.factor = 2 + self.stride = 1 + + out_ratio = self.factor ** 2 + if not interpolate: + out_channels = out_channels * out_ratio + + if interpolate: + nn.conv = DCConv2d( + in_channels=in_channels, + out_channels=out_channels, + kernel_size=kernel_size, + ) + else: + self.conv = DCConv2d( + in_channels=in_channels, + out_channels=out_channels, + kernel_size=kernel_size, + use_bias=True, + norm=None, + act_func=None, + ) + self.conv = UpsamplePixelShuffle( + in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, factor=2 + ) + + self.shortcut = None + if shortcut: + self.shortcut = UpsampleChannelDuplicatingPixelUnshuffle( + in_channels=in_channels, out_channels=out_channels, factor=2 + ) + + def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: + if self.interpolate: + x = torch.nn.functional.interpolate(x, scale_factor=self.factor, mode=self.interpolation_mode) + x = self.conv(x) + else: + x = self.conv(hidden_states) + if self.shortcut is not None: + hidden_states = x + self.shortcut(hidden_states) + else: + hidden_states = x + return hidden_states class Encoder(nn.Module): @@ -685,50 +722,49 @@ def __init__( factor = 1 if layers_per_block[0] > 0 else 2 if factor == 1: - self.conv_in = ConvLayer( - in_channels=in_channels, - out_channels=block_out_channels[0] if layers_per_block[0] > 0 else block_out_channels[1], + self.conv_in = nn.Conv2d( + in_channels, + block_out_channels[0] if layers_per_block[0] > 0 else block_out_channels[1], kernel_size=3, stride=1, - use_bias=True, - norm=None, - act_func=None, + padding=1, ) elif factor == 2: - self.conv_in = build_downsample_block( - block_type=downsample_block_type, in_channels=in_channels, out_channels=block_out_channels[0] if layers_per_block[0] > 0 else block_out_channels[1], shortcut=None + self.conv_in = DCDownBlock2d( + in_channels=in_channels, + out_channels=block_out_channels[0] if layers_per_block[0] > 0 else block_out_channels[1], + downsample=downsample_block_type == "ConvPixelUnshuffle", + shortcut=False, ) else: raise - self.stages: list[OpSequential] = [] + stages = [] for stage_id, (width, depth) in enumerate(zip(block_out_channels, layers_per_block)): stage_block_type = block_type[stage_id] if isinstance(block_type, list) else block_type - stage = build_stage_main( + current_stage = build_stage_main( width=width, depth=depth, block_type=stage_block_type, norm="rms2d", act="silu", input_width=width ) if stage_id < num_stages - 1 and depth > 0: - downsample_block = build_downsample_block( - block_type=downsample_block_type, + downsample_block = DCDownBlock2d( in_channels=width, out_channels=block_out_channels[stage_id + 1], - shortcut="averaging", + downsample=downsample_block_type == "ConvPixelUnshuffle", + shortcut=True, ) - stage.append(downsample_block) - self.stages.append(OpSequential(stage)) - self.stages = nn.ModuleList(self.stages) + current_stage.append(downsample_block) + stages.append(nn.Sequential(*current_stage)) + self.stages = nn.ModuleList(stages) - self.norm_out = DownsamplePixelUnshuffleChannelAveraging( - in_channels=block_out_channels[-1], out_channels=latent_channels, factor=1 - ) - self.conv_out = ConvLayer( - in_channels=block_out_channels[-1], - out_channels=latent_channels, + self.conv_out = nn.Conv2d( + block_out_channels[-1], + latent_channels, kernel_size=3, stride=1, - use_bias=True, - norm=None, - act_func=None, + padding=1, + ) + self.norm_out = DownsamplePixelUnshuffleChannelAveraging( + in_channels=block_out_channels[-1], out_channels=latent_channels, factor=1 ) def forward(self, x: torch.Tensor) -> torch.Tensor: @@ -752,7 +788,6 @@ def __init__( norm: str | list[str] = "rms2d", act: str | list[str] = "silu", upsample_block_type: str = "ConvPixelShuffle", - upsample_match_channel: bool = True, upsample_shortcut: str = "duplicating", ): super().__init__() @@ -766,48 +801,44 @@ def __init__( assert isinstance(norm, str) or (isinstance(norm, list) and len(norm) == num_stages) assert isinstance(act, str) or (isinstance(act, list) and len(act) == num_stages) - self.conv_in = ConvLayer( - in_channels=latent_channels, - out_channels=block_out_channels[-1], + self.conv_in = nn.Conv2d( + latent_channels, + block_out_channels[-1], kernel_size=3, stride=1, - use_bias=True, - norm=None, - act_func=None, + padding=1 ) - self.norm_in = ChannelDuplicatingPixelUnshuffleUpSampleLayer( + self.norm_in = UpsampleChannelDuplicatingPixelUnshuffle( in_channels=latent_channels, out_channels=block_out_channels[-1], factor=1 ) - self.stages: list[OpSequential] = [] + stages = [] for stage_id, (width, depth) in reversed(list(enumerate(zip(block_out_channels, layers_per_block)))): - stage = [] + current_stage = [] if stage_id < num_stages - 1 and depth > 0: - upsample_block = build_upsample_block( - block_type=upsample_block_type, - in_channels=block_out_channels[stage_id + 1], - out_channels=width if upsample_match_channel else block_out_channels[stage_id + 1], + upsample_block = DCUpBlock2d( + block_out_channels[stage_id + 1], + width, + interpolate=upsample_block_type == "InterpolateConv", shortcut=upsample_shortcut, ) - stage.append(upsample_block) + current_stage.append(upsample_block) stage_block_type = block_type[stage_id] if isinstance(block_type, list) else block_type stage_norm = norm[stage_id] if isinstance(norm, list) else norm stage_act = act[stage_id] if isinstance(act, list) else act - stage.extend( + current_stage.extend( build_stage_main( width=width, depth=depth, block_type=stage_block_type, norm=stage_norm, act=stage_act, - input_width=( - width if upsample_match_channel else block_out_channels[min(stage_id + 1, num_stages - 1)] - ), + input_width=width, ) ) - self.stages.insert(0, OpSequential(stage)) - self.stages = nn.ModuleList(self.stages) + stages.insert(0, nn.Sequential(*current_stage)) + self.stages = nn.ModuleList(stages) factor = 1 if layers_per_block[0] > 0 else 2 @@ -816,18 +847,18 @@ def __init__( self.conv_out = None if factor == 1: - self.conv_out = ConvLayer( - in_channels=block_out_channels[0] if layers_per_block[0] > 0 else block_out_channels[1], - out_channels=in_channels, + self.conv_out = nn.Conv2d( + block_out_channels[0] if layers_per_block[0] > 0 else block_out_channels[1], + in_channels, kernel_size=3, stride=1, - use_bias=True, - norm=None, - act_func=None, + padding=1, ) else: - self.conv_out = build_upsample_block( - block_type=upsample_block_type, in_channels=block_out_channels[0] if layers_per_block[0] > 0 else block_out_channels[1], out_channels=in_channels, shortcut=None + self.conv_out = DCUpBlock2d( + block_out_channels[0] if layers_per_block[0] > 0 else block_out_channels[1], + in_channels, + shortcut=False, ) def forward(self, x: torch.Tensor) -> torch.Tensor: From 1f8a3b3b4621faed2c10cd520ff0c81ace765f81 Mon Sep 17 00:00:00 2001 From: Aryan Date: Thu, 28 Nov 2024 20:24:24 +0100 Subject: [PATCH 037/141] update --- scripts/convert_dcae_to_diffusers.py | 9 +- .../models/autoencoders/autoencoder_dc.py | 156 +++++------------- 2 files changed, 48 insertions(+), 117 deletions(-) diff --git a/scripts/convert_dcae_to_diffusers.py b/scripts/convert_dcae_to_diffusers.py index e0a2a4119ec4..865daa25e632 100644 --- a/scripts/convert_dcae_to_diffusers.py +++ b/scripts/convert_dcae_to_diffusers.py @@ -20,13 +20,18 @@ def remove_keys_(key: str, state_dict: Dict[str, Any]): VAE_KEYS_RENAME_DICT = { # common + "main.": "", "op_list.": "", "norm.": "norm.norm.", + "depth_conv": "conv_depth", + "point_conv": "conv_point", + "inverted_conv": "conv_inverted", + "conv.conv.": "conv.", # encoder "encoder.project_in.conv": "encoder.conv_in", - "encoder.project_out.main.0.conv": "encoder.conv_out", + "encoder.project_out.0.conv": "encoder.conv_out", # decoder - "decoder.project_in.main.conv": "decoder.conv_in", + "decoder.project_in.conv": "decoder.conv_in", "decoder.project_out.0": "decoder.norm_out.norm", "decoder.project_out.2.conv": "decoder.conv_out", } diff --git a/src/diffusers/models/autoencoders/autoencoder_dc.py b/src/diffusers/models/autoencoders/autoencoder_dc.py index 8c77097ed0ce..b1af8d594a67 100644 --- a/src/diffusers/models/autoencoders/autoencoder_dc.py +++ b/src/diffusers/models/autoencoders/autoencoder_dc.py @@ -111,59 +111,6 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: return x -class UpsamplePixelShuffle(nn.Module): - def __init__( - self, - in_channels: int, - out_channels: int, - kernel_size: int, - factor: int, - ): - super().__init__() - self.factor = factor - out_ratio = factor**2 - self.conv = DCConv2d( - in_channels=in_channels, - out_channels=out_channels * out_ratio, - kernel_size=kernel_size, - use_bias=True, - norm=None, - act_func=None, - ) - - def forward(self, x: torch.Tensor) -> torch.Tensor: - x = self.conv(x) - x = F.pixel_shuffle(x, self.factor) - return x - - -class UpsampleInterpolate(nn.Module): - def __init__( - self, - in_channels: int, - out_channels: int, - kernel_size: int, - factor: int, - mode: str = "nearest", - ) -> None: - super().__init__() - self.factor = factor - self.mode = mode - self.conv = DCConv2d( - in_channels=in_channels, - out_channels=out_channels, - kernel_size=kernel_size, - use_bias=True, - norm=None, - act_func=None, - ) - - def forward(self, x: torch.Tensor) -> torch.Tensor: - x = torch.nn.functional.interpolate(x, scale_factor=self.factor, mode=self.mode) - x = self.conv(x) - return x - - class UpsampleChannelDuplicatingPixelUnshuffle(nn.Module): def __init__( self, @@ -184,11 +131,6 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: return x -class IdentityLayer(nn.Module): - def forward(self, x: torch.Tensor) -> torch.Tensor: - return x - - class GLUMBConv(nn.Module): def __init__( self, @@ -210,7 +152,7 @@ def __init__( mid_channels = round(in_channels * expand_ratio) if mid_channels is None else mid_channels self.glu_act = get_activation(act_func[1]) - self.inverted_conv = DCConv2d( + self.conv_inverted = DCConv2d( in_channels, mid_channels * 2, 1, @@ -218,7 +160,7 @@ def __init__( norm=norm[0], act_func=act_func[0], ) - self.depth_conv = DCConv2d( + self.conv_depth = DCConv2d( mid_channels * 2, mid_channels * 2, kernel_size, @@ -228,7 +170,7 @@ def __init__( norm=norm[1], act_func=None, ) - self.point_conv = DCConv2d( + self.conv_point = DCConv2d( mid_channels, out_channels, 1, @@ -238,15 +180,16 @@ def __init__( ) def forward(self, x: torch.Tensor) -> torch.Tensor: - x = self.inverted_conv(x) - x = self.depth_conv(x) + residual = x + x = self.conv_inverted(x) + x = self.conv_depth(x) x, gate = torch.chunk(x, 2, dim=1) gate = self.glu_act(gate) x = x * gate - x = self.point_conv(x) - return x + x = self.conv_point(x) + return x + residual class ResBlock(nn.Module): @@ -289,9 +232,10 @@ def __init__( ) def forward(self, x: torch.Tensor) -> torch.Tensor: + residual = x x = self.conv1(x) x = self.conv2(x) - return x + return x + residual class LiteMLA(nn.Module): @@ -357,7 +301,6 @@ def __init__( act_func=act_func[1], ) - @torch.autocast(device_type="cuda", enabled=False) def relu_linear_att(self, qkv: torch.Tensor) -> torch.Tensor: B, _, H, W = list(qkv.size()) @@ -429,6 +372,7 @@ def relu_quadratic_att(self, qkv: torch.Tensor) -> torch.Tensor: return out def forward(self, x: torch.Tensor) -> torch.Tensor: + residual = x # generate multi-scale q, k, v qkv = self.qkv(x) multi_scale_qkv = [qkv] @@ -443,7 +387,7 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: out = self.relu_quadratic_att(qkv) out = self.proj(out) - return out + return out + residual class EfficientViTBlock(nn.Module): @@ -461,30 +405,24 @@ def __init__( ): super().__init__() if context_module == "LiteMLA": - self.context_module = ResidualBlock( - LiteMLA( - in_channels=in_channels, - out_channels=in_channels, - heads_ratio=heads_ratio, - dim=dim, - norm=(None, norm), - scales=scales, - ), - IdentityLayer(), + self.context_module = LiteMLA( + in_channels=in_channels, + out_channels=in_channels, + heads_ratio=heads_ratio, + dim=dim, + norm=(None, norm), + scales=scales, ) else: raise ValueError(f"context_module {context_module} is not supported") if local_module == "GLUMBConv": - self.local_module = ResidualBlock( - GLUMBConv( - in_channels=in_channels, - out_channels=in_channels, - expand_ratio=expand_ratio, - use_bias=(True, True, False), - norm=(None, None, norm), - act_func=(act_func, act_func, None), - ), - IdentityLayer(), + self.local_module = GLUMBConv( + in_channels=in_channels, + out_channels=in_channels, + expand_ratio=expand_ratio, + use_bias=(True, True, False), + norm=(None, None, norm), + act_func=(act_func, act_func, None), ) else: raise NotImplementedError(f"local_module {local_module} is not supported") @@ -546,7 +484,7 @@ def build_stage_main( if current_block_type == "ResBlock": assert in_channels == out_channels - main_block = ResBlock( + block = ResBlock( in_channels=in_channels, out_channels=out_channels, kernel_size=3, @@ -555,7 +493,6 @@ def build_stage_main( norm=(None, norm), act_func=(act, None), ) - block = ResidualBlock(main_block, IdentityLayer()) elif current_block_type == "EViT_GLU": assert in_channels == out_channels block = EfficientViTBlock(in_channels, norm=norm, act_func=act, local_module="GLUMBConv", scales=()) @@ -619,7 +556,7 @@ def __init__( self.conv = nn.Conv2d( in_channels, out_channels, - kernel_size=(kernel_size, kernel_size), + kernel_size=kernel_size, stride=self.stride, padding=kernel_size // 2, ) @@ -654,7 +591,7 @@ def __init__( super().__init__() self.interpolate = interpolate - self.interpolation_method = interpolation_mode + self.interpolation_mode = interpolation_mode self.factor = 2 self.stride = 1 @@ -662,24 +599,13 @@ def __init__( if not interpolate: out_channels = out_channels * out_ratio - if interpolate: - nn.conv = DCConv2d( - in_channels=in_channels, - out_channels=out_channels, - kernel_size=kernel_size, - ) - else: - self.conv = DCConv2d( - in_channels=in_channels, - out_channels=out_channels, - kernel_size=kernel_size, - use_bias=True, - norm=None, - act_func=None, - ) - self.conv = UpsamplePixelShuffle( - in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, factor=2 - ) + self.conv = nn.Conv2d( + in_channels, + out_channels, + kernel_size=kernel_size, + stride=self.stride, + padding=kernel_size // 2, + ) self.shortcut = None if shortcut: @@ -689,14 +615,17 @@ def __init__( def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: if self.interpolate: - x = torch.nn.functional.interpolate(x, scale_factor=self.factor, mode=self.interpolation_mode) + x = F.interpolate(hidden_states, scale_factor=self.factor, mode=self.interpolation_mode) x = self.conv(x) else: x = self.conv(hidden_states) + x = F.pixel_shuffle(x, self.factor) + if self.shortcut is not None: hidden_states = x + self.shortcut(hidden_states) else: hidden_states = x + return hidden_states @@ -770,8 +699,6 @@ def __init__( def forward(self, x: torch.Tensor) -> torch.Tensor: x = self.conv_in(x) for stage in self.stages: - if len(stage.op_list) == 0: - continue x = stage(x) x = self.conv_out(x) + self.norm_out(x) return x @@ -858,14 +785,13 @@ def __init__( self.conv_out = DCUpBlock2d( block_out_channels[0] if layers_per_block[0] > 0 else block_out_channels[1], in_channels, + interpolate=upsample_block_type == "InterpolateConv", shortcut=False, ) def forward(self, x: torch.Tensor) -> torch.Tensor: x = self.conv_in(x) + self.norm_in(x) for stage in reversed(self.stages): - if len(stage.op_list) == 0: - continue x = stage(x) x = self.norm_out(x) x = self.conv_act(x) From 7b9d7e5513d8bef695cc5ede9161143c3ab0292a Mon Sep 17 00:00:00 2001 From: Aryan Date: Thu, 28 Nov 2024 20:24:36 +0100 Subject: [PATCH 038/141] make style --- scripts/convert_dcae_to_diffusers.py | 1 - src/diffusers/__init__.py | 2 +- src/diffusers/models/attention.py | 10 ++- .../models/autoencoders/autoencoder_dc.py | 82 +++++++++++-------- src/diffusers/models/normalization.py | 2 +- 5 files changed, 60 insertions(+), 37 deletions(-) diff --git a/scripts/convert_dcae_to_diffusers.py b/scripts/convert_dcae_to_diffusers.py index 865daa25e632..8a713aa41e5d 100644 --- a/scripts/convert_dcae_to_diffusers.py +++ b/scripts/convert_dcae_to_diffusers.py @@ -3,7 +3,6 @@ import torch from safetensors.torch import load_file -from transformers import T5EncoderModel, T5Tokenizer from diffusers import AutoencoderDC diff --git a/src/diffusers/__init__.py b/src/diffusers/__init__.py index 4e2b3c0baea8..f393167796d1 100644 --- a/src/diffusers/__init__.py +++ b/src/diffusers/__init__.py @@ -572,8 +572,8 @@ AllegroTransformer3DModel, AsymmetricAutoencoderKL, AuraFlowTransformer2DModel, - AutoencoderKL, AutoencoderDC, + AutoencoderKL, AutoencoderKLAllegro, AutoencoderKLCogVideoX, AutoencoderKLMochi, diff --git a/src/diffusers/models/attention.py b/src/diffusers/models/attention.py index 6a07f7659fd9..bef5dc73a96f 100644 --- a/src/diffusers/models/attention.py +++ b/src/diffusers/models/attention.py @@ -19,10 +19,16 @@ from ..utils import deprecate, logging from ..utils.torch_utils import maybe_allow_in_graph -from .activations import GEGLU, GELU, ApproximateGELU, FP32SiLU, SwiGLU, get_activation +from .activations import GEGLU, GELU, ApproximateGELU, FP32SiLU, SwiGLU from .attention_processor import Attention, JointAttnProcessor2_0 from .embeddings import SinusoidalPositionalEmbedding -from .normalization import AdaLayerNorm, AdaLayerNormContinuous, AdaLayerNormZero, RMSNorm, SD35AdaLayerNormZeroX, RMSNormNd +from .normalization import ( + AdaLayerNorm, + AdaLayerNormContinuous, + AdaLayerNormZero, + RMSNorm, + SD35AdaLayerNormZeroX, +) logger = logging.get_logger(__name__) diff --git a/src/diffusers/models/autoencoders/autoencoder_dc.py b/src/diffusers/models/autoencoders/autoencoder_dc.py index b1af8d594a67..8b06920c6cb0 100644 --- a/src/diffusers/models/autoencoders/autoencoder_dc.py +++ b/src/diffusers/models/autoencoders/autoencoder_dc.py @@ -13,7 +13,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -from typing import Any, Callable, Tuple, Optional +from typing import Any, Callable, Optional, Tuple import torch import torch.nn as nn @@ -34,7 +34,7 @@ def val2tuple(x: list | tuple | Any, min_len: int = 1) -> tuple: return tuple(x) -def build_norm(name: Optional[str]="bn2d", num_features: Optional[int]=None) -> Optional[nn.Module]: +def build_norm(name: Optional[str] = "bn2d", num_features: Optional[int] = None) -> Optional[nn.Module]: if name is None: norm = None elif name == "rms2d": @@ -481,7 +481,7 @@ def build_stage_main( in_channels = width if d > 0 else input_width out_channels = width - + if current_block_type == "ResBlock": assert in_channels == out_channels block = ResBlock( @@ -501,7 +501,7 @@ def build_stage_main( block = EfficientViTBlock(in_channels, norm=norm, act_func=act, local_module="GLUMBConv", scales=(5,)) else: raise ValueError(f"block_type {current_block_type} is not supported") - + stage.append(block) return stage @@ -543,7 +543,7 @@ def __init__( shortcut: bool = True, ) -> None: super().__init__() - + self.downsample = downsample self.factor = 2 self.stride = 1 if downsample else 2 @@ -552,7 +552,7 @@ def __init__( if downsample: assert out_channels % out_ratio == 0 out_channels = out_channels // out_ratio - + self.conv = nn.Conv2d( in_channels, out_channels, @@ -560,13 +560,13 @@ def __init__( stride=self.stride, padding=kernel_size // 2, ) - + self.shortcut = None if shortcut: self.shortcut = DownsamplePixelUnshuffleChannelAveraging( in_channels=in_channels, out_channels=out_channels, factor=2 ) - + def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: x = self.conv(hidden_states) if self.downsample: @@ -594,8 +594,8 @@ def __init__( self.interpolation_mode = interpolation_mode self.factor = 2 self.stride = 1 - - out_ratio = self.factor ** 2 + + out_ratio = self.factor**2 if not interpolate: out_channels = out_channels * out_ratio @@ -612,7 +612,7 @@ def __init__( self.shortcut = UpsampleChannelDuplicatingPixelUnshuffle( in_channels=in_channels, out_channels=out_channels, factor=2 ) - + def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: if self.interpolate: x = F.interpolate(hidden_states, scale_factor=self.factor, mode=self.interpolation_mode) @@ -620,12 +620,12 @@ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: else: x = self.conv(hidden_states) x = F.pixel_shuffle(x, self.factor) - + if self.shortcut is not None: hidden_states = x + self.shortcut(hidden_states) else: hidden_states = x - + return hidden_states @@ -644,9 +644,7 @@ def __init__( self.num_stages = num_stages assert len(layers_per_block) == num_stages assert len(block_out_channels) == num_stages - assert isinstance(block_type, str) or ( - isinstance(block_type, list) and len(block_type) == num_stages - ) + assert isinstance(block_type, str) or (isinstance(block_type, list) and len(block_type) == num_stages) factor = 1 if layers_per_block[0] > 0 else 2 @@ -722,19 +720,11 @@ def __init__( self.num_stages = num_stages assert len(layers_per_block) == num_stages assert len(block_out_channels) == num_stages - assert isinstance(block_type, str) or ( - isinstance(block_type, list) and len(block_type) == num_stages - ) + assert isinstance(block_type, str) or (isinstance(block_type, list) and len(block_type) == num_stages) assert isinstance(norm, str) or (isinstance(norm, list) and len(norm) == num_stages) assert isinstance(act, str) or (isinstance(act, list) and len(act) == num_stages) - self.conv_in = nn.Conv2d( - latent_channels, - block_out_channels[-1], - kernel_size=3, - stride=1, - padding=1 - ) + self.conv_in = nn.Conv2d(latent_channels, block_out_channels[-1], kernel_size=3, stride=1, padding=1) self.norm_in = UpsampleChannelDuplicatingPixelUnshuffle( in_channels=latent_channels, out_channels=block_out_channels[-1], factor=1 ) @@ -767,9 +757,15 @@ def __init__( stages.insert(0, nn.Sequential(*current_stage)) self.stages = nn.ModuleList(stages) - factor = 1 if layers_per_block[0] > 0 else 2 + factor = 1 if layers_per_block[0] > 0 else 2 - self.norm_out = RMSNormNd(block_out_channels[0] if layers_per_block[0] > 0 else block_out_channels[1], eps=1e-5, elementwise_affine=True, bias=True, channel_dim=1) + self.norm_out = RMSNormNd( + block_out_channels[0] if layers_per_block[0] > 0 else block_out_channels[1], + eps=1e-5, + elementwise_affine=True, + bias=True, + channel_dim=1, + ) self.conv_act = nn.ReLU() self.conv_out = None @@ -884,7 +880,9 @@ def dc_ae_f32c32(name: str) -> dict: return cfg -def dc_ae_f64c128(name: str,) -> dict: +def dc_ae_f64c128( + name: str, +) -> dict: if name in ["dc-ae-f64c128-in-1.0", "dc-ae-f64c128-mix-1.0"]: cfg = { "latent_channels": 128, @@ -901,14 +899,34 @@ def dc_ae_f64c128(name: str,) -> dict: return cfg -def dc_ae_f128c512(name: str,) -> dict: +def dc_ae_f128c512( + name: str, +) -> dict: if name in ["dc-ae-f128c512-in-1.0", "dc-ae-f128c512-mix-1.0"]: cfg = { "latent_channels": 512, - "encoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViT_GLU", "EViT_GLU", "EViT_GLU", "EViT_GLU", "EViT_GLU"], + "encoder_block_type": [ + "ResBlock", + "ResBlock", + "ResBlock", + "EViT_GLU", + "EViT_GLU", + "EViT_GLU", + "EViT_GLU", + "EViT_GLU", + ], "block_out_channels": [128, 256, 512, 512, 1024, 1024, 2048, 2048], "encoder_layers_per_block": [0, 4, 8, 2, 2, 2, 2, 2], - "decoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViT_GLU", "EViT_GLU", "EViT_GLU", "EViT_GLU", "EViT_GLU"], + "decoder_block_type": [ + "ResBlock", + "ResBlock", + "ResBlock", + "EViT_GLU", + "EViT_GLU", + "EViT_GLU", + "EViT_GLU", + "EViT_GLU", + ], "decoder_layers_per_block": [0, 5, 10, 2, 2, 2, 2, 2], "decoder_norm": ["bn2d", "bn2d", "bn2d", "rms2d", "rms2d", "rms2d", "rms2d", "rms2d"], "decoder_act": ["relu", "relu", "relu", "silu", "silu", "silu", "silu", "silu"], diff --git a/src/diffusers/models/normalization.py b/src/diffusers/models/normalization.py index d6f63b536d4e..b94cda63906a 100644 --- a/src/diffusers/models/normalization.py +++ b/src/diffusers/models/normalization.py @@ -525,7 +525,7 @@ def __init__(self, dim, eps: float, elementwise_affine: bool = True, bias: bool self.weight = None self.bias = None - + if elementwise_affine: self.weight = nn.Parameter(torch.ones(dim)) if bias: From bf6c211e653ad63829ffdada2b795efb092aedbf Mon Sep 17 00:00:00 2001 From: Aryan Date: Thu, 28 Nov 2024 21:38:09 +0100 Subject: [PATCH 039/141] update --- scripts/convert_dcae_to_diffusers.py | 75 ++++ .../models/autoencoders/autoencoder_dc.py | 389 +++++------------- 2 files changed, 170 insertions(+), 294 deletions(-) diff --git a/scripts/convert_dcae_to_diffusers.py b/scripts/convert_dcae_to_diffusers.py index 8a713aa41e5d..f2de94c19051 100644 --- a/scripts/convert_dcae_to_diffusers.py +++ b/scripts/convert_dcae_to_diffusers.py @@ -26,6 +26,13 @@ def remove_keys_(key: str, state_dict: Dict[str, Any]): "point_conv": "conv_point", "inverted_conv": "conv_inverted", "conv.conv.": "conv.", + "conv1.conv": "conv1", + "conv2.conv": "conv2", + "conv1.norm": "norm2", + "conv2.norm": "norm2", + "qkv.conv": "qkv", + "proj.conv": "proj_out", + "proj.norm": "norm_out", # encoder "encoder.project_in.conv": "encoder.conv_in", "encoder.project_out.0.conv": "encoder.conv_out", @@ -114,6 +121,74 @@ def convert_vae(ckpt_path: str, dtype: torch.dtype): return vae +def get_vae_config(name: str): + if name in ["dc-ae-f32c32-sana-1.0"]: + config = { + "latent_channels": 32, + "encoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViTS5_GLU", "EViTS5_GLU", "EViTS5_GLU"], + "block_out_channels": [128, 256, 512, 512, 1024, 1024], + "encoder_layers_per_block": [2, 2, 2, 3, 3, 3], + "downsample_block_type": "Conv", + "decoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViTS5_GLU", "EViTS5_GLU", "EViTS5_GLU"], + "decoder_layers_per_block": [3, 3, 3, 3, 3, 3], + "upsample_block_type": "InterpolateConv", + "scaling_factor": 0.41407, + } + elif name in ["dc-ae-f32c32-in-1.0", "dc-ae-f32c32-mix-1.0"]: + config = { + "latent_channels": 32, + "encoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViT_GLU", "EViT_GLU", "EViT_GLU"], + "block_out_channels": [128, 256, 512, 512, 1024, 1024], + "encoder_layers_per_block": [0, 4, 8, 2, 2, 2], + "decoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViT_GLU", "EViT_GLU", "EViT_GLU"], + "decoder_layers_per_block": [0, 5, 10, 2, 2, 2], + "decoder_norm": ["bn2d", "bn2d", "bn2d", "rms2d", "rms2d", "rms2d"], + "decoder_act": ["relu", "relu", "relu", "silu", "silu", "silu"], + } + elif name in ["dc-ae-f128c512-in-1.0", "dc-ae-f128c512-mix-1.0"]: + config = { + "latent_channels": 512, + "encoder_block_type": [ + "ResBlock", + "ResBlock", + "ResBlock", + "EViT_GLU", + "EViT_GLU", + "EViT_GLU", + "EViT_GLU", + "EViT_GLU", + ], + "block_out_channels": [128, 256, 512, 512, 1024, 1024, 2048, 2048], + "encoder_layers_per_block": [0, 4, 8, 2, 2, 2, 2, 2], + "decoder_block_type": [ + "ResBlock", + "ResBlock", + "ResBlock", + "EViT_GLU", + "EViT_GLU", + "EViT_GLU", + "EViT_GLU", + "EViT_GLU", + ], + "decoder_layers_per_block": [0, 5, 10, 2, 2, 2, 2, 2], + "decoder_norm": ["bn2d", "bn2d", "bn2d", "rms2d", "rms2d", "rms2d", "rms2d", "rms2d"], + "decoder_act": ["relu", "relu", "relu", "silu", "silu", "silu", "silu", "silu"], + } + elif name in ["dc-ae-f64c128-in-1.0", "dc-ae-f64c128-mix-1.0"]: + config = { + "latent_channels": 128, + "encoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViT_GLU", "EViT_GLU", "EViT_GLU", "EViT_GLU"], + "block_out_channels": [128, 256, 512, 512, 1024, 1024, 2048], + "encoder_layers_per_block": [0, 4, 8, 2, 2, 2, 2], + "decoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViT_GLU", "EViT_GLU", "EViT_GLU", "EViT_GLU"], + "decoder_layers_per_block": [0, 5, 10, 2, 2, 2, 2], + "decoder_norm": ["bn2d", "bn2d", "bn2d", "rms2d", "rms2d", "rms2d", "rms2d"], + "decoder_act": ["relu", "relu", "relu", "silu", "silu", "silu", "silu"], + } + + return config + + def get_args(): parser = argparse.ArgumentParser() parser.add_argument( diff --git a/src/diffusers/models/autoencoders/autoencoder_dc.py b/src/diffusers/models/autoencoders/autoencoder_dc.py index 8b06920c6cb0..b3083a6272b6 100644 --- a/src/diffusers/models/autoencoders/autoencoder_dc.py +++ b/src/diffusers/models/autoencoders/autoencoder_dc.py @@ -13,7 +13,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -from typing import Any, Callable, Optional, Tuple +from typing import Any, List, Optional, Tuple import torch import torch.nn as nn @@ -90,47 +90,6 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: return x -class DownsamplePixelUnshuffleChannelAveraging(nn.Module): - def __init__( - self, - in_channels: int, - out_channels: int, - factor: int, - ): - super().__init__() - self.in_channels = in_channels - self.out_channels = out_channels - self.factor = factor - assert in_channels * factor**2 % out_channels == 0 - self.group_size = in_channels * factor**2 // out_channels - - def forward(self, x: torch.Tensor) -> torch.Tensor: - x = F.pixel_unshuffle(x, self.factor) - x = x.unflatten(1, (-1, self.group_size)) - x = x.mean(dim=2) - return x - - -class UpsampleChannelDuplicatingPixelUnshuffle(nn.Module): - def __init__( - self, - in_channels: int, - out_channels: int, - factor: int, - ): - super().__init__() - self.in_channels = in_channels - self.out_channels = out_channels - self.factor = factor - assert out_channels * factor**2 % in_channels == 0 - self.repeats = out_channels * factor**2 // in_channels - - def forward(self, x: torch.Tensor) -> torch.Tensor: - x = x.repeat_interleave(self.repeats, dim=1) - x = F.pixel_shuffle(x, self.factor) - return x - - class GLUMBConv(nn.Module): def __init__( self, @@ -212,29 +171,32 @@ def __init__( mid_channels = round(in_channels * expand_ratio) if mid_channels is None else mid_channels - self.conv1 = DCConv2d( + self.conv1 = nn.Conv2d( in_channels, mid_channels, - kernel_size, - stride, - use_bias=use_bias[0], - norm=norm[0], - act_func=act_func[0], + kernel_size=kernel_size, + stride=stride, + padding=kernel_size // 2, + bias=use_bias[0], ) - self.conv2 = DCConv2d( + self.norm1 = build_norm(norm[0], num_features=mid_channels) if norm[0] is not None else nn.Identity() + self.act1 = get_activation(act_func[0]) if act_func[0] is not None else nn.Identity() + + self.conv2 = nn.Conv2d( mid_channels, out_channels, - kernel_size, - 1, - use_bias=use_bias[1], - norm=norm[1], - act_func=act_func[1], + kernel_size=kernel_size, + stride=1, + padding=kernel_size // 2, + bias=use_bias[1], ) + self.norm2 = build_norm(norm[1], num_features=out_channels) if norm[1] is not None else nn.Identity() + self.act2 = get_activation(act_func[1]) if act_func[1] is not None else nn.Identity() def forward(self, x: torch.Tensor) -> torch.Tensor: residual = x - x = self.conv1(x) - x = self.conv2(x) + x = self.act1(self.norm1(self.conv1(x))) + x = self.act2(self.norm2(self.conv2(x))) return x + residual @@ -266,14 +228,9 @@ def __init__( act_func = val2tuple(act_func, 2) self.dim = dim - self.qkv = DCConv2d( - in_channels, - 3 * total_dim, - 1, - use_bias=use_bias[0], - norm=norm[0], - act_func=act_func[0], - ) + + self.qkv = nn.Conv2d(in_channels, 3 * total_dim, kernel_size=1, stride=1, padding=0, bias=use_bias[0]) + self.aggreg = nn.ModuleList( [ nn.Sequential( @@ -292,14 +249,16 @@ def __init__( ) self.kernel_func = get_activation(kernel_func) - self.proj = DCConv2d( + self.proj_out = nn.Conv2d( total_dim * (1 + len(scales)), out_channels, - 1, - use_bias=use_bias[1], - norm=norm[1], - act_func=act_func[1], + kernel_size=1, + stride=1, + padding=0, + bias=use_bias[1], ) + self.norm_out = build_norm(norm[1], num_features=out_channels) or nn.Identity() + self.act_out = get_activation(act_func[1]) if act_func[1] is not None else nn.Identity() def relu_linear_att(self, qkv: torch.Tensor) -> torch.Tensor: B, _, H, W = list(qkv.size()) @@ -309,12 +268,7 @@ def relu_linear_att(self, qkv: torch.Tensor) -> torch.Tensor: qkv = torch.reshape( qkv, - ( - B, - -1, - 3 * self.dim, - H * W, - ), + (B, -1, 3 * self.dim, H * W), ) q, k, v = ( qkv[:, :, 0 : self.dim], @@ -342,15 +296,7 @@ def relu_linear_att(self, qkv: torch.Tensor) -> torch.Tensor: def relu_quadratic_att(self, qkv: torch.Tensor) -> torch.Tensor: B, _, H, W = list(qkv.size()) - qkv = torch.reshape( - qkv, - ( - B, - -1, - 3 * self.dim, - H * W, - ), - ) + qkv = torch.reshape(qkv, (B, -1, 3 * self.dim, H * W)) q, k, v = ( qkv[:, :, 0 : self.dim], qkv[:, :, self.dim : 2 * self.dim], @@ -375,9 +321,11 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: residual = x # generate multi-scale q, k, v qkv = self.qkv(x) + multi_scale_qkv = [qkv] for op in self.aggreg: multi_scale_qkv.append(op(qkv)) + qkv = torch.cat(multi_scale_qkv, dim=1) H, W = list(qkv.size())[-2:] @@ -385,7 +333,10 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: out = self.relu_linear_att(qkv).to(qkv.dtype) else: out = self.relu_quadratic_att(qkv) - out = self.proj(out) + + out = self.proj_out(out) + out = self.norm_out(out) + out = self.act_out(out) return out + residual @@ -415,6 +366,7 @@ def __init__( ) else: raise ValueError(f"context_module {context_module} is not supported") + if local_module == "GLUMBConv": self.local_module = GLUMBConv( in_channels=in_channels, @@ -433,46 +385,8 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: return x -################################################################################# -# Functional Blocks # -################################################################################# - - -class ResidualBlock(nn.Module): - def __init__( - self, - main: Optional[nn.Module], - shortcut: Optional[nn.Module], - post_act=None, - pre_norm: Optional[nn.Module] = None, - ): - super().__init__() - - self.pre_norm = pre_norm - self.main = main - self.shortcut = shortcut - self.post_act = get_activation(post_act) if post_act is not None else None - - def forward_main(self, x: torch.Tensor) -> torch.Tensor: - if self.pre_norm is None: - return self.main(x) - else: - return self.main(self.pre_norm(x)) - - def forward(self, x: torch.Tensor) -> torch.Tensor: - if self.main is None: - res = x - elif self.shortcut is None: - res = self.forward_main(x) - else: - res = self.forward_main(x) + self.shortcut(x) - if self.post_act: - res = self.post_act(res) - return res - - def build_stage_main( - width: int, depth: int, block_type: str | list[str], norm: str, act: str, input_width: int + width: int, depth: int, block_type: str | List[str], norm: str, act: str, input_width: int ) -> list[nn.Module]: assert isinstance(block_type, str) or (isinstance(block_type, list) and depth == len(block_type)) stage = [] @@ -506,33 +420,6 @@ def build_stage_main( return stage -class DownsamplePixelUnshuffle(nn.Module): - def __init__( - self, - in_channels: int, - out_channels: int, - kernel_size: int, - factor: int, - ): - super().__init__() - self.factor = factor - out_ratio = factor**2 - assert out_channels % out_ratio == 0 - self.conv = DCConv2d( - in_channels=in_channels, - out_channels=out_channels // out_ratio, - kernel_size=kernel_size, - use_bias=True, - norm=None, - act_func=None, - ) - - def forward(self, x: torch.Tensor) -> torch.Tensor: - x = self.conv(x) - x = F.pixel_unshuffle(x, self.factor) - return x - - class DCDownBlock2d(nn.Module): def __init__( self, @@ -547,6 +434,8 @@ def __init__( self.downsample = downsample self.factor = 2 self.stride = 1 if downsample else 2 + self.group_size = in_channels * self.factor**2 // out_channels + self.shortcut = shortcut out_ratio = self.factor**2 if downsample: @@ -561,20 +450,19 @@ def __init__( padding=kernel_size // 2, ) - self.shortcut = None - if shortcut: - self.shortcut = DownsamplePixelUnshuffleChannelAveraging( - in_channels=in_channels, out_channels=out_channels, factor=2 - ) - def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: x = self.conv(hidden_states) if self.downsample: x = F.pixel_unshuffle(x, self.factor) - if self.shortcut is not None: - hidden_states = x + self.shortcut(hidden_states) + + if self.shortcut: + y = F.pixel_unshuffle(hidden_states, self.factor) + y = y.unflatten(1, (-1, self.group_size)) + y = y.mean(dim=2) + hidden_states = x + y else: hidden_states = x + return hidden_states @@ -594,11 +482,13 @@ def __init__( self.interpolation_mode = interpolation_mode self.factor = 2 self.stride = 1 - out_ratio = self.factor**2 + if not interpolate: out_channels = out_channels * out_ratio + self.repeats = out_channels * self.factor**2 // in_channels + self.conv = nn.Conv2d( in_channels, out_channels, @@ -607,11 +497,7 @@ def __init__( padding=kernel_size // 2, ) - self.shortcut = None - if shortcut: - self.shortcut = UpsampleChannelDuplicatingPixelUnshuffle( - in_channels=in_channels, out_channels=out_channels, factor=2 - ) + self.shortcut = shortcut def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: if self.interpolate: @@ -621,8 +507,10 @@ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: x = self.conv(hidden_states) x = F.pixel_shuffle(x, self.factor) - if self.shortcut is not None: - hidden_states = x + self.shortcut(hidden_states) + if self.shortcut: + y = hidden_states.repeat_interleave(self.repeats, dim=1) + y = F.pixel_shuffle(y, self.factor) + hidden_states = x + y else: hidden_states = x @@ -634,9 +522,9 @@ def __init__( self, in_channels: int, latent_channels: int, - block_out_channels: list[int] = [128, 256, 512, 512, 1024, 1024], - layers_per_block: list[int] = [2, 2, 2, 2, 2, 2], - block_type: str | list[str] = "ResBlock", + block_out_channels: List[int] = [128, 256, 512, 512, 1024, 1024], + layers_per_block: List[int] = [2, 2, 2, 2, 2, 2], + block_type: str | List[str] = "ResBlock", downsample_block_type: str = "ConvPixelUnshuffle", ): super().__init__() @@ -690,16 +578,22 @@ def __init__( stride=1, padding=1, ) - self.norm_out = DownsamplePixelUnshuffleChannelAveraging( - in_channels=block_out_channels[-1], out_channels=latent_channels, factor=1 - ) + self.norm_factor = 1 + norm_in_channels = block_out_channels[-1] + norm_out_channels = latent_channels + self.norm_group_size = norm_in_channels * self.norm_factor**2 // norm_out_channels - def forward(self, x: torch.Tensor) -> torch.Tensor: - x = self.conv_in(x) + def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: + hidden_states = self.conv_in(hidden_states) for stage in self.stages: - x = stage(x) - x = self.conv_out(x) + self.norm_out(x) - return x + hidden_states = stage(hidden_states) + + x = F.pixel_unshuffle(hidden_states, self.norm_factor) + x = x.unflatten(1, (-1, self.norm_group_size)) + x = x.mean(dim=2) + + hidden_states = self.conv_out(hidden_states) + x + return hidden_states class Decoder(nn.Module): @@ -707,11 +601,11 @@ def __init__( self, in_channels: int, latent_channels: int, - block_out_channels: list[int] = [128, 256, 512, 512, 1024, 1024], - layers_per_block: list[int] = [2, 2, 2, 2, 2, 2], - block_type: str | list[str] = "ResBlock", - norm: str | list[str] = "rms2d", - act: str | list[str] = "silu", + block_out_channels: List[int] = [128, 256, 512, 512, 1024, 1024], + layers_per_block: List[int] = [2, 2, 2, 2, 2, 2], + block_type: str | List[str] = "ResBlock", + norm: str | List[str] = "rms2d", + act: str | List[str] = "silu", upsample_block_type: str = "ConvPixelShuffle", upsample_shortcut: str = "duplicating", ): @@ -725,9 +619,10 @@ def __init__( assert isinstance(act, str) or (isinstance(act, list) and len(act) == num_stages) self.conv_in = nn.Conv2d(latent_channels, block_out_channels[-1], kernel_size=3, stride=1, padding=1) - self.norm_in = UpsampleChannelDuplicatingPixelUnshuffle( - in_channels=latent_channels, out_channels=block_out_channels[-1], factor=1 - ) + + self.norm_factor = 1 + # TODO(aryan): Make sure this is divisible + self.norm_repeats = block_out_channels[-1] * self.norm_factor**2 // latent_channels stages = [] for stage_id, (width, depth) in reversed(list(enumerate(zip(block_out_channels, layers_per_block)))): @@ -785,14 +680,19 @@ def __init__( shortcut=False, ) - def forward(self, x: torch.Tensor) -> torch.Tensor: - x = self.conv_in(x) + self.norm_in(x) + def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: + x = hidden_states.repeat_interleave(self.norm_repeats, dim=1) + x = F.pixel_shuffle(x, self.norm_factor) + + hidden_states = self.conv_in(hidden_states) + x + for stage in reversed(self.stages): - x = stage(x) - x = self.norm_out(x) - x = self.conv_act(x) - x = self.conv_out(x) - return x + hidden_states = stage(hidden_states) + + hidden_states = self.norm_out(hidden_states) + hidden_states = self.conv_act(hidden_states) + hidden_states = self.conv_out(hidden_states) + return hidden_states class AutoencoderDC(ModelMixin, ConfigMixin): @@ -804,14 +704,13 @@ def __init__( block_out_channels: Tuple[int, ...] = (128, 256, 512, 512, 1024, 1024), encoder_layers_per_block: Tuple[int] = (2, 2, 2, 3, 3, 3), decoder_layers_per_block: Tuple[int] = (3, 3, 3, 3, 3, 3), - encoder_block_type: str | list[str] = "ResBlock", + encoder_block_type: str | List[str] = "ResBlock", downsample_block_type: str = "ConvPixelUnshuffle", - decoder_block_type: str | list[str] = "ResBlock", + decoder_block_type: str | List[str] = "ResBlock", decoder_norm: str = "rms2d", decoder_act: str = "silu", upsample_block_type: str = "ConvPixelShuffle", scaling_factor: Optional[float] = None, - **kwargs, ): super().__init__() self.encoder = Encoder( @@ -849,101 +748,3 @@ def forward(self, x: torch.Tensor, global_step: int) -> torch.Tensor: x = self.encoder(x) x = self.decoder(x) return x, torch.tensor(0), {} - - -def dc_ae_f32c32(name: str) -> dict: - if name in ["dc-ae-f32c32-in-1.0", "dc-ae-f32c32-mix-1.0"]: - cfg = { - "latent_channels": 32, - "encoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViT_GLU", "EViT_GLU", "EViT_GLU"], - "block_out_channels": [128, 256, 512, 512, 1024, 1024], - "encoder_layers_per_block": [0, 4, 8, 2, 2, 2], - "decoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViT_GLU", "EViT_GLU", "EViT_GLU"], - "decoder_layers_per_block": [0, 5, 10, 2, 2, 2], - "decoder_norm": ["bn2d", "bn2d", "bn2d", "rms2d", "rms2d", "rms2d"], - "decoder_act": ["relu", "relu", "relu", "silu", "silu", "silu"], - } - elif name in ["dc-ae-f32c32-sana-1.0"]: - cfg = { - "latent_channels": 32, - "encoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViTS5_GLU", "EViTS5_GLU", "EViTS5_GLU"], - "block_out_channels": [128, 256, 512, 512, 1024, 1024], - "encoder_layers_per_block": [2, 2, 2, 3, 3, 3], - "downsample_block_type": "Conv", - "decoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViTS5_GLU", "EViTS5_GLU", "EViTS5_GLU"], - "decoder_layers_per_block": [3, 3, 3, 3, 3, 3], - "upsample_block_type": "InterpolateConv", - "scaling_factor": 0.41407, - } - else: - raise NotImplementedError - return cfg - - -def dc_ae_f64c128( - name: str, -) -> dict: - if name in ["dc-ae-f64c128-in-1.0", "dc-ae-f64c128-mix-1.0"]: - cfg = { - "latent_channels": 128, - "encoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViT_GLU", "EViT_GLU", "EViT_GLU", "EViT_GLU"], - "block_out_channels": [128, 256, 512, 512, 1024, 1024, 2048], - "encoder_layers_per_block": [0, 4, 8, 2, 2, 2, 2], - "decoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViT_GLU", "EViT_GLU", "EViT_GLU", "EViT_GLU"], - "decoder_layers_per_block": [0, 5, 10, 2, 2, 2, 2], - "decoder_norm": ["bn2d", "bn2d", "bn2d", "rms2d", "rms2d", "rms2d", "rms2d"], - "decoder_act": ["relu", "relu", "relu", "silu", "silu", "silu", "silu"], - } - else: - raise NotImplementedError - return cfg - - -def dc_ae_f128c512( - name: str, -) -> dict: - if name in ["dc-ae-f128c512-in-1.0", "dc-ae-f128c512-mix-1.0"]: - cfg = { - "latent_channels": 512, - "encoder_block_type": [ - "ResBlock", - "ResBlock", - "ResBlock", - "EViT_GLU", - "EViT_GLU", - "EViT_GLU", - "EViT_GLU", - "EViT_GLU", - ], - "block_out_channels": [128, 256, 512, 512, 1024, 1024, 2048, 2048], - "encoder_layers_per_block": [0, 4, 8, 2, 2, 2, 2, 2], - "decoder_block_type": [ - "ResBlock", - "ResBlock", - "ResBlock", - "EViT_GLU", - "EViT_GLU", - "EViT_GLU", - "EViT_GLU", - "EViT_GLU", - ], - "decoder_layers_per_block": [0, 5, 10, 2, 2, 2, 2, 2], - "decoder_norm": ["bn2d", "bn2d", "bn2d", "rms2d", "rms2d", "rms2d", "rms2d", "rms2d"], - "decoder_act": ["relu", "relu", "relu", "silu", "silu", "silu", "silu", "silu"], - } - else: - raise NotImplementedError - return cfg - - -REGISTERED_DCAE_MODEL: dict[str, Callable] = { - "dc-ae-f32c32-in-1.0": dc_ae_f32c32, - "dc-ae-f64c128-in-1.0": dc_ae_f64c128, - "dc-ae-f128c512-in-1.0": dc_ae_f128c512, - ################################################################################################# - "dc-ae-f32c32-mix-1.0": dc_ae_f32c32, - "dc-ae-f64c128-mix-1.0": dc_ae_f64c128, - "dc-ae-f128c512-mix-1.0": dc_ae_f128c512, - ################################################################################################# - "dc-ae-f32c32-sana-1.0": dc_ae_f32c32, -} From a2ec5f81aca5e7ac22c7b9d9e8e30d8d21c50f61 Mon Sep 17 00:00:00 2001 From: Aryan Date: Thu, 28 Nov 2024 22:01:46 +0100 Subject: [PATCH 040/141] update --- src/diffusers/models/downsampling.py | 47 ---------------------------- src/diffusers/models/upsampling.py | 44 -------------------------- 2 files changed, 91 deletions(-) diff --git a/src/diffusers/models/downsampling.py b/src/diffusers/models/downsampling.py index 479e88ba374a..3ac8953e3dcc 100644 --- a/src/diffusers/models/downsampling.py +++ b/src/diffusers/models/downsampling.py @@ -285,53 +285,6 @@ def forward(self, inputs: torch.Tensor) -> torch.Tensor: return F.conv2d(inputs, weight, stride=2) -class ConvPixelUnshuffleDownsample2D(nn.Module): - def __init__( - self, - in_channels: int, - out_channels: int, - kernel_size: int, - factor: int, - ): - super().__init__() - self.factor = factor - out_ratio = factor**2 - assert out_channels % out_ratio == 0 - self.conv = nn.Conv2d( - in_channels=in_channels, - out_channels=out_channels // out_ratio, - kernel_size=kernel_size, - padding=kernel_size // 2, - ) - - def forward(self, x: torch.Tensor) -> torch.Tensor: - x = self.conv(x) - x = F.pixel_unshuffle(x, self.factor) - return x - - -class PixelUnshuffleChannelAveragingDownsample2D(nn.Module): - def __init__( - self, - in_channels: int, - out_channels: int, - factor: int, - ): - super().__init__() - self.in_channels = in_channels - self.out_channels = out_channels - self.factor = factor - assert in_channels * factor**2 % out_channels == 0 - self.group_size = in_channels * factor**2 // out_channels - - def forward(self, x: torch.Tensor) -> torch.Tensor: - x = F.pixel_unshuffle(x, self.factor) - B, C, H, W = x.shape - x = x.view(B, self.out_channels, self.group_size, H, W) - x = x.mean(dim=2) - return x - - class CogVideoXDownsample3D(nn.Module): # Todo: Wait for paper relase. r""" diff --git a/src/diffusers/models/upsampling.py b/src/diffusers/models/upsampling.py index e24900e7a022..cf07e45b0c5c 100644 --- a/src/diffusers/models/upsampling.py +++ b/src/diffusers/models/upsampling.py @@ -348,50 +348,6 @@ def forward(self, inputs: torch.Tensor) -> torch.Tensor: return F.conv_transpose2d(inputs, weight, stride=2, padding=self.pad * 2 + 1) -class ConvPixelShuffleUpsample2D(nn.Module): - def __init__( - self, - in_channels: int, - out_channels: int, - kernel_size: int, - factor: int, - ): - super().__init__() - self.factor = factor - out_ratio = factor**2 - self.conv = nn.Conv2d( - in_channels=in_channels, - out_channels=out_channels * out_ratio, - kernel_size=kernel_size, - padding=kernel_size // 2, - ) - - def forward(self, x: torch.Tensor) -> torch.Tensor: - x = self.conv(x) - x = F.pixel_shuffle(x, self.factor) - return x - - -class ChannelDuplicatingPixelUnshuffleUpsample2D(nn.Module): - def __init__( - self, - in_channels: int, - out_channels: int, - factor: int, - ): - super().__init__() - self.in_channels = in_channels - self.out_channels = out_channels - self.factor = factor - assert out_channels * factor**2 % in_channels == 0 - self.repeats = out_channels * factor**2 // in_channels - - def forward(self, x: torch.Tensor) -> torch.Tensor: - x = x.repeat_interleave(self.repeats, dim=1) - x = F.pixel_shuffle(x, self.factor) - return x - - class CogVideoXUpsample3D(nn.Module): r""" A 3D Upsample layer using in CogVideoX by Tsinghua University & ZhipuAI # Todo: Wait for paper relase. From f5876c5bc4fd57ae754cdbbd6f40ef276279f45a Mon Sep 17 00:00:00 2001 From: Aryan Date: Thu, 28 Nov 2024 22:13:21 +0100 Subject: [PATCH 041/141] fix --- scripts/convert_dcae_to_diffusers.py | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/scripts/convert_dcae_to_diffusers.py b/scripts/convert_dcae_to_diffusers.py index f2de94c19051..bce7767a1342 100644 --- a/scripts/convert_dcae_to_diffusers.py +++ b/scripts/convert_dcae_to_diffusers.py @@ -28,7 +28,7 @@ def remove_keys_(key: str, state_dict: Dict[str, Any]): "conv.conv.": "conv.", "conv1.conv": "conv1", "conv2.conv": "conv2", - "conv1.norm": "norm2", + "conv1.norm": "norm1", "conv2.norm": "norm2", "qkv.conv": "qkv", "proj.conv": "proj_out", @@ -90,14 +90,11 @@ def convert_vae(ckpt_path: str, dtype: torch.dtype): vae = AutoencoderDC( in_channels=3, latent_channels=32, - encoder_width_list=[128, 256, 512, 512, 1024, 1024], - encoder_depth_list=[2, 2, 2, 3, 3, 3], + block_out_channels=[128, 256, 512, 512, 1024, 1024], + encoder_layers_per_block=[2, 2, 2, 3, 3, 3], encoder_block_type=["ResBlock", "ResBlock", "ResBlock", "EViTS5_GLU", "EViTS5_GLU", "EViTS5_GLU"], - encoder_norm="rms2d", - encoder_act="silu", downsample_block_type="Conv", - decoder_width_list=[128, 256, 512, 512, 1024, 1024], - decoder_depth_list=[3, 3, 3, 3, 3, 3], + decoder_layers_per_block=[3, 3, 3, 3, 3, 3], decoder_block_type=["ResBlock", "ResBlock", "ResBlock", "EViTS5_GLU", "EViTS5_GLU", "EViTS5_GLU"], decoder_norm="rms2d", decoder_act="silu", From 44034a6f246ca96f0e83cdbedeaec4f642c95040 Mon Sep 17 00:00:00 2001 From: Aryan Date: Fri, 29 Nov 2024 15:50:26 +0100 Subject: [PATCH 042/141] refactor --- scripts/convert_dcae_to_diffusers.py | 7 +- .../models/autoencoders/autoencoder_dc.py | 299 +++++------------- 2 files changed, 84 insertions(+), 222 deletions(-) diff --git a/scripts/convert_dcae_to_diffusers.py b/scripts/convert_dcae_to_diffusers.py index bce7767a1342..0bd27b4a9612 100644 --- a/scripts/convert_dcae_to_diffusers.py +++ b/scripts/convert_dcae_to_diffusers.py @@ -22,9 +22,10 @@ def remove_keys_(key: str, state_dict: Dict[str, Any]): "main.": "", "op_list.": "", "norm.": "norm.norm.", - "depth_conv": "conv_depth", - "point_conv": "conv_point", - "inverted_conv": "conv_inverted", + "depth_conv.conv": "conv_depth", + "inverted_conv.conv": "conv_inverted", + "point_conv.conv": "conv_point", + "point_conv.norm": "norm", "conv.conv.": "conv.", "conv1.conv": "conv1", "conv2.conv": "conv2", diff --git a/src/diffusers/models/autoencoders/autoencoder_dc.py b/src/diffusers/models/autoencoders/autoencoder_dc.py index b3083a6272b6..4f5676b83de2 100644 --- a/src/diffusers/models/autoencoders/autoencoder_dc.py +++ b/src/diffusers/models/autoencoders/autoencoder_dc.py @@ -46,108 +46,32 @@ def build_norm(name: Optional[str] = "bn2d", num_features: Optional[int] = None) return norm -class DCConv2d(nn.Module): - def __init__( - self, - in_channels: int, - out_channels: int, - kernel_size=3, - stride=1, - dilation=1, - groups=1, - use_bias=False, - dropout=0, - norm="bn2d", - act_func="relu", - ): - super(DCConv2d, self).__init__() - - padding = kernel_size // 2 - padding *= dilation - - self.dropout = nn.Dropout2d(dropout, inplace=False) if dropout > 0 else None - self.conv = nn.Conv2d( - in_channels, - out_channels, - kernel_size=(kernel_size, kernel_size), - stride=(stride, stride), - padding=padding, - dilation=(dilation, dilation), - groups=groups, - bias=use_bias, - ) - self.norm = build_norm(norm, num_features=out_channels) - self.act = get_activation(act_func) if act_func is not None else None - - def forward(self, x: torch.Tensor) -> torch.Tensor: - if self.dropout is not None: - x = self.dropout(x) - x = self.conv(x) - if self.norm: - x = self.norm(x) - if self.act: - x = self.act(x) - return x - - class GLUMBConv(nn.Module): - def __init__( - self, - in_channels: int, - out_channels: int, - kernel_size=3, - stride=1, - mid_channels=None, - expand_ratio=6, - use_bias=False, - norm=(None, None, "ln2d"), - act_func=("silu", "silu", None), - ): + def __init__(self, in_channels: int, out_channels: int) -> None: super().__init__() - use_bias = val2tuple(use_bias, 3) - norm = val2tuple(norm, 3) - act_func = val2tuple(act_func, 3) - mid_channels = round(in_channels * expand_ratio) if mid_channels is None else mid_channels + hidden_channels = 4 * in_channels - self.glu_act = get_activation(act_func[1]) - self.conv_inverted = DCConv2d( - in_channels, - mid_channels * 2, - 1, - use_bias=use_bias[0], - norm=norm[0], - act_func=act_func[0], - ) - self.conv_depth = DCConv2d( - mid_channels * 2, - mid_channels * 2, - kernel_size, - stride=stride, - groups=mid_channels * 2, - use_bias=use_bias[1], - norm=norm[1], - act_func=None, - ) - self.conv_point = DCConv2d( - mid_channels, - out_channels, - 1, - use_bias=use_bias[2], - norm=norm[2], - act_func=act_func[2], - ) + self.nonlinearity = nn.SiLU() + + self.conv_inverted = nn.Conv2d(in_channels, hidden_channels * 2, 1, 1, 0) + self.conv_depth = nn.Conv2d(hidden_channels * 2, hidden_channels * 2, 3, 1, 1, groups=hidden_channels * 2) + self.conv_point = nn.Conv2d(hidden_channels, out_channels, 1, 1, 0, bias=False) + self.norm = RMSNormNd(out_channels, eps=1e-5, elementwise_affine=True, bias=True, channel_dim=1) def forward(self, x: torch.Tensor) -> torch.Tensor: residual = x + x = self.conv_inverted(x) - x = self.conv_depth(x) + x = self.nonlinearity(x) + x = self.conv_depth(x) x, gate = torch.chunk(x, 2, dim=1) - gate = self.glu_act(gate) - x = x * gate + x = x * self.nonlinearity(gate) x = self.conv_point(x) + x = self.norm(x) + return x + residual @@ -156,47 +80,29 @@ def __init__( self, in_channels: int, out_channels: int, - kernel_size=3, - stride=1, - mid_channels=None, - expand_ratio=1, - use_bias=False, norm=("bn2d", "bn2d"), act_func=("relu6", None), - ): + ) -> None: super().__init__() - use_bias = val2tuple(use_bias, 2) + norm = val2tuple(norm, 2) act_func = val2tuple(act_func, 2) - mid_channels = round(in_channels * expand_ratio) if mid_channels is None else mid_channels + self.nonlinearity = get_activation(act_func[0]) if act_func[0] is not None else nn.Identity() - self.conv1 = nn.Conv2d( - in_channels, - mid_channels, - kernel_size=kernel_size, - stride=stride, - padding=kernel_size // 2, - bias=use_bias[0], - ) - self.norm1 = build_norm(norm[0], num_features=mid_channels) if norm[0] is not None else nn.Identity() - self.act1 = get_activation(act_func[0]) if act_func[0] is not None else nn.Identity() + self.conv1 = nn.Conv2d(in_channels, in_channels, 3, 1, 1) + self.norm1 = build_norm(norm[0], num_features=in_channels) if norm[0] is not None else nn.Identity() - self.conv2 = nn.Conv2d( - mid_channels, - out_channels, - kernel_size=kernel_size, - stride=1, - padding=kernel_size // 2, - bias=use_bias[1], - ) + self.conv2 = nn.Conv2d(in_channels, out_channels, 3, 1, 1, bias=False) self.norm2 = build_norm(norm[1], num_features=out_channels) if norm[1] is not None else nn.Identity() - self.act2 = get_activation(act_func[1]) if act_func[1] is not None else nn.Identity() def forward(self, x: torch.Tensor) -> torch.Tensor: residual = x - x = self.act1(self.norm1(self.conv1(x))) - x = self.act2(self.norm2(self.conv2(x))) + x = self.conv1(x) + x = self.norm1(x) + x = self.nonlinearity(x) + x = self.conv2(x) + x = self.norm2(x) return x + residual @@ -207,90 +113,75 @@ def __init__( self, in_channels: int, out_channels: int, - heads: Optional[int] = None, + num_attention_heads: Optional[int] = None, heads_ratio: float = 1.0, dim=8, - use_bias=False, norm=(None, "bn2d"), act_func=(None, None), - kernel_func="relu", scales: tuple[int, ...] = (5,), - eps=1.0e-15, + eps: float = 1e-15, ): - super(LiteMLA, self).__init__() - self.eps = eps - heads = int(in_channels // dim * heads_ratio) if heads is None else heads - - total_dim = heads * dim + super().__init__() - use_bias = val2tuple(use_bias, 2) norm = val2tuple(norm, 2) act_func = val2tuple(act_func, 2) + self.eps = eps self.dim = dim - self.qkv = nn.Conv2d(in_channels, 3 * total_dim, kernel_size=1, stride=1, padding=0, bias=use_bias[0]) + num_attention_heads = ( + int(in_channels // dim * heads_ratio) if num_attention_heads is None else num_attention_heads + ) + inner_dim = num_attention_heads * dim + + # TODO(aryan): Convert to nn.linear + self.qkv = nn.Conv2d(in_channels, 3 * inner_dim, 1, 1, 0, bias=False) self.aggreg = nn.ModuleList( [ nn.Sequential( nn.Conv2d( - 3 * total_dim, - 3 * total_dim, + 3 * inner_dim, + 3 * inner_dim, scale, padding=scale // 2, - groups=3 * total_dim, - bias=use_bias[0], + groups=3 * inner_dim, + bias=False, ), - nn.Conv2d(3 * total_dim, 3 * total_dim, 1, groups=3 * heads, bias=use_bias[0]), + nn.Conv2d(3 * inner_dim, 3 * inner_dim, 1, 1, 0, groups=3 * num_attention_heads, bias=False), ) for scale in scales ] ) - self.kernel_func = get_activation(kernel_func) + self.kernel_nonlinearity = nn.ReLU() - self.proj_out = nn.Conv2d( - total_dim * (1 + len(scales)), - out_channels, - kernel_size=1, - stride=1, - padding=0, - bias=use_bias[1], - ) + self.proj_out = nn.Conv2d(inner_dim * (1 + len(scales)), out_channels, 1, 1, 0, bias=False) self.norm_out = build_norm(norm[1], num_features=out_channels) or nn.Identity() self.act_out = get_activation(act_func[1]) if act_func[1] is not None else nn.Identity() def relu_linear_att(self, qkv: torch.Tensor) -> torch.Tensor: B, _, H, W = list(qkv.size()) - if qkv.dtype == torch.float16: - qkv = qkv.float() + qkv = qkv.float() + qkv = torch.reshape(qkv, (B, -1, 3 * self.dim, H * W)) - qkv = torch.reshape( - qkv, - (B, -1, 3 * self.dim, H * W), - ) - q, k, v = ( - qkv[:, :, 0 : self.dim], - qkv[:, :, self.dim : 2 * self.dim], - qkv[:, :, 2 * self.dim :], - ) + query, key, value = (qkv[:, :, 0 : self.dim], qkv[:, :, self.dim : 2 * self.dim], qkv[:, :, 2 * self.dim :]) # lightweight linear attention - q = self.kernel_func(q) - k = self.kernel_func(k) + query = self.kernel_nonlinearity(query) + key = self.kernel_nonlinearity(key) # linear matmul - trans_k = k.transpose(-1, -2) + k_T = key.transpose(-1, -2) - v = F.pad(v, (0, 0, 0, 1), mode="constant", value=1) - vk = torch.matmul(v, trans_k) - out = torch.matmul(vk, q) - if out.dtype == torch.bfloat16: - out = out.float() - out = out[:, :, :-1] / (out[:, :, -1:] + self.eps) + value = F.pad(value, (0, 0, 0, 1), mode="constant", value=1) + vk = torch.matmul(value, k_T) + out = torch.matmul(vk, query) + out = out.float() + out = out[:, :, :-1] / (out[:, :, -1:] + self.eps) out = torch.reshape(out, (B, -1, H, W)) + return out def relu_quadratic_att(self, qkv: torch.Tensor) -> torch.Tensor: @@ -303,15 +194,16 @@ def relu_quadratic_att(self, qkv: torch.Tensor) -> torch.Tensor: qkv[:, :, 2 * self.dim :], ) - q = self.kernel_func(q) - k = self.kernel_func(k) + q = self.kernel_nonlinearity(q) + k = self.kernel_nonlinearity(k) att_map = torch.matmul(k.transpose(-1, -2), q) # b h n n + original_dtype = att_map.dtype - if original_dtype in [torch.float16, torch.bfloat16]: - att_map = att_map.float() + att_map = att_map.float() att_map = att_map / (torch.sum(att_map, dim=2, keepdim=True) + self.eps) # b h n n att_map = att_map.to(original_dtype) + out = torch.matmul(v, att_map) # b h d n out = torch.reshape(out, (B, -1, H, W)) @@ -347,37 +239,24 @@ def __init__( in_channels: int, heads_ratio: float = 1.0, dim=32, - expand_ratio: float = 4, scales: tuple[int, ...] = (5,), norm: str = "bn2d", - act_func: str = "hswish", - context_module: str = "LiteMLA", - local_module: str = "MBConv", ): super().__init__() - if context_module == "LiteMLA": - self.context_module = LiteMLA( - in_channels=in_channels, - out_channels=in_channels, - heads_ratio=heads_ratio, - dim=dim, - norm=(None, norm), - scales=scales, - ) - else: - raise ValueError(f"context_module {context_module} is not supported") - if local_module == "GLUMBConv": - self.local_module = GLUMBConv( - in_channels=in_channels, - out_channels=in_channels, - expand_ratio=expand_ratio, - use_bias=(True, True, False), - norm=(None, None, norm), - act_func=(act_func, act_func, None), - ) - else: - raise NotImplementedError(f"local_module {local_module} is not supported") + self.context_module = LiteMLA( + in_channels=in_channels, + out_channels=in_channels, + heads_ratio=heads_ratio, + dim=dim, + norm=(None, norm), + scales=scales, + ) + + self.local_module = GLUMBConv( + in_channels=in_channels, + out_channels=in_channels, + ) def forward(self, x: torch.Tensor) -> torch.Tensor: x = self.context_module(x) @@ -401,18 +280,15 @@ def build_stage_main( block = ResBlock( in_channels=in_channels, out_channels=out_channels, - kernel_size=3, - stride=1, - use_bias=(True, False), norm=(None, norm), act_func=(act, None), ) elif current_block_type == "EViT_GLU": assert in_channels == out_channels - block = EfficientViTBlock(in_channels, norm=norm, act_func=act, local_module="GLUMBConv", scales=()) + block = EfficientViTBlock(in_channels, norm=norm, scales=()) elif current_block_type == "EViTS5_GLU": assert in_channels == out_channels - block = EfficientViTBlock(in_channels, norm=norm, act_func=act, local_module="GLUMBConv", scales=(5,)) + block = EfficientViTBlock(in_channels, norm=norm, scales=(5,)) else: raise ValueError(f"block_type {current_block_type} is not supported") @@ -421,14 +297,7 @@ def build_stage_main( class DCDownBlock2d(nn.Module): - def __init__( - self, - in_channels: int, - out_channels: int, - kernel_size: int = 3, - downsample: bool = False, - shortcut: bool = True, - ) -> None: + def __init__(self, in_channels: int, out_channels: int, downsample: bool = False, shortcut: bool = True) -> None: super().__init__() self.downsample = downsample @@ -445,9 +314,9 @@ def __init__( self.conv = nn.Conv2d( in_channels, out_channels, - kernel_size=kernel_size, + kernel_size=3, stride=self.stride, - padding=kernel_size // 2, + padding=1, ) def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: @@ -471,7 +340,6 @@ def __init__( self, in_channels: int, out_channels: int, - kernel_size: int = 3, interpolate: bool = False, shortcut: bool = True, interpolation_mode: str = "nearest", @@ -481,7 +349,6 @@ def __init__( self.interpolate = interpolate self.interpolation_mode = interpolation_mode self.factor = 2 - self.stride = 1 out_ratio = self.factor**2 if not interpolate: @@ -489,13 +356,7 @@ def __init__( self.repeats = out_channels * self.factor**2 // in_channels - self.conv = nn.Conv2d( - in_channels, - out_channels, - kernel_size=kernel_size, - stride=self.stride, - padding=kernel_size // 2, - ) + self.conv = nn.Conv2d(in_channels, out_channels, 3, 1, 1) self.shortcut = shortcut @@ -524,7 +385,7 @@ def __init__( latent_channels: int, block_out_channels: List[int] = [128, 256, 512, 512, 1024, 1024], layers_per_block: List[int] = [2, 2, 2, 2, 2, 2], - block_type: str | List[str] = "ResBlock", + block_type: Union[str, List[str]] = "ResBlock", downsample_block_type: str = "ConvPixelUnshuffle", ): super().__init__() From 637924124bc4025c744a58b2813845c0a4287508 Mon Sep 17 00:00:00 2001 From: Aryan Date: Fri, 29 Nov 2024 16:04:15 +0100 Subject: [PATCH 043/141] refactor --- scripts/convert_dcae_to_diffusers.py | 5 +- .../models/autoencoders/autoencoder_dc.py | 116 +++++++----------- 2 files changed, 45 insertions(+), 76 deletions(-) diff --git a/scripts/convert_dcae_to_diffusers.py b/scripts/convert_dcae_to_diffusers.py index 0bd27b4a9612..1c91a0cbc995 100644 --- a/scripts/convert_dcae_to_diffusers.py +++ b/scripts/convert_dcae_to_diffusers.py @@ -21,6 +21,8 @@ def remove_keys_(key: str, state_dict: Dict[str, Any]): # common "main.": "", "op_list.": "", + "context_module": "attn", + "local_module": "conv_out", "norm.": "norm.norm.", "depth_conv.conv": "conv_depth", "inverted_conv.conv": "conv_inverted", @@ -29,8 +31,7 @@ def remove_keys_(key: str, state_dict: Dict[str, Any]): "conv.conv.": "conv.", "conv1.conv": "conv1", "conv2.conv": "conv2", - "conv1.norm": "norm1", - "conv2.norm": "norm2", + "conv2.norm": "norm", "qkv.conv": "qkv", "proj.conv": "proj_out", "proj.norm": "norm_out", diff --git a/src/diffusers/models/autoencoders/autoencoder_dc.py b/src/diffusers/models/autoencoders/autoencoder_dc.py index 4f5676b83de2..6315d0d35c9d 100644 --- a/src/diffusers/models/autoencoders/autoencoder_dc.py +++ b/src/diffusers/models/autoencoders/autoencoder_dc.py @@ -13,12 +13,11 @@ # See the License for the specific language governing permissions and # limitations under the License. -from typing import Any, List, Optional, Tuple +from typing import Any, List, Optional, Tuple, Union import torch import torch.nn as nn import torch.nn.functional as F -from torch.nn import BatchNorm2d from ...configuration_utils import ConfigMixin, register_to_config from ..activations import get_activation @@ -40,7 +39,7 @@ def build_norm(name: Optional[str] = "bn2d", num_features: Optional[int] = None) elif name == "rms2d": norm = RMSNormNd(num_features, eps=1e-5, elementwise_affine=True, bias=True, channel_dim=1) elif name == "bn2d": - norm = BatchNorm2d(num_features=num_features) + norm = nn.BatchNorm2d(num_features=num_features) else: raise ValueError(f"norm {name} is not supported") return norm @@ -59,20 +58,20 @@ def __init__(self, in_channels: int, out_channels: int) -> None: self.conv_point = nn.Conv2d(hidden_channels, out_channels, 1, 1, 0, bias=False) self.norm = RMSNormNd(out_channels, eps=1e-5, elementwise_affine=True, bias=True, channel_dim=1) - def forward(self, x: torch.Tensor) -> torch.Tensor: - residual = x + def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: + residual = hidden_states - x = self.conv_inverted(x) - x = self.nonlinearity(x) + hidden_states = self.conv_inverted(hidden_states) + hidden_states = self.nonlinearity(hidden_states) - x = self.conv_depth(x) - x, gate = torch.chunk(x, 2, dim=1) - x = x * self.nonlinearity(gate) + hidden_states = self.conv_depth(hidden_states) + hidden_states, gate = torch.chunk(hidden_states, 2, dim=1) + hidden_states = hidden_states * self.nonlinearity(gate) - x = self.conv_point(x) - x = self.norm(x) + hidden_states = self.conv_point(hidden_states) + hidden_states = self.norm(hidden_states) - return x + residual + return hidden_states + residual class ResBlock(nn.Module): @@ -80,30 +79,26 @@ def __init__( self, in_channels: int, out_channels: int, - norm=("bn2d", "bn2d"), + norm_type: str = "bn2d", act_func=("relu6", None), ) -> None: super().__init__() - norm = val2tuple(norm, 2) act_func = val2tuple(act_func, 2) self.nonlinearity = get_activation(act_func[0]) if act_func[0] is not None else nn.Identity() self.conv1 = nn.Conv2d(in_channels, in_channels, 3, 1, 1) - self.norm1 = build_norm(norm[0], num_features=in_channels) if norm[0] is not None else nn.Identity() - self.conv2 = nn.Conv2d(in_channels, out_channels, 3, 1, 1, bias=False) - self.norm2 = build_norm(norm[1], num_features=out_channels) if norm[1] is not None else nn.Identity() + self.norm = build_norm(norm_type, out_channels) - def forward(self, x: torch.Tensor) -> torch.Tensor: - residual = x - x = self.conv1(x) - x = self.norm1(x) - x = self.nonlinearity(x) - x = self.conv2(x) - x = self.norm2(x) - return x + residual + def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: + residual = hidden_states + hidden_states = self.conv1(hidden_states) + hidden_states = self.nonlinearity(hidden_states) + hidden_states = self.conv2(hidden_states) + hidden_states = self.norm(hidden_states) + return hidden_states + residual class LiteMLA(nn.Module): @@ -244,7 +239,7 @@ def __init__( ): super().__init__() - self.context_module = LiteMLA( + self.attn = LiteMLA( in_channels=in_channels, out_channels=in_channels, heads_ratio=heads_ratio, @@ -253,14 +248,14 @@ def __init__( scales=scales, ) - self.local_module = GLUMBConv( + self.conv_out = GLUMBConv( in_channels=in_channels, out_channels=in_channels, ) def forward(self, x: torch.Tensor) -> torch.Tensor: - x = self.context_module(x) - x = self.local_module(x) + x = self.attn(x) + x = self.conv_out(x) return x @@ -280,7 +275,7 @@ def build_stage_main( block = ResBlock( in_channels=in_channels, out_channels=out_channels, - norm=(None, norm), + norm_type=norm, act_func=(act, None), ) elif current_block_type == "EViT_GLU": @@ -348,18 +343,17 @@ def __init__( self.interpolate = interpolate self.interpolation_mode = interpolation_mode + self.shortcut = shortcut self.factor = 2 + self.repeats = out_channels * self.factor**2 // in_channels + out_ratio = self.factor**2 if not interpolate: out_channels = out_channels * out_ratio - self.repeats = out_channels * self.factor**2 // in_channels - self.conv = nn.Conv2d(in_channels, out_channels, 3, 1, 1) - self.shortcut = shortcut - def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: if self.interpolate: x = F.interpolate(hidden_states, scale_factor=self.factor, mode=self.interpolation_mode) @@ -395,9 +389,7 @@ def __init__( assert len(block_out_channels) == num_stages assert isinstance(block_type, str) or (isinstance(block_type, list) and len(block_type) == num_stages) - factor = 1 if layers_per_block[0] > 0 else 2 - - if factor == 1: + if layers_per_block[0] > 0: self.conv_in = nn.Conv2d( in_channels, block_out_channels[0] if layers_per_block[0] > 0 else block_out_channels[1], @@ -405,15 +397,13 @@ def __init__( stride=1, padding=1, ) - elif factor == 2: + else: self.conv_in = DCDownBlock2d( in_channels=in_channels, out_channels=block_out_channels[0] if layers_per_block[0] > 0 else block_out_channels[1], downsample=downsample_block_type == "ConvPixelUnshuffle", shortcut=False, ) - else: - raise stages = [] for stage_id, (width, depth) in enumerate(zip(block_out_channels, layers_per_block)): @@ -432,13 +422,7 @@ def __init__( stages.append(nn.Sequential(*current_stage)) self.stages = nn.ModuleList(stages) - self.conv_out = nn.Conv2d( - block_out_channels[-1], - latent_channels, - kernel_size=3, - stride=1, - padding=1, - ) + self.conv_out = nn.Conv2d(block_out_channels[-1], latent_channels, 3, 1, 1) self.norm_factor = 1 norm_in_channels = block_out_channels[-1] norm_out_channels = latent_channels @@ -464,9 +448,9 @@ def __init__( latent_channels: int, block_out_channels: List[int] = [128, 256, 512, 512, 1024, 1024], layers_per_block: List[int] = [2, 2, 2, 2, 2, 2], - block_type: str | List[str] = "ResBlock", - norm: str | List[str] = "rms2d", - act: str | List[str] = "silu", + block_type: Union[str, List[str]] = "ResBlock", + norm: Union[str, List[str]] = "rms2d", + act: Union[str, List[str]] = "silu", upsample_block_type: str = "ConvPixelShuffle", upsample_shortcut: str = "duplicating", ): @@ -479,10 +463,9 @@ def __init__( assert isinstance(norm, str) or (isinstance(norm, list) and len(norm) == num_stages) assert isinstance(act, str) or (isinstance(act, list) and len(act) == num_stages) - self.conv_in = nn.Conv2d(latent_channels, block_out_channels[-1], kernel_size=3, stride=1, padding=1) + self.conv_in = nn.Conv2d(latent_channels, block_out_channels[-1], 3, 1, 1) self.norm_factor = 1 - # TODO(aryan): Make sure this is divisible self.norm_repeats = block_out_channels[-1] * self.norm_factor**2 // latent_channels stages = [] @@ -513,32 +496,17 @@ def __init__( stages.insert(0, nn.Sequential(*current_stage)) self.stages = nn.ModuleList(stages) - factor = 1 if layers_per_block[0] > 0 else 2 + channels = block_out_channels[0] if layers_per_block[0] > 0 else block_out_channels[1] - self.norm_out = RMSNormNd( - block_out_channels[0] if layers_per_block[0] > 0 else block_out_channels[1], - eps=1e-5, - elementwise_affine=True, - bias=True, - channel_dim=1, - ) + self.norm_out = RMSNormNd(channels, eps=1e-5, elementwise_affine=True, bias=True, channel_dim=1) self.conv_act = nn.ReLU() self.conv_out = None - if factor == 1: - self.conv_out = nn.Conv2d( - block_out_channels[0] if layers_per_block[0] > 0 else block_out_channels[1], - in_channels, - kernel_size=3, - stride=1, - padding=1, - ) + if layers_per_block[0] > 0: + self.conv_out = nn.Conv2d(channels, in_channels, 3, 1, 1) else: self.conv_out = DCUpBlock2d( - block_out_channels[0] if layers_per_block[0] > 0 else block_out_channels[1], - in_channels, - interpolate=upsample_block_type == "InterpolateConv", - shortcut=False, + channels, in_channels, interpolate=upsample_block_type == "InterpolateConv", shortcut=False ) def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: @@ -571,7 +539,7 @@ def __init__( decoder_norm: str = "rms2d", decoder_act: str = "silu", upsample_block_type: str = "ConvPixelShuffle", - scaling_factor: Optional[float] = None, + scaling_factor: float = 1.0, ): super().__init__() self.encoder = Encoder( From 77571a8fb9fbc15b35d253949dc75433374b9fdf Mon Sep 17 00:00:00 2001 From: Aryan Date: Fri, 29 Nov 2024 16:11:31 +0100 Subject: [PATCH 044/141] refactor --- scripts/convert_dcae_to_diffusers.py | 28 +++++++++---------- .../models/autoencoders/autoencoder_dc.py | 25 +++++++++++++---- 2 files changed, 34 insertions(+), 19 deletions(-) diff --git a/scripts/convert_dcae_to_diffusers.py b/scripts/convert_dcae_to_diffusers.py index 1c91a0cbc995..7f2f21ce8016 100644 --- a/scripts/convert_dcae_to_diffusers.py +++ b/scripts/convert_dcae_to_diffusers.py @@ -136,10 +136,10 @@ def get_vae_config(name: str): elif name in ["dc-ae-f32c32-in-1.0", "dc-ae-f32c32-mix-1.0"]: config = { "latent_channels": 32, - "encoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViT_GLU", "EViT_GLU", "EViT_GLU"], + "encoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock"], "block_out_channels": [128, 256, 512, 512, 1024, 1024], "encoder_layers_per_block": [0, 4, 8, 2, 2, 2], - "decoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViT_GLU", "EViT_GLU", "EViT_GLU"], + "decoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock"], "decoder_layers_per_block": [0, 5, 10, 2, 2, 2], "decoder_norm": ["bn2d", "bn2d", "bn2d", "rms2d", "rms2d", "rms2d"], "decoder_act": ["relu", "relu", "relu", "silu", "silu", "silu"], @@ -151,11 +151,11 @@ def get_vae_config(name: str): "ResBlock", "ResBlock", "ResBlock", - "EViT_GLU", - "EViT_GLU", - "EViT_GLU", - "EViT_GLU", - "EViT_GLU", + "EfficientViTBlock", + "EfficientViTBlock", + "EfficientViTBlock", + "EfficientViTBlock", + "EfficientViTBlock", ], "block_out_channels": [128, 256, 512, 512, 1024, 1024, 2048, 2048], "encoder_layers_per_block": [0, 4, 8, 2, 2, 2, 2, 2], @@ -163,11 +163,11 @@ def get_vae_config(name: str): "ResBlock", "ResBlock", "ResBlock", - "EViT_GLU", - "EViT_GLU", - "EViT_GLU", - "EViT_GLU", - "EViT_GLU", + "EfficientViTBlock", + "EfficientViTBlock", + "EfficientViTBlock", + "EfficientViTBlock", + "EfficientViTBlock", ], "decoder_layers_per_block": [0, 5, 10, 2, 2, 2, 2, 2], "decoder_norm": ["bn2d", "bn2d", "bn2d", "rms2d", "rms2d", "rms2d", "rms2d", "rms2d"], @@ -176,10 +176,10 @@ def get_vae_config(name: str): elif name in ["dc-ae-f64c128-in-1.0", "dc-ae-f64c128-mix-1.0"]: config = { "latent_channels": 128, - "encoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViT_GLU", "EViT_GLU", "EViT_GLU", "EViT_GLU"], + "encoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock"], "block_out_channels": [128, 256, 512, 512, 1024, 1024, 2048], "encoder_layers_per_block": [0, 4, 8, 2, 2, 2, 2], - "decoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViT_GLU", "EViT_GLU", "EViT_GLU", "EViT_GLU"], + "decoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock"], "decoder_layers_per_block": [0, 5, 10, 2, 2, 2, 2], "decoder_norm": ["bn2d", "bn2d", "bn2d", "rms2d", "rms2d", "rms2d", "rms2d"], "decoder_act": ["relu", "relu", "relu", "silu", "silu", "silu", "silu"], diff --git a/src/diffusers/models/autoencoders/autoencoder_dc.py b/src/diffusers/models/autoencoders/autoencoder_dc.py index 6315d0d35c9d..4668b333e08a 100644 --- a/src/diffusers/models/autoencoders/autoencoder_dc.py +++ b/src/diffusers/models/autoencoders/autoencoder_dc.py @@ -80,13 +80,11 @@ def __init__( in_channels: int, out_channels: int, norm_type: str = "bn2d", - act_func=("relu6", None), + act_fn: str = "relu6", ) -> None: super().__init__() - act_func = val2tuple(act_func, 2) - - self.nonlinearity = get_activation(act_func[0]) if act_func[0] is not None else nn.Identity() + self.nonlinearity = get_activation(act_fn) if act_fn is not None else nn.Identity() self.conv1 = nn.Conv2d(in_channels, in_channels, 3, 1, 1) self.conv2 = nn.Conv2d(in_channels, out_channels, 3, 1, 1, bias=False) @@ -259,6 +257,23 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: return x +def get_block_from_block_type( + block_type: str, + in_channels: int, + out_channels: int, + norm_type: str, + act_fn: str, +): + if block_type == "ResBlock": + block = ResBlock(in_channels, out_channels, norm_type, act_fn) + + elif block_type == "EfficientViTBlock": + block = EfficientViTBlock(in_channels, norm=norm_type, scales=()) + + else: + raise ValueError(f"Block with {block_type=} is not supported.") + + def build_stage_main( width: int, depth: int, block_type: str | List[str], norm: str, act: str, input_width: int ) -> list[nn.Module]: @@ -278,7 +293,7 @@ def build_stage_main( norm_type=norm, act_func=(act, None), ) - elif current_block_type == "EViT_GLU": + elif current_block_type == "EfficientViTBlock": assert in_channels == out_channels block = EfficientViTBlock(in_channels, norm=norm, scales=()) elif current_block_type == "EViTS5_GLU": From c4d0867c89200e33dff2d64723ad6b8b37e4f2a6 Mon Sep 17 00:00:00 2001 From: Aryan Date: Sat, 30 Nov 2024 05:53:30 +0100 Subject: [PATCH 045/141] update --- src/diffusers/models/autoencoders/autoencoder_dc.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/diffusers/models/autoencoders/autoencoder_dc.py b/src/diffusers/models/autoencoders/autoencoder_dc.py index 4668b333e08a..d10f1a193e26 100644 --- a/src/diffusers/models/autoencoders/autoencoder_dc.py +++ b/src/diffusers/models/autoencoders/autoencoder_dc.py @@ -291,7 +291,7 @@ def build_stage_main( in_channels=in_channels, out_channels=out_channels, norm_type=norm, - act_func=(act, None), + act_fn=act, ) elif current_block_type == "EfficientViTBlock": assert in_channels == out_channels From 0bdb7eff9a9fda54bed5d92e9d74bd39293a1a5e Mon Sep 17 00:00:00 2001 From: Aryan Date: Sat, 30 Nov 2024 21:54:22 +0100 Subject: [PATCH 046/141] possibly change to nn.Linear --- scripts/convert_dcae_to_diffusers.py | 140 ++++---- .../models/autoencoders/autoencoder_dc.py | 302 +++++++++--------- 2 files changed, 206 insertions(+), 236 deletions(-) diff --git a/scripts/convert_dcae_to_diffusers.py b/scripts/convert_dcae_to_diffusers.py index 7f2f21ce8016..01bed2abcfcc 100644 --- a/scripts/convert_dcae_to_diffusers.py +++ b/scripts/convert_dcae_to_diffusers.py @@ -11,11 +11,14 @@ def remove_keys_(key: str, state_dict: Dict[str, Any]): state_dict.pop(key) -TOKENIZER_MAX_LENGTH = 128 +def remap_qkv_(key: str, state_dict: Dict[str, Any]): + qkv = state_dict.pop(key) + q, k, v = torch.chunk(qkv, 3, dim=0) + parent_module, _, _ = key.rpartition(".qkv.conv.weight") + state_dict[f"{parent_module}.to_q.weight"] = q.squeeze() + state_dict[f"{parent_module}.to_k.weight"] = k.squeeze() + state_dict[f"{parent_module}.to_v.weight"] = v.squeeze() -TRANSFORMER_KEYS_RENAME_DICT = {} - -TRANSFORMER_SPECIAL_KEYS_REMAP = {} VAE_KEYS_RENAME_DICT = { # common @@ -23,6 +26,10 @@ def remove_keys_(key: str, state_dict: Dict[str, Any]): "op_list.": "", "context_module": "attn", "local_module": "conv_out", + # NOTE: The below two lines work because scales in the available configs only have a tuple length of 1 + # If there were more scales, there would be more layers, so a loop would be better to handle this + "aggreg.0.0": "to_qkv_multiscale.0.proj_in", + "aggreg.0.1": "to_qkv_multiscale.0.proj_out", "norm.": "norm.norm.", "depth_conv.conv": "conv_depth", "inverted_conv.conv": "conv_inverted", @@ -32,7 +39,6 @@ def remove_keys_(key: str, state_dict: Dict[str, Any]): "conv1.conv": "conv1", "conv2.conv": "conv2", "conv2.norm": "norm", - "qkv.conv": "qkv", "proj.conv": "proj_out", "proj.norm": "norm_out", # encoder @@ -44,7 +50,9 @@ def remove_keys_(key: str, state_dict: Dict[str, Any]): "decoder.project_out.2.conv": "decoder.conv_out", } -VAE_SPECIAL_KEYS_REMAP = {} +VAE_SPECIAL_KEYS_REMAP = { + "qkv.conv.weight": remap_qkv_, +} def get_state_dict(saved_dict: Dict[str, Any]) -> Dict[str, Any]: @@ -58,49 +66,26 @@ def get_state_dict(saved_dict: Dict[str, Any]) -> Dict[str, Any]: return state_dict -def update_state_dict_inplace(state_dict: Dict[str, Any], old_key: str, new_key: str) -> Dict[str, Any]: +def update_state_dict_(state_dict: Dict[str, Any], old_key: str, new_key: str) -> Dict[str, Any]: state_dict[new_key] = state_dict.pop(old_key) -# def convert_transformer( -# ckpt_path: str, -# dtype: torch.dtype, -# ): -# PREFIX_KEY = "" - -# original_state_dict = get_state_dict(load_file(ckpt_path)) -# transformer = LTXTransformer3DModel().to(dtype=dtype) - -# for key in list(original_state_dict.keys()): -# new_key = key[len(PREFIX_KEY) :] -# for replace_key, rename_key in TRANSFORMER_KEYS_RENAME_DICT.items(): -# new_key = new_key.replace(replace_key, rename_key) -# update_state_dict_inplace(original_state_dict, key, new_key) - -# for key in list(original_state_dict.keys()): -# for special_key, handler_fn_inplace in TRANSFORMER_SPECIAL_KEYS_REMAP.items(): -# if special_key not in key: -# continue -# handler_fn_inplace(key, original_state_dict) - -# transformer.load_state_dict(original_state_dict, strict=True) -# return transformer - - def convert_vae(ckpt_path: str, dtype: torch.dtype): original_state_dict = get_state_dict(load_file(ckpt_path)) vae = AutoencoderDC( in_channels=3, latent_channels=32, - block_out_channels=[128, 256, 512, 512, 1024, 1024], - encoder_layers_per_block=[2, 2, 2, 3, 3, 3], - encoder_block_type=["ResBlock", "ResBlock", "ResBlock", "EViTS5_GLU", "EViTS5_GLU", "EViTS5_GLU"], + encoder_block_types=("ResBlock", "ResBlock", "ResBlock", "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock"), + decoder_block_types=("ResBlock", "ResBlock", "ResBlock", "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock"), + block_out_channels=(128, 256, 512, 512, 1024, 1024), + encoder_layers_per_block=(2, 2, 2, 3, 3, 3), + decoder_layers_per_block=(3, 3, 3, 3, 3, 3), + encoder_qkv_multiscales=((), (), (), (5,), (5,), (5,)), + decoder_qkv_multiscales=((), (), (), (5,), (5,), (5,)), downsample_block_type="Conv", - decoder_layers_per_block=[3, 3, 3, 3, 3, 3], - decoder_block_type=["ResBlock", "ResBlock", "ResBlock", "EViTS5_GLU", "EViTS5_GLU", "EViTS5_GLU"], - decoder_norm="rms2d", - decoder_act="silu", upsample_block_type="InterpolateConv", + decoder_norm_types="rms2d", + decoder_act_fns="silu", scaling_factor=0.41407, ).to(dtype=dtype) @@ -108,7 +93,7 @@ def convert_vae(ckpt_path: str, dtype: torch.dtype): new_key = key[:] for replace_key, rename_key in VAE_KEYS_RENAME_DICT.items(): new_key = new_key.replace(replace_key, rename_key) - update_state_dict_inplace(original_state_dict, key, new_key) + update_state_dict_(original_state_dict, key, new_key) for key in list(original_state_dict.keys()): for special_key, handler_fn_inplace in VAE_SPECIAL_KEYS_REMAP.items(): @@ -116,6 +101,8 @@ def convert_vae(ckpt_path: str, dtype: torch.dtype): continue handler_fn_inplace(key, original_state_dict) + print(original_state_dict.__len__()) + print(len(vae.state_dict().keys())) vae.load_state_dict(original_state_dict, strict=True) return vae @@ -124,30 +111,34 @@ def get_vae_config(name: str): if name in ["dc-ae-f32c32-sana-1.0"]: config = { "latent_channels": 32, - "encoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViTS5_GLU", "EViTS5_GLU", "EViTS5_GLU"], - "block_out_channels": [128, 256, 512, 512, 1024, 1024], - "encoder_layers_per_block": [2, 2, 2, 3, 3, 3], - "downsample_block_type": "Conv", - "decoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EViTS5_GLU", "EViTS5_GLU", "EViTS5_GLU"], + "encoder_block_types": ("ResBlock", "ResBlock", "ResBlock", "EViTS5_GLU", "EViTS5_GLU", "EViTS5_GLU"), + "decoder_block_types": ("ResBlock", "ResBlock", "ResBlock", "EViTS5_GLU", "EViTS5_GLU", "EViTS5_GLU"), + "block_out_channels": (128, 256, 512, 512, 1024, 1024), + "encoder_qkv_multiscales": ((), (), (), (5,), (5,), (5,)), + "decoder_qkv_multiscales": ((), (), (), (5,), (5,), (5,)), + "encoder_layers_per_block": (2, 2, 2, 3, 3, 3), "decoder_layers_per_block": [3, 3, 3, 3, 3, 3], + "downsample_block_type": "Conv", "upsample_block_type": "InterpolateConv", "scaling_factor": 0.41407, } elif name in ["dc-ae-f32c32-in-1.0", "dc-ae-f32c32-mix-1.0"]: config = { "latent_channels": 32, - "encoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock"], + "encoder_block_types": ["ResBlock", "ResBlock", "ResBlock", "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock"], + "decoder_block_types": ["ResBlock", "ResBlock", "ResBlock", "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock"], "block_out_channels": [128, 256, 512, 512, 1024, 1024], "encoder_layers_per_block": [0, 4, 8, 2, 2, 2], - "decoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock"], "decoder_layers_per_block": [0, 5, 10, 2, 2, 2], - "decoder_norm": ["bn2d", "bn2d", "bn2d", "rms2d", "rms2d", "rms2d"], - "decoder_act": ["relu", "relu", "relu", "silu", "silu", "silu"], + "encoder_qkv_multiscales": ((), (), (), (), (), ()), + "decoder_qkv_multiscales": ((), (), (), (), (), ()), + "decoder_norm_types": ["bn2d", "bn2d", "bn2d", "rms2d", "rms2d", "rms2d"], + "decoder_act_fns": ["relu", "relu", "relu", "silu", "silu", "silu"], } elif name in ["dc-ae-f128c512-in-1.0", "dc-ae-f128c512-mix-1.0"]: config = { "latent_channels": 512, - "encoder_block_type": [ + "encoder_block_types": [ "ResBlock", "ResBlock", "ResBlock", @@ -157,9 +148,7 @@ def get_vae_config(name: str): "EfficientViTBlock", "EfficientViTBlock", ], - "block_out_channels": [128, 256, 512, 512, 1024, 1024, 2048, 2048], - "encoder_layers_per_block": [0, 4, 8, 2, 2, 2, 2, 2], - "decoder_block_type": [ + "decoder_block_types": [ "ResBlock", "ResBlock", "ResBlock", @@ -169,20 +158,26 @@ def get_vae_config(name: str): "EfficientViTBlock", "EfficientViTBlock", ], + "block_out_channels": [128, 256, 512, 512, 1024, 1024, 2048, 2048], + "encoder_layers_per_block": [0, 4, 8, 2, 2, 2, 2, 2], "decoder_layers_per_block": [0, 5, 10, 2, 2, 2, 2, 2], - "decoder_norm": ["bn2d", "bn2d", "bn2d", "rms2d", "rms2d", "rms2d", "rms2d", "rms2d"], - "decoder_act": ["relu", "relu", "relu", "silu", "silu", "silu", "silu", "silu"], + "encoder_qkv_multiscales": ((), (), (), (), (), (), (), ()), + "decoder_qkv_multiscales": ((), (), (), (), (), (), (), ()), + "decoder_norm_types": ["bn2d", "bn2d", "bn2d", "rms2d", "rms2d", "rms2d", "rms2d", "rms2d"], + "decoder_act_fns": ["relu", "relu", "relu", "silu", "silu", "silu", "silu", "silu"], } elif name in ["dc-ae-f64c128-in-1.0", "dc-ae-f64c128-mix-1.0"]: config = { "latent_channels": 128, - "encoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock"], + "encoder_block_types": ["ResBlock", "ResBlock", "ResBlock", "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock"], + "decoder_block_types": ["ResBlock", "ResBlock", "ResBlock", "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock"], "block_out_channels": [128, 256, 512, 512, 1024, 1024, 2048], "encoder_layers_per_block": [0, 4, 8, 2, 2, 2, 2], - "decoder_block_type": ["ResBlock", "ResBlock", "ResBlock", "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock"], "decoder_layers_per_block": [0, 5, 10, 2, 2, 2, 2], - "decoder_norm": ["bn2d", "bn2d", "bn2d", "rms2d", "rms2d", "rms2d", "rms2d"], - "decoder_act": ["relu", "relu", "relu", "silu", "silu", "silu", "silu"], + "encoder_qkv_multiscales": ((), (), (), (), (), (), ()), + "decoder_qkv_multiscales": ((), (), (), (), (), (), ()), + "decoder_norm_types": ["bn2d", "bn2d", "bn2d", "rms2d", "rms2d", "rms2d", "rms2d"], + "decoder_act_fns": ["relu", "relu", "relu", "silu", "silu", "silu", "silu"], } return config @@ -190,20 +185,7 @@ def get_vae_config(name: str): def get_args(): parser = argparse.ArgumentParser() - parser.add_argument( - "--transformer_ckpt_path", type=str, default=None, help="Path to original transformer checkpoint" - ) parser.add_argument("--vae_ckpt_path", type=str, default=None, help="Path to original vae checkpoint") - parser.add_argument( - "--text_encoder_cache_dir", type=str, default=None, help="Path to text encoder cache directory" - ) - parser.add_argument( - "--typecast_text_encoder", - action="store_true", - default=False, - help="Whether or not to apply fp16/bf16 precision to text_encoder", - ) - parser.add_argument("--save_pipeline", action="store_true") parser.add_argument("--output_path", type=str, required=True, help="Path where converted model should be saved") parser.add_argument("--dtype", default="fp32", help="Torch dtype to save the model in.") return parser.parse_args() @@ -225,21 +207,9 @@ def get_args(): if __name__ == "__main__": args = get_args() - transformer = None dtype = DTYPE_MAPPING[args.dtype] variant = VARIANT_MAPPING[args.dtype] - if args.save_pipeline: - assert args.transformer_ckpt_path is not None and args.vae_ckpt_path is not None - - # if args.transformer_ckpt_path is not None: - # transformer = convert_transformer(args.transformer_ckpt_path, dtype) - # if not args.save_pipeline: - # transformer.save_pretrained( - # args.output_path, safe_serialization=True, max_shard_size="5GB", variant=variant - # ) - if args.vae_ckpt_path is not None: vae = convert_vae(args.vae_ckpt_path, dtype) - if not args.save_pipeline: - vae.save_pretrained(args.output_path, safe_serialization=True, max_shard_size="5GB", variant=variant) + vae.save_pretrained(args.output_path, safe_serialization=True, max_shard_size="5GB", variant=variant) diff --git a/src/diffusers/models/autoencoders/autoencoder_dc.py b/src/diffusers/models/autoencoders/autoencoder_dc.py index d10f1a193e26..50d911739f0d 100644 --- a/src/diffusers/models/autoencoders/autoencoder_dc.py +++ b/src/diffusers/models/autoencoders/autoencoder_dc.py @@ -13,7 +13,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -from typing import Any, List, Optional, Tuple, Union +from typing import List, Optional, Tuple, Union import torch import torch.nn as nn @@ -25,15 +25,7 @@ from ..normalization import RMSNormNd -def val2tuple(x: list | tuple | Any, min_len: int = 1) -> tuple: - x = list(x) if isinstance(x, (list, tuple)) else [x] - # repeat elements if necessary - if len(x) > 0: - x.extend([x[-1] for _ in range(min_len - len(x))]) - return tuple(x) - - -def build_norm(name: Optional[str] = "bn2d", num_features: Optional[int] = None) -> Optional[nn.Module]: +def get_norm_layer(name: Optional[str] = "bn2d", num_features: Optional[int] = None) -> Optional[nn.Module]: if name is None: norm = None elif name == "rms2d": @@ -85,10 +77,9 @@ def __init__( super().__init__() self.nonlinearity = get_activation(act_fn) if act_fn is not None else nn.Identity() - self.conv1 = nn.Conv2d(in_channels, in_channels, 3, 1, 1) self.conv2 = nn.Conv2d(in_channels, out_channels, 3, 1, 1, bias=False) - self.norm = build_norm(norm_type, out_channels) + self.norm = get_norm_layer(norm_type, out_channels) def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: residual = hidden_states @@ -99,6 +90,31 @@ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: return hidden_states + residual +class MLAProjection(nn.Module): + def __init__( + self, + in_channels: int, + num_attention_heads: int, + kernel_size: int, + ) -> None: + super().__init__() + + self.proj_in = nn.Conv2d( + 3 * in_channels, + 3 * in_channels, + kernel_size, + padding=kernel_size // 2, + groups=3 * in_channels, + bias=False, + ) + self.proj_out = nn.Conv2d(3 * in_channels, 3 * in_channels, 1, 1, 0, groups=3 * num_attention_heads, bias=False) + + def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: + hidden_states = self.proj_in(hidden_states) + hidden_states = self.proj_out(hidden_states) + return hidden_states + + class LiteMLA(nn.Module): r"""Lightweight multi-scale linear attention""" @@ -108,122 +124,111 @@ def __init__( out_channels: int, num_attention_heads: Optional[int] = None, heads_ratio: float = 1.0, - dim=8, - norm=(None, "bn2d"), - act_func=(None, None), - scales: tuple[int, ...] = (5,), + attention_head_dim: int = 8, + norm_type: str = "bn2d", + kernel_sizes: Tuple[int, ...] = (5,), eps: float = 1e-15, ): super().__init__() - norm = val2tuple(norm, 2) - act_func = val2tuple(act_func, 2) - self.eps = eps - self.dim = dim + self.attention_head_dim = attention_head_dim num_attention_heads = ( - int(in_channels // dim * heads_ratio) if num_attention_heads is None else num_attention_heads + int(in_channels // attention_head_dim * heads_ratio) if num_attention_heads is None else num_attention_heads ) - inner_dim = num_attention_heads * dim + inner_dim = num_attention_heads * attention_head_dim # TODO(aryan): Convert to nn.linear - self.qkv = nn.Conv2d(in_channels, 3 * inner_dim, 1, 1, 0, bias=False) - - self.aggreg = nn.ModuleList( - [ - nn.Sequential( - nn.Conv2d( - 3 * inner_dim, - 3 * inner_dim, - scale, - padding=scale // 2, - groups=3 * inner_dim, - bias=False, - ), - nn.Conv2d(3 * inner_dim, 3 * inner_dim, 1, 1, 0, groups=3 * num_attention_heads, bias=False), - ) - for scale in scales - ] - ) + # self.qkv = nn.Conv2d(in_channels, 3 * inner_dim, 1, 1, 0, bias=False) + self.to_q = nn.Linear(in_channels, inner_dim, bias=False) + self.to_k = nn.Linear(in_channels, inner_dim, bias=False) + self.to_v = nn.Linear(in_channels, inner_dim, bias=False) + + self.to_qkv_multiscale = nn.ModuleList() + for kernel_size in kernel_sizes: + self.to_qkv_multiscale.append(MLAProjection(inner_dim, num_attention_heads, kernel_size)) + self.kernel_nonlinearity = nn.ReLU() - self.proj_out = nn.Conv2d(inner_dim * (1 + len(scales)), out_channels, 1, 1, 0, bias=False) - self.norm_out = build_norm(norm[1], num_features=out_channels) or nn.Identity() - self.act_out = get_activation(act_func[1]) if act_func[1] is not None else nn.Identity() + self.proj_out = nn.Conv2d(inner_dim * (1 + len(kernel_sizes)), out_channels, 1, 1, 0, bias=False) + self.norm_out = get_norm_layer(norm_type, num_features=out_channels) def relu_linear_att(self, qkv: torch.Tensor) -> torch.Tensor: - B, _, H, W = list(qkv.size()) + batch_size, _, height, width = qkv.shape qkv = qkv.float() - qkv = torch.reshape(qkv, (B, -1, 3 * self.dim, H * W)) + qkv = torch.reshape(qkv, (batch_size, -1, 3 * self.attention_head_dim, height * width)) - query, key, value = (qkv[:, :, 0 : self.dim], qkv[:, :, self.dim : 2 * self.dim], qkv[:, :, 2 * self.dim :]) + query, key, value = (qkv[:, :, 0 : self.attention_head_dim], qkv[:, :, self.attention_head_dim : 2 * self.attention_head_dim], qkv[:, :, 2 * self.attention_head_dim :]) # lightweight linear attention query = self.kernel_nonlinearity(query) key = self.kernel_nonlinearity(key) - - # linear matmul - k_T = key.transpose(-1, -2) - value = F.pad(value, (0, 0, 0, 1), mode="constant", value=1) - vk = torch.matmul(value, k_T) - out = torch.matmul(vk, query) - out = out.float() - out = out[:, :, :-1] / (out[:, :, -1:] + self.eps) - out = torch.reshape(out, (B, -1, H, W)) + key_T = key.transpose(-1, -2) + scores = torch.matmul(value, key_T) + output = torch.matmul(scores, query) + + output = output.float() + output = output[:, :, :-1] / (output[:, :, -1:] + self.eps) + output = torch.reshape(output, (batch_size, -1, height, width)) - return out + return output def relu_quadratic_att(self, qkv: torch.Tensor) -> torch.Tensor: - B, _, H, W = list(qkv.size()) + batch_size, _, height, width = list(qkv.size()) - qkv = torch.reshape(qkv, (B, -1, 3 * self.dim, H * W)) - q, k, v = ( - qkv[:, :, 0 : self.dim], - qkv[:, :, self.dim : 2 * self.dim], - qkv[:, :, 2 * self.dim :], + qkv = torch.reshape(qkv, (batch_size, -1, 3 * self.attention_head_dim, height * width)) + query, key, value = ( + qkv[:, :, 0 : self.attention_head_dim], + qkv[:, :, self.attention_head_dim : 2 * self.attention_head_dim], + qkv[:, :, 2 * self.attention_head_dim :], ) - q = self.kernel_nonlinearity(q) - k = self.kernel_nonlinearity(k) - - att_map = torch.matmul(k.transpose(-1, -2), q) # b h n n + query = self.kernel_nonlinearity(query) + key = self.kernel_nonlinearity(key) - original_dtype = att_map.dtype - att_map = att_map.float() - att_map = att_map / (torch.sum(att_map, dim=2, keepdim=True) + self.eps) # b h n n - att_map = att_map.to(original_dtype) + scores = torch.matmul(key.transpose(-1, -2), query) - out = torch.matmul(v, att_map) # b h d n + original_dtype = scores.dtype + scores = scores.float() + scores = scores / (torch.sum(scores, dim=2, keepdim=True) + self.eps) + scores = scores.to(original_dtype) - out = torch.reshape(out, (B, -1, H, W)) - return out + output = torch.matmul(value, scores) + output = torch.reshape(output, (batch_size, -1, height, width)) + + return output - def forward(self, x: torch.Tensor) -> torch.Tensor: - residual = x - # generate multi-scale q, k, v - qkv = self.qkv(x) + def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: + residual = hidden_states + + hidden_states = hidden_states.movedim(1, -1) + query = self.to_q(hidden_states) + key = self.to_k(hidden_states) + value = self.to_v(hidden_states) + qkv = torch.cat([query, key, value], dim=-1) + qkv = qkv.movedim(-1, 1) multi_scale_qkv = [qkv] - for op in self.aggreg: - multi_scale_qkv.append(op(qkv)) + + for block in self.to_qkv_multiscale: + multi_scale_qkv.append(block(qkv)) qkv = torch.cat(multi_scale_qkv, dim=1) - H, W = list(qkv.size())[-2:] - if H * W > self.dim: - out = self.relu_linear_att(qkv).to(qkv.dtype) + height, width = qkv.shape[-2:] + if height * width > self.attention_head_dim: + hidden_states = self.relu_linear_att(qkv).to(qkv.dtype) else: - out = self.relu_quadratic_att(qkv) + hidden_states = self.relu_quadratic_att(qkv) - out = self.proj_out(out) - out = self.norm_out(out) - out = self.act_out(out) + hidden_states = self.proj_out(hidden_states) + hidden_states = self.norm_out(hidden_states) - return out + residual + return hidden_states + residual class EfficientViTBlock(nn.Module): @@ -231,9 +236,9 @@ def __init__( self, in_channels: int, heads_ratio: float = 1.0, - dim=32, - scales: tuple[int, ...] = (5,), - norm: str = "bn2d", + dim: int = 32, + qkv_multiscales: Tuple[int, ...] = (5,), + norm_type: str = "bn2d", ): super().__init__() @@ -241,9 +246,9 @@ def __init__( in_channels=in_channels, out_channels=in_channels, heads_ratio=heads_ratio, - dim=dim, - norm=(None, norm), - scales=scales, + attention_head_dim=dim, + norm_type=norm_type, + kernel_sizes=qkv_multiscales, ) self.conv_out = GLUMBConv( @@ -263,21 +268,23 @@ def get_block_from_block_type( out_channels: int, norm_type: str, act_fn: str, + qkv_mutliscales: Tuple[int] = (), ): if block_type == "ResBlock": block = ResBlock(in_channels, out_channels, norm_type, act_fn) elif block_type == "EfficientViTBlock": - block = EfficientViTBlock(in_channels, norm=norm_type, scales=()) + block = EfficientViTBlock(in_channels, norm_type=norm_type, qkv_multiscales=qkv_mutliscales) else: raise ValueError(f"Block with {block_type=} is not supported.") + + return block def build_stage_main( - width: int, depth: int, block_type: str | List[str], norm: str, act: str, input_width: int + width: int, depth: int, block_type: str | List[str], norm: str, act: str, input_width: int, qkv_multiscales=() ) -> list[nn.Module]: - assert isinstance(block_type, str) or (isinstance(block_type, list) and depth == len(block_type)) stage = [] for d in range(depth): current_block_type = block_type[d] if isinstance(block_type, list) else block_type @@ -285,23 +292,7 @@ def build_stage_main( in_channels = width if d > 0 else input_width out_channels = width - if current_block_type == "ResBlock": - assert in_channels == out_channels - block = ResBlock( - in_channels=in_channels, - out_channels=out_channels, - norm_type=norm, - act_fn=act, - ) - elif current_block_type == "EfficientViTBlock": - assert in_channels == out_channels - block = EfficientViTBlock(in_channels, norm=norm, scales=()) - elif current_block_type == "EViTS5_GLU": - assert in_channels == out_channels - block = EfficientViTBlock(in_channels, norm=norm, scales=(5,)) - else: - raise ValueError(f"block_type {current_block_type} is not supported") - + block = get_block_from_block_type(current_block_type, in_channels, out_channels, norm_type=norm, act_fn=act, qkv_mutliscales=qkv_multiscales) stage.append(block) return stage @@ -392,17 +383,18 @@ def __init__( self, in_channels: int, latent_channels: int, - block_out_channels: List[int] = [128, 256, 512, 512, 1024, 1024], - layers_per_block: List[int] = [2, 2, 2, 2, 2, 2], - block_type: Union[str, List[str]] = "ResBlock", + block_type: Union[str, Tuple[str]] = "ResBlock", + block_out_channels: Tuple[int] = (128, 256, 512, 512, 1024, 1024), + layers_per_block: Tuple[int] = (2, 2, 2, 2, 2, 2), + qkv_multiscales: Tuple[Tuple[int, ...], ...] = ((), (), (), (5,), (5,), (5,)), downsample_block_type: str = "ConvPixelUnshuffle", ): super().__init__() + num_stages = len(block_out_channels) - self.num_stages = num_stages - assert len(layers_per_block) == num_stages - assert len(block_out_channels) == num_stages - assert isinstance(block_type, str) or (isinstance(block_type, list) and len(block_type) == num_stages) + + if isinstance(block_type, str): + block_type = (block_type,) * num_stages if layers_per_block[0] > 0: self.conv_in = nn.Conv2d( @@ -422,9 +414,9 @@ def __init__( stages = [] for stage_id, (width, depth) in enumerate(zip(block_out_channels, layers_per_block)): - stage_block_type = block_type[stage_id] if isinstance(block_type, list) else block_type + stage_block_type = block_type[stage_id] current_stage = build_stage_main( - width=width, depth=depth, block_type=stage_block_type, norm="rms2d", act="silu", input_width=width + width=width, depth=depth, block_type=stage_block_type, norm="rms2d", act="silu", input_width=width, qkv_multiscales=qkv_multiscales[stage_id] ) if stage_id < num_stages - 1 and depth > 0: downsample_block = DCDownBlock2d( @@ -461,22 +453,25 @@ def __init__( self, in_channels: int, latent_channels: int, - block_out_channels: List[int] = [128, 256, 512, 512, 1024, 1024], - layers_per_block: List[int] = [2, 2, 2, 2, 2, 2], - block_type: Union[str, List[str]] = "ResBlock", - norm: Union[str, List[str]] = "rms2d", - act: Union[str, List[str]] = "silu", + block_type: Union[str, Tuple[str]] = "ResBlock", + block_out_channels: Tuple[int] = (128, 256, 512, 512, 1024, 1024), + layers_per_block: Tuple[int] = (2, 2, 2, 2, 2, 2), + qkv_multiscales: Tuple[Tuple[int, ...], ...] = ((), (), (), (5,), (5,), (5,)), + norm_type: Union[str, Tuple[str]] = "rms2d", + act_fn: Union[str, Tuple[str]] = "silu", upsample_block_type: str = "ConvPixelShuffle", upsample_shortcut: str = "duplicating", ): super().__init__() + num_stages = len(block_out_channels) - self.num_stages = num_stages - assert len(layers_per_block) == num_stages - assert len(block_out_channels) == num_stages - assert isinstance(block_type, str) or (isinstance(block_type, list) and len(block_type) == num_stages) - assert isinstance(norm, str) or (isinstance(norm, list) and len(norm) == num_stages) - assert isinstance(act, str) or (isinstance(act, list) and len(act) == num_stages) + + if isinstance(block_type, str): + block_type = (block_type,) * num_stages + if isinstance(norm_type, str): + norm_type = (norm_type,) * num_stages + if isinstance(act_fn, str): + act_fn = (act_fn,) * num_stages self.conv_in = nn.Conv2d(latent_channels, block_out_channels[-1], 3, 1, 1) @@ -495,9 +490,9 @@ def __init__( ) current_stage.append(upsample_block) - stage_block_type = block_type[stage_id] if isinstance(block_type, list) else block_type - stage_norm = norm[stage_id] if isinstance(norm, list) else norm - stage_act = act[stage_id] if isinstance(act, list) else act + stage_block_type = block_type[stage_id] + stage_norm = norm_type[stage_id] + stage_act = act_fn[stage_id] current_stage.extend( build_stage_main( width=width, @@ -506,6 +501,7 @@ def __init__( norm=stage_norm, act=stage_act, input_width=width, + qkv_multiscales=qkv_multiscales[stage_id], ) ) stages.insert(0, nn.Sequential(*current_stage)) @@ -545,40 +541,44 @@ def __init__( self, in_channels: int = 3, latent_channels: int = 32, + encoder_block_types: Union[str, Tuple[str]] = "ResBlock", + decoder_block_types: Union[str, Tuple[str]] = "ResBlock", block_out_channels: Tuple[int, ...] = (128, 256, 512, 512, 1024, 1024), encoder_layers_per_block: Tuple[int] = (2, 2, 2, 3, 3, 3), decoder_layers_per_block: Tuple[int] = (3, 3, 3, 3, 3, 3), - encoder_block_type: str | List[str] = "ResBlock", - downsample_block_type: str = "ConvPixelUnshuffle", - decoder_block_type: str | List[str] = "ResBlock", - decoder_norm: str = "rms2d", - decoder_act: str = "silu", + encoder_qkv_multiscales: Tuple[Tuple[int, ...], ...] = ((), (), (), (5,), (5,), (5,)), + decoder_qkv_multiscales: Tuple[Tuple[int, ...], ...] = ((), (), (), (5,), (5,), (5,)), upsample_block_type: str = "ConvPixelShuffle", + downsample_block_type: str = "ConvPixelUnshuffle", + decoder_norm_types: Union[str, Tuple[str]] = "rms2d", + decoder_act_fns: Union[str, Tuple[str]] = "silu", scaling_factor: float = 1.0, - ): + ) -> None: super().__init__() + self.encoder = Encoder( in_channels=in_channels, latent_channels=latent_channels, + block_type=encoder_block_types, block_out_channels=block_out_channels, layers_per_block=encoder_layers_per_block, - block_type=encoder_block_type, + qkv_multiscales=encoder_qkv_multiscales, downsample_block_type=downsample_block_type, ) self.decoder = Decoder( in_channels=in_channels, latent_channels=latent_channels, + block_type=decoder_block_types, block_out_channels=block_out_channels, layers_per_block=decoder_layers_per_block, - block_type=decoder_block_type, - norm=decoder_norm, - act=decoder_act, + qkv_multiscales=decoder_qkv_multiscales, + norm_type=decoder_norm_types, + act_fn=decoder_act_fns, upsample_block_type=upsample_block_type, ) - @property - def spatial_compression_ratio(self) -> int: - return 2 ** (self.decoder.num_stages - 1) + self.spatial_compression_ratio = 2 ** (len(block_out_channels) - 1) + self.temporal_compression_ratio = 1 def encode(self, x: torch.Tensor) -> torch.Tensor: x = self.encoder(x) @@ -588,7 +588,7 @@ def decode(self, x: torch.Tensor) -> torch.Tensor: x = self.decoder(x) return x - def forward(self, x: torch.Tensor, global_step: int) -> torch.Tensor: + def forward(self, x: torch.Tensor) -> torch.Tensor: x = self.encoder(x) x = self.decoder(x) - return x, torch.tensor(0), {} + return x From 54e933b39f289f67b957b49bb8032a10985c7852 Mon Sep 17 00:00:00 2001 From: Aryan Date: Sat, 30 Nov 2024 22:15:00 +0100 Subject: [PATCH 047/141] refactor --- scripts/convert_dcae_to_diffusers.py | 100 +++++++-- .../models/autoencoders/autoencoder_dc.py | 200 ++++++++++-------- 2 files changed, 196 insertions(+), 104 deletions(-) diff --git a/scripts/convert_dcae_to_diffusers.py b/scripts/convert_dcae_to_diffusers.py index 01bed2abcfcc..f43d7972dcd2 100644 --- a/scripts/convert_dcae_to_diffusers.py +++ b/scripts/convert_dcae_to_diffusers.py @@ -12,12 +12,13 @@ def remove_keys_(key: str, state_dict: Dict[str, Any]): def remap_qkv_(key: str, state_dict: Dict[str, Any]): - qkv = state_dict.pop(key) - q, k, v = torch.chunk(qkv, 3, dim=0) - parent_module, _, _ = key.rpartition(".qkv.conv.weight") - state_dict[f"{parent_module}.to_q.weight"] = q.squeeze() - state_dict[f"{parent_module}.to_k.weight"] = k.squeeze() - state_dict[f"{parent_module}.to_v.weight"] = v.squeeze() + # qkv = state_dict.pop(key) + # q, k, v = torch.chunk(qkv, 3, dim=0) + # parent_module, _, _ = key.rpartition(".qkv.conv.weight") + # state_dict[f"{parent_module}.to_q.weight"] = q.squeeze() + # state_dict[f"{parent_module}.to_k.weight"] = k.squeeze() + # state_dict[f"{parent_module}.to_v.weight"] = v.squeeze() + state_dict[key.replace("qkv.conv", "to_qkv")] = state_dict.pop(key) VAE_KEYS_RENAME_DICT = { @@ -75,16 +76,30 @@ def convert_vae(ckpt_path: str, dtype: torch.dtype): vae = AutoencoderDC( in_channels=3, latent_channels=32, - encoder_block_types=("ResBlock", "ResBlock", "ResBlock", "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock"), - decoder_block_types=("ResBlock", "ResBlock", "ResBlock", "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock"), + encoder_block_types=( + "ResBlock", + "ResBlock", + "ResBlock", + "EfficientViTBlock", + "EfficientViTBlock", + "EfficientViTBlock", + ), + decoder_block_types=( + "ResBlock", + "ResBlock", + "ResBlock", + "EfficientViTBlock", + "EfficientViTBlock", + "EfficientViTBlock", + ), block_out_channels=(128, 256, 512, 512, 1024, 1024), encoder_layers_per_block=(2, 2, 2, 3, 3, 3), decoder_layers_per_block=(3, 3, 3, 3, 3, 3), encoder_qkv_multiscales=((), (), (), (5,), (5,), (5,)), decoder_qkv_multiscales=((), (), (), (5,), (5,), (5,)), downsample_block_type="Conv", - upsample_block_type="InterpolateConv", - decoder_norm_types="rms2d", + upsample_block_type="interpolate", + decoder_norm_types="rms_norm", decoder_act_fns="silu", scaling_factor=0.41407, ).to(dtype=dtype) @@ -101,8 +116,6 @@ def convert_vae(ckpt_path: str, dtype: torch.dtype): continue handler_fn_inplace(key, original_state_dict) - print(original_state_dict.__len__()) - print(len(vae.state_dict().keys())) vae.load_state_dict(original_state_dict, strict=True) return vae @@ -119,20 +132,34 @@ def get_vae_config(name: str): "encoder_layers_per_block": (2, 2, 2, 3, 3, 3), "decoder_layers_per_block": [3, 3, 3, 3, 3, 3], "downsample_block_type": "Conv", - "upsample_block_type": "InterpolateConv", + "upsample_block_type": "interpolate", "scaling_factor": 0.41407, } elif name in ["dc-ae-f32c32-in-1.0", "dc-ae-f32c32-mix-1.0"]: config = { "latent_channels": 32, - "encoder_block_types": ["ResBlock", "ResBlock", "ResBlock", "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock"], - "decoder_block_types": ["ResBlock", "ResBlock", "ResBlock", "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock"], + "encoder_block_types": [ + "ResBlock", + "ResBlock", + "ResBlock", + "EfficientViTBlock", + "EfficientViTBlock", + "EfficientViTBlock", + ], + "decoder_block_types": [ + "ResBlock", + "ResBlock", + "ResBlock", + "EfficientViTBlock", + "EfficientViTBlock", + "EfficientViTBlock", + ], "block_out_channels": [128, 256, 512, 512, 1024, 1024], "encoder_layers_per_block": [0, 4, 8, 2, 2, 2], "decoder_layers_per_block": [0, 5, 10, 2, 2, 2], "encoder_qkv_multiscales": ((), (), (), (), (), ()), "decoder_qkv_multiscales": ((), (), (), (), (), ()), - "decoder_norm_types": ["bn2d", "bn2d", "bn2d", "rms2d", "rms2d", "rms2d"], + "decoder_norm_types": ["batch_norm", "batch_norm", "batch_norm", "rms_norm", "rms_norm", "rms_norm"], "decoder_act_fns": ["relu", "relu", "relu", "silu", "silu", "silu"], } elif name in ["dc-ae-f128c512-in-1.0", "dc-ae-f128c512-mix-1.0"]: @@ -163,20 +190,53 @@ def get_vae_config(name: str): "decoder_layers_per_block": [0, 5, 10, 2, 2, 2, 2, 2], "encoder_qkv_multiscales": ((), (), (), (), (), (), (), ()), "decoder_qkv_multiscales": ((), (), (), (), (), (), (), ()), - "decoder_norm_types": ["bn2d", "bn2d", "bn2d", "rms2d", "rms2d", "rms2d", "rms2d", "rms2d"], + "decoder_norm_types": [ + "batch_norm", + "batch_norm", + "batch_norm", + "rms_norm", + "rms_norm", + "rms_norm", + "rms_norm", + "rms_norm", + ], "decoder_act_fns": ["relu", "relu", "relu", "silu", "silu", "silu", "silu", "silu"], } elif name in ["dc-ae-f64c128-in-1.0", "dc-ae-f64c128-mix-1.0"]: config = { "latent_channels": 128, - "encoder_block_types": ["ResBlock", "ResBlock", "ResBlock", "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock"], - "decoder_block_types": ["ResBlock", "ResBlock", "ResBlock", "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock"], + "encoder_block_types": [ + "ResBlock", + "ResBlock", + "ResBlock", + "EfficientViTBlock", + "EfficientViTBlock", + "EfficientViTBlock", + "EfficientViTBlock", + ], + "decoder_block_types": [ + "ResBlock", + "ResBlock", + "ResBlock", + "EfficientViTBlock", + "EfficientViTBlock", + "EfficientViTBlock", + "EfficientViTBlock", + ], "block_out_channels": [128, 256, 512, 512, 1024, 1024, 2048], "encoder_layers_per_block": [0, 4, 8, 2, 2, 2, 2], "decoder_layers_per_block": [0, 5, 10, 2, 2, 2, 2], "encoder_qkv_multiscales": ((), (), (), (), (), (), ()), "decoder_qkv_multiscales": ((), (), (), (), (), (), ()), - "decoder_norm_types": ["bn2d", "bn2d", "bn2d", "rms2d", "rms2d", "rms2d", "rms2d"], + "decoder_norm_types": [ + "batch_norm", + "batch_norm", + "batch_norm", + "rms_norm", + "rms_norm", + "rms_norm", + "rms_norm", + ], "decoder_act_fns": ["relu", "relu", "relu", "silu", "silu", "silu", "silu"], } diff --git a/src/diffusers/models/autoencoders/autoencoder_dc.py b/src/diffusers/models/autoencoders/autoencoder_dc.py index 50d911739f0d..5eb090e83c54 100644 --- a/src/diffusers/models/autoencoders/autoencoder_dc.py +++ b/src/diffusers/models/autoencoders/autoencoder_dc.py @@ -13,7 +13,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -from typing import List, Optional, Tuple, Union +from typing import Optional, Tuple, Union import torch import torch.nn as nn @@ -25,12 +25,12 @@ from ..normalization import RMSNormNd -def get_norm_layer(name: Optional[str] = "bn2d", num_features: Optional[int] = None) -> Optional[nn.Module]: +def get_norm_layer(name: Optional[str] = "batch_norm", num_features: Optional[int] = None) -> Optional[nn.Module]: if name is None: norm = None - elif name == "rms2d": + elif name == "rms_norm": norm = RMSNormNd(num_features, eps=1e-5, elementwise_affine=True, bias=True, channel_dim=1) - elif name == "bn2d": + elif name == "batch_norm": norm = nn.BatchNorm2d(num_features=num_features) else: raise ValueError(f"norm {name} is not supported") @@ -71,7 +71,7 @@ def __init__( self, in_channels: int, out_channels: int, - norm_type: str = "bn2d", + norm_type: str = "batch_norm", act_fn: str = "relu6", ) -> None: super().__init__() @@ -107,8 +107,10 @@ def __init__( groups=3 * in_channels, bias=False, ) - self.proj_out = nn.Conv2d(3 * in_channels, 3 * in_channels, 1, 1, 0, groups=3 * num_attention_heads, bias=False) - + self.proj_out = nn.Conv2d( + 3 * in_channels, 3 * in_channels, 1, 1, 0, groups=3 * num_attention_heads, bias=False + ) + def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: hidden_states = self.proj_in(hidden_states) hidden_states = self.proj_out(hidden_states) @@ -125,7 +127,7 @@ def __init__( num_attention_heads: Optional[int] = None, heads_ratio: float = 1.0, attention_head_dim: int = 8, - norm_type: str = "bn2d", + norm_type: str = "batch_norm", kernel_sizes: Tuple[int, ...] = (5,), eps: float = 1e-15, ): @@ -135,32 +137,33 @@ def __init__( self.attention_head_dim = attention_head_dim num_attention_heads = ( - int(in_channels // attention_head_dim * heads_ratio) if num_attention_heads is None else num_attention_heads + int(in_channels // attention_head_dim * heads_ratio) + if num_attention_heads is None + else num_attention_heads ) inner_dim = num_attention_heads * attention_head_dim - # TODO(aryan): Convert to nn.linear - # self.qkv = nn.Conv2d(in_channels, 3 * inner_dim, 1, 1, 0, bias=False) - self.to_q = nn.Linear(in_channels, inner_dim, bias=False) - self.to_k = nn.Linear(in_channels, inner_dim, bias=False) - self.to_v = nn.Linear(in_channels, inner_dim, bias=False) + self.to_qkv = nn.Conv2d(in_channels, 3 * inner_dim, 1, 1, 0, bias=False) self.to_qkv_multiscale = nn.ModuleList() for kernel_size in kernel_sizes: self.to_qkv_multiscale.append(MLAProjection(inner_dim, num_attention_heads, kernel_size)) self.kernel_nonlinearity = nn.ReLU() - self.proj_out = nn.Conv2d(inner_dim * (1 + len(kernel_sizes)), out_channels, 1, 1, 0, bias=False) self.norm_out = get_norm_layer(norm_type, num_features=out_channels) - def relu_linear_att(self, qkv: torch.Tensor) -> torch.Tensor: + def linear_attention(self, qkv: torch.Tensor) -> torch.Tensor: batch_size, _, height, width = qkv.shape qkv = qkv.float() qkv = torch.reshape(qkv, (batch_size, -1, 3 * self.attention_head_dim, height * width)) - query, key, value = (qkv[:, :, 0 : self.attention_head_dim], qkv[:, :, self.attention_head_dim : 2 * self.attention_head_dim], qkv[:, :, 2 * self.attention_head_dim :]) + query, key, value = ( + qkv[:, :, 0 : self.attention_head_dim], + qkv[:, :, self.attention_head_dim : 2 * self.attention_head_dim], + qkv[:, :, 2 * self.attention_head_dim :], + ) # lightweight linear attention query = self.kernel_nonlinearity(query) @@ -170,14 +173,14 @@ def relu_linear_att(self, qkv: torch.Tensor) -> torch.Tensor: key_T = key.transpose(-1, -2) scores = torch.matmul(value, key_T) output = torch.matmul(scores, query) - + output = output.float() output = output[:, :, :-1] / (output[:, :, -1:] + self.eps) output = torch.reshape(output, (batch_size, -1, height, width)) return output - def relu_quadratic_att(self, qkv: torch.Tensor) -> torch.Tensor: + def quadratic_attention(self, qkv: torch.Tensor) -> torch.Tensor: batch_size, _, height, width = list(qkv.size()) qkv = torch.reshape(qkv, (batch_size, -1, 3 * self.attention_head_dim, height * width)) @@ -199,21 +202,15 @@ def relu_quadratic_att(self, qkv: torch.Tensor) -> torch.Tensor: output = torch.matmul(value, scores) output = torch.reshape(output, (batch_size, -1, height, width)) - + return output def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: residual = hidden_states - - hidden_states = hidden_states.movedim(1, -1) - query = self.to_q(hidden_states) - key = self.to_k(hidden_states) - value = self.to_v(hidden_states) - qkv = torch.cat([query, key, value], dim=-1) - qkv = qkv.movedim(-1, 1) + + qkv = self.to_qkv(hidden_states) multi_scale_qkv = [qkv] - for block in self.to_qkv_multiscale: multi_scale_qkv.append(block(qkv)) @@ -221,9 +218,9 @@ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: height, width = qkv.shape[-2:] if height * width > self.attention_head_dim: - hidden_states = self.relu_linear_att(qkv).to(qkv.dtype) + hidden_states = self.linear_attention(qkv).to(qkv.dtype) else: - hidden_states = self.relu_quadratic_att(qkv) + hidden_states = self.quadratic_attention(qkv) hidden_states = self.proj_out(hidden_states) hidden_states = self.norm_out(hidden_states) @@ -238,7 +235,7 @@ def __init__( heads_ratio: float = 1.0, dim: int = 32, qkv_multiscales: Tuple[int, ...] = (5,), - norm_type: str = "bn2d", + norm_type: str = "batch_norm", ): super().__init__() @@ -272,29 +269,14 @@ def get_block_from_block_type( ): if block_type == "ResBlock": block = ResBlock(in_channels, out_channels, norm_type, act_fn) - + elif block_type == "EfficientViTBlock": block = EfficientViTBlock(in_channels, norm_type=norm_type, qkv_multiscales=qkv_mutliscales) else: raise ValueError(f"Block with {block_type=} is not supported.") - - return block - -def build_stage_main( - width: int, depth: int, block_type: str | List[str], norm: str, act: str, input_width: int, qkv_multiscales=() -) -> list[nn.Module]: - stage = [] - for d in range(depth): - current_block_type = block_type[d] if isinstance(block_type, list) else block_type - - in_channels = width if d > 0 else input_width - out_channels = width - - block = get_block_from_block_type(current_block_type, in_channels, out_channels, norm_type=norm, act_fn=act, qkv_mutliscales=qkv_multiscales) - stage.append(block) - return stage + return block class DCDownBlock2d(nn.Module): @@ -387,10 +369,10 @@ def __init__( block_out_channels: Tuple[int] = (128, 256, 512, 512, 1024, 1024), layers_per_block: Tuple[int] = (2, 2, 2, 2, 2, 2), qkv_multiscales: Tuple[Tuple[int, ...], ...] = ((), (), (), (5,), (5,), (5,)), - downsample_block_type: str = "ConvPixelUnshuffle", + downsample_block_type: str = "pixel_unshuffle", ): super().__init__() - + num_stages = len(block_out_channels) if isinstance(block_type, str): @@ -408,25 +390,36 @@ def __init__( self.conv_in = DCDownBlock2d( in_channels=in_channels, out_channels=block_out_channels[0] if layers_per_block[0] > 0 else block_out_channels[1], - downsample=downsample_block_type == "ConvPixelUnshuffle", + downsample=downsample_block_type == "pixel_unshuffle", shortcut=False, ) stages = [] for stage_id, (width, depth) in enumerate(zip(block_out_channels, layers_per_block)): - stage_block_type = block_type[stage_id] - current_stage = build_stage_main( - width=width, depth=depth, block_type=stage_block_type, norm="rms2d", act="silu", input_width=width, qkv_multiscales=qkv_multiscales[stage_id] - ) + stage = [] + + for _ in range(depth): + block = get_block_from_block_type( + block_type[stage_id], + width, + width, + norm_type="rms_norm", + act_fn="silu", + qkv_mutliscales=qkv_multiscales[stage_id], + ) + stage.append(block) + if stage_id < num_stages - 1 and depth > 0: downsample_block = DCDownBlock2d( in_channels=width, out_channels=block_out_channels[stage_id + 1], - downsample=downsample_block_type == "ConvPixelUnshuffle", + downsample=downsample_block_type == "pixel_unshuffle", shortcut=True, ) - current_stage.append(downsample_block) - stages.append(nn.Sequential(*current_stage)) + stage.append(downsample_block) + + stages.append(nn.Sequential(*stage)) + self.stages = nn.ModuleList(stages) self.conv_out = nn.Conv2d(block_out_channels[-1], latent_channels, 3, 1, 1) @@ -457,13 +450,13 @@ def __init__( block_out_channels: Tuple[int] = (128, 256, 512, 512, 1024, 1024), layers_per_block: Tuple[int] = (2, 2, 2, 2, 2, 2), qkv_multiscales: Tuple[Tuple[int, ...], ...] = ((), (), (), (5,), (5,), (5,)), - norm_type: Union[str, Tuple[str]] = "rms2d", + norm_type: Union[str, Tuple[str]] = "rms_norm", act_fn: Union[str, Tuple[str]] = "silu", - upsample_block_type: str = "ConvPixelShuffle", + upsample_block_type: str = "pixel_shuffle", upsample_shortcut: str = "duplicating", ): super().__init__() - + num_stages = len(block_out_channels) if isinstance(block_type, str): @@ -480,31 +473,30 @@ def __init__( stages = [] for stage_id, (width, depth) in reversed(list(enumerate(zip(block_out_channels, layers_per_block)))): - current_stage = [] + stage = [] + if stage_id < num_stages - 1 and depth > 0: upsample_block = DCUpBlock2d( block_out_channels[stage_id + 1], width, - interpolate=upsample_block_type == "InterpolateConv", + interpolate=upsample_block_type == "interpolate", shortcut=upsample_shortcut, ) - current_stage.append(upsample_block) - - stage_block_type = block_type[stage_id] - stage_norm = norm_type[stage_id] - stage_act = act_fn[stage_id] - current_stage.extend( - build_stage_main( - width=width, - depth=depth, - block_type=stage_block_type, - norm=stage_norm, - act=stage_act, - input_width=width, - qkv_multiscales=qkv_multiscales[stage_id], + stage.append(upsample_block) + + for _ in range(depth): + block = get_block_from_block_type( + block_type[stage_id], + width, + width, + norm_type=norm_type[stage_id], + act_fn=act_fn[stage_id], + qkv_mutliscales=qkv_multiscales[stage_id], ) - ) - stages.insert(0, nn.Sequential(*current_stage)) + stage.append(block) + + stages.insert(0, nn.Sequential(*stage)) + self.stages = nn.ModuleList(stages) channels = block_out_channels[0] if layers_per_block[0] > 0 else block_out_channels[1] @@ -517,7 +509,7 @@ def __init__( self.conv_out = nn.Conv2d(channels, in_channels, 3, 1, 1) else: self.conv_out = DCUpBlock2d( - channels, in_channels, interpolate=upsample_block_type == "InterpolateConv", shortcut=False + channels, in_channels, interpolate=upsample_block_type == "interpolate", shortcut=False ) def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: @@ -536,6 +528,46 @@ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: class AutoencoderDC(ModelMixin, ConfigMixin): + r""" + An Autoencoder model introduced in [DCAE](https://arxiv.org/abs/2410.10733) and used in + [SANA](https://arxiv.org/abs/2410.10629). + + This model inherits from [`ModelMixin`]. Check the superclass documentation for it's generic methods implemented + for all models (such as downloading or saving). + + Args: + in_channels (`int`, defaults to `3`): + The number of input channels in samples. + latent_channels (`int`, defaults to `32`): + The number of channels in the latent space representation. + encoder_block_types (`Union[str, Tuple[str]]`, defaults to `"ResBlock"`): + The type(s) of block to use in the encoder. + decoder_block_types (`Union[str, Tuple[str]]`, defaults to `"ResBlock"`): + The type(s) of block to use in the decoder. + block_out_channels (`Tuple[int, ...]`, defaults to `(128, 256, 512, 512, 1024, 1024)`): + The number of output channels for each block in the encoder/decoder. + encoder_layers_per_block (`Tuple[int]`, defaults to `(2, 2, 2, 3, 3, 3)`): + The number of layers per block in the encoder. + decoder_layers_per_block (`Tuple[int]`, defaults to `(3, 3, 3, 3, 3, 3)`): + The number of layers per block in the decoder. + encoder_qkv_multiscales (`Tuple[Tuple[int, ...], ...]`, defaults to `((), (), (), (5,), (5,), (5,))`): + Multi-scale configurations for the encoder's QKV (query-key-value) transformations. + decoder_qkv_multiscales (`Tuple[Tuple[int, ...], ...]`, defaults to `((), (), (), (5,), (5,), (5,))`): + Multi-scale configurations for the decoder's QKV (query-key-value) transformations. + upsample_block_type (`str`, defaults to `"pixel_shuffle"`): + The type of block to use for upsampling in the decoder. + downsample_block_type (`str`, defaults to `"pixel_unshuffle"`): + The type of block to use for downsampling in the encoder. + decoder_norm_types (`Union[str, Tuple[str]]`, defaults to `"rms_norm"`): + The normalization type(s) to use in the decoder. + decoder_act_fns (`Union[str, Tuple[str]]`, defaults to `"silu"`): + The activation function(s) to use in the decoder. + scaling_factor (`float`, defaults to `1.0`): + A scaling factor applied during model operations. + """ + + _supports_gradient_checkpointing = True + @register_to_config def __init__( self, @@ -548,14 +580,14 @@ def __init__( decoder_layers_per_block: Tuple[int] = (3, 3, 3, 3, 3, 3), encoder_qkv_multiscales: Tuple[Tuple[int, ...], ...] = ((), (), (), (5,), (5,), (5,)), decoder_qkv_multiscales: Tuple[Tuple[int, ...], ...] = ((), (), (), (5,), (5,), (5,)), - upsample_block_type: str = "ConvPixelShuffle", - downsample_block_type: str = "ConvPixelUnshuffle", - decoder_norm_types: Union[str, Tuple[str]] = "rms2d", + upsample_block_type: str = "pixel_shuffle", + downsample_block_type: str = "pixel_unshuffle", + decoder_norm_types: Union[str, Tuple[str]] = "rms_norm", decoder_act_fns: Union[str, Tuple[str]] = "silu", scaling_factor: float = 1.0, ) -> None: super().__init__() - + self.encoder = Encoder( in_channels=in_channels, latent_channels=latent_channels, From 3d5faaff2deaedfbbb2b4d7a2474abb9fce2491c Mon Sep 17 00:00:00 2001 From: Aryan Date: Sat, 30 Nov 2024 22:27:41 +0100 Subject: [PATCH 048/141] make fix-copies --- src/diffusers/utils/dummy_pt_objects.py | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/src/diffusers/utils/dummy_pt_objects.py b/src/diffusers/utils/dummy_pt_objects.py index 5091ff318f1b..7b3c366ca8e2 100644 --- a/src/diffusers/utils/dummy_pt_objects.py +++ b/src/diffusers/utils/dummy_pt_objects.py @@ -47,6 +47,21 @@ def from_pretrained(cls, *args, **kwargs): requires_backends(cls, ["torch"]) +class AutoencoderDC(metaclass=DummyObject): + _backends = ["torch"] + + def __init__(self, *args, **kwargs): + requires_backends(self, ["torch"]) + + @classmethod + def from_config(cls, *args, **kwargs): + requires_backends(cls, ["torch"]) + + @classmethod + def from_pretrained(cls, *args, **kwargs): + requires_backends(cls, ["torch"]) + + class AutoencoderKL(metaclass=DummyObject): _backends = ["torch"] From ca3ac4dedeb871c16d5648faf02570488ff9a7bd Mon Sep 17 00:00:00 2001 From: Junyu Chen Date: Mon, 2 Dec 2024 17:52:28 -0800 Subject: [PATCH 049/141] replace vae with ae --- scripts/convert_dcae_to_diffusers.py | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/scripts/convert_dcae_to_diffusers.py b/scripts/convert_dcae_to_diffusers.py index f43d7972dcd2..60f23d6f78f6 100644 --- a/scripts/convert_dcae_to_diffusers.py +++ b/scripts/convert_dcae_to_diffusers.py @@ -21,7 +21,7 @@ def remap_qkv_(key: str, state_dict: Dict[str, Any]): state_dict[key.replace("qkv.conv", "to_qkv")] = state_dict.pop(key) -VAE_KEYS_RENAME_DICT = { +AE_KEYS_RENAME_DICT = { # common "main.": "", "op_list.": "", @@ -51,7 +51,7 @@ def remap_qkv_(key: str, state_dict: Dict[str, Any]): "decoder.project_out.2.conv": "decoder.conv_out", } -VAE_SPECIAL_KEYS_REMAP = { +AE_SPECIAL_KEYS_REMAP = { "qkv.conv.weight": remap_qkv_, } @@ -71,9 +71,9 @@ def update_state_dict_(state_dict: Dict[str, Any], old_key: str, new_key: str) - state_dict[new_key] = state_dict.pop(old_key) -def convert_vae(ckpt_path: str, dtype: torch.dtype): +def convert_ae(ckpt_path: str, dtype: torch.dtype): original_state_dict = get_state_dict(load_file(ckpt_path)) - vae = AutoencoderDC( + ae = AutoencoderDC( in_channels=3, latent_channels=32, encoder_block_types=( @@ -106,21 +106,21 @@ def convert_vae(ckpt_path: str, dtype: torch.dtype): for key in list(original_state_dict.keys()): new_key = key[:] - for replace_key, rename_key in VAE_KEYS_RENAME_DICT.items(): + for replace_key, rename_key in AE_KEYS_RENAME_DICT.items(): new_key = new_key.replace(replace_key, rename_key) update_state_dict_(original_state_dict, key, new_key) for key in list(original_state_dict.keys()): - for special_key, handler_fn_inplace in VAE_SPECIAL_KEYS_REMAP.items(): + for special_key, handler_fn_inplace in AE_SPECIAL_KEYS_REMAP.items(): if special_key not in key: continue handler_fn_inplace(key, original_state_dict) - vae.load_state_dict(original_state_dict, strict=True) - return vae + ae.load_state_dict(original_state_dict, strict=True) + return ae -def get_vae_config(name: str): +def get_ae_config(name: str): if name in ["dc-ae-f32c32-sana-1.0"]: config = { "latent_channels": 32, @@ -245,7 +245,7 @@ def get_vae_config(name: str): def get_args(): parser = argparse.ArgumentParser() - parser.add_argument("--vae_ckpt_path", type=str, default=None, help="Path to original vae checkpoint") + parser.add_argument("--ae_ckpt_path", type=str, default=None, help="Path to original ae checkpoint") parser.add_argument("--output_path", type=str, required=True, help="Path where converted model should be saved") parser.add_argument("--dtype", default="fp32", help="Torch dtype to save the model in.") return parser.parse_args() @@ -270,6 +270,6 @@ def get_args(): dtype = DTYPE_MAPPING[args.dtype] variant = VARIANT_MAPPING[args.dtype] - if args.vae_ckpt_path is not None: - vae = convert_vae(args.vae_ckpt_path, dtype) - vae.save_pretrained(args.output_path, safe_serialization=True, max_shard_size="5GB", variant=variant) + if args.ae_ckpt_path is not None: + ae = convert_ae(args.ae_ckpt_path, dtype) + ae.save_pretrained(args.output_path, safe_serialization=True, max_shard_size="5GB", variant=variant) From 9ef7b59725b6f759a69b32593b63fd96894ca9f7 Mon Sep 17 00:00:00 2001 From: Junyu Chen Date: Mon, 2 Dec 2024 17:53:34 -0800 Subject: [PATCH 050/141] replace get_block_from_block_type to get_block --- src/diffusers/models/autoencoders/autoencoder_dc.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/diffusers/models/autoencoders/autoencoder_dc.py b/src/diffusers/models/autoencoders/autoencoder_dc.py index 5eb090e83c54..62f64d5c9e2a 100644 --- a/src/diffusers/models/autoencoders/autoencoder_dc.py +++ b/src/diffusers/models/autoencoders/autoencoder_dc.py @@ -259,7 +259,7 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: return x -def get_block_from_block_type( +def get_block( block_type: str, in_channels: int, out_channels: int, @@ -399,7 +399,7 @@ def __init__( stage = [] for _ in range(depth): - block = get_block_from_block_type( + block = get_block( block_type[stage_id], width, width, @@ -485,7 +485,7 @@ def __init__( stage.append(upsample_block) for _ in range(depth): - block = get_block_from_block_type( + block = get_block( block_type[stage_id], width, width, From 074817cfdcc1af232610673ec560ebe3b4bcbe07 Mon Sep 17 00:00:00 2001 From: Junyu Chen Date: Mon, 2 Dec 2024 19:15:22 -0800 Subject: [PATCH 051/141] replace downsample_block_type from Conv to conv for consistency --- scripts/convert_dcae_to_diffusers.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/scripts/convert_dcae_to_diffusers.py b/scripts/convert_dcae_to_diffusers.py index 60f23d6f78f6..25e93a01cabe 100644 --- a/scripts/convert_dcae_to_diffusers.py +++ b/scripts/convert_dcae_to_diffusers.py @@ -97,7 +97,7 @@ def convert_ae(ckpt_path: str, dtype: torch.dtype): decoder_layers_per_block=(3, 3, 3, 3, 3, 3), encoder_qkv_multiscales=((), (), (), (5,), (5,), (5,)), decoder_qkv_multiscales=((), (), (), (5,), (5,), (5,)), - downsample_block_type="Conv", + downsample_block_type="conv", upsample_block_type="interpolate", decoder_norm_types="rms_norm", decoder_act_fns="silu", @@ -131,7 +131,7 @@ def get_ae_config(name: str): "decoder_qkv_multiscales": ((), (), (), (5,), (5,), (5,)), "encoder_layers_per_block": (2, 2, 2, 3, 3, 3), "decoder_layers_per_block": [3, 3, 3, 3, 3, 3], - "downsample_block_type": "Conv", + "downsample_block_type": "conv", "upsample_block_type": "interpolate", "scaling_factor": 0.41407, } From 64de66a4774a7cc313f4dfb24f6684c9e88ac4fa Mon Sep 17 00:00:00 2001 From: Junyu Chen Date: Mon, 2 Dec 2024 21:31:56 -0800 Subject: [PATCH 052/141] add scaling factors --- scripts/convert_dcae_to_diffusers.py | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/scripts/convert_dcae_to_diffusers.py b/scripts/convert_dcae_to_diffusers.py index 25e93a01cabe..1ae28766e4ab 100644 --- a/scripts/convert_dcae_to_diffusers.py +++ b/scripts/convert_dcae_to_diffusers.py @@ -162,6 +162,10 @@ def get_ae_config(name: str): "decoder_norm_types": ["batch_norm", "batch_norm", "batch_norm", "rms_norm", "rms_norm", "rms_norm"], "decoder_act_fns": ["relu", "relu", "relu", "silu", "silu", "silu"], } + if name == "dc-ae-f32c32-in-1.0": + config["scaling_factor"] = 0.3189 + elif name == "dc-ae-f32c32-mix-1.0": + config["scaling_factor"] = 0.4552 elif name in ["dc-ae-f128c512-in-1.0", "dc-ae-f128c512-mix-1.0"]: config = { "latent_channels": 512, @@ -202,6 +206,10 @@ def get_ae_config(name: str): ], "decoder_act_fns": ["relu", "relu", "relu", "silu", "silu", "silu", "silu", "silu"], } + if name == "dc-ae-f128c512-in-1.0": + config["scaling_factor"] = 0.4883 + elif name == "dc-ae-f128c512-mix-1.0": + config["scaling_factor"] = 0.3620 elif name in ["dc-ae-f64c128-in-1.0", "dc-ae-f64c128-mix-1.0"]: config = { "latent_channels": 128, @@ -239,6 +247,10 @@ def get_ae_config(name: str): ], "decoder_act_fns": ["relu", "relu", "relu", "silu", "silu", "silu", "silu"], } + if name == "dc-ae-f64c128-in-1.0": + config["scaling_factor"] = 0.2889 + elif name == "dc-ae-f64c128-mix-1.0": + config["scaling_factor"] = 0.4538 return config From 0bda5c51bcbfb083d5ea25eaddd3d07b837d22f4 Mon Sep 17 00:00:00 2001 From: Aryan Date: Wed, 4 Dec 2024 07:26:30 +0100 Subject: [PATCH 053/141] incorporate changes for all checkpoints --- scripts/convert_dcae_to_diffusers.py | 158 ++++++++++-------- .../models/autoencoders/autoencoder_dc.py | 120 +++++++------ src/diffusers/models/normalization.py | 25 --- 3 files changed, 156 insertions(+), 147 deletions(-) diff --git a/scripts/convert_dcae_to_diffusers.py b/scripts/convert_dcae_to_diffusers.py index 1ae28766e4ab..da401cd082f0 100644 --- a/scripts/convert_dcae_to_diffusers.py +++ b/scripts/convert_dcae_to_diffusers.py @@ -2,6 +2,7 @@ from typing import Any, Dict import torch +from huggingface_hub import hf_hub_download from safetensors.torch import load_file from diffusers import AutoencoderDC @@ -31,7 +32,6 @@ def remap_qkv_(key: str, state_dict: Dict[str, Any]): # If there were more scales, there would be more layers, so a loop would be better to handle this "aggreg.0.0": "to_qkv_multiscale.0.proj_in", "aggreg.0.1": "to_qkv_multiscale.0.proj_out", - "norm.": "norm.norm.", "depth_conv.conv": "conv_depth", "inverted_conv.conv": "conv_inverted", "point_conv.conv": "conv_point", @@ -45,10 +45,33 @@ def remap_qkv_(key: str, state_dict: Dict[str, Any]): # encoder "encoder.project_in.conv": "encoder.conv_in", "encoder.project_out.0.conv": "encoder.conv_out", + "encoder.stages": "encoder.down_blocks", # decoder "decoder.project_in.conv": "decoder.conv_in", - "decoder.project_out.0": "decoder.norm_out.norm", + "decoder.project_out.0": "decoder.norm_out", "decoder.project_out.2.conv": "decoder.conv_out", + "decoder.stages": "decoder.up_blocks", +} + +AE_F32C32_KEYS = { + # encoder + "encoder.project_in.conv": "encoder.conv_in.conv", + # decoder + "decoder.project_out.2.conv": "decoder.conv_out.conv", +} + +AE_F64C128_KEYS = { + # encoder + "encoder.project_in.conv": "encoder.conv_in.conv", + # decoder + "decoder.project_out.2.conv": "decoder.conv_out.conv", +} + +AE_F128C512_KEYS = { + # encoder + "encoder.project_in.conv": "encoder.conv_in.conv", + # decoder + "decoder.project_out.2.conv": "decoder.conv_out.conv", } AE_SPECIAL_KEYS_REMAP = { @@ -71,38 +94,13 @@ def update_state_dict_(state_dict: Dict[str, Any], old_key: str, new_key: str) - state_dict[new_key] = state_dict.pop(old_key) -def convert_ae(ckpt_path: str, dtype: torch.dtype): +def convert_ae(config_name: str, dtype: torch.dtype): + config = get_ae_config(config_name) + hub_id = f"mit-han-lab/{config_name}" + ckpt_path = hf_hub_download(hub_id, "model.safetensors") original_state_dict = get_state_dict(load_file(ckpt_path)) - ae = AutoencoderDC( - in_channels=3, - latent_channels=32, - encoder_block_types=( - "ResBlock", - "ResBlock", - "ResBlock", - "EfficientViTBlock", - "EfficientViTBlock", - "EfficientViTBlock", - ), - decoder_block_types=( - "ResBlock", - "ResBlock", - "ResBlock", - "EfficientViTBlock", - "EfficientViTBlock", - "EfficientViTBlock", - ), - block_out_channels=(128, 256, 512, 512, 1024, 1024), - encoder_layers_per_block=(2, 2, 2, 3, 3, 3), - decoder_layers_per_block=(3, 3, 3, 3, 3, 3), - encoder_qkv_multiscales=((), (), (), (5,), (5,), (5,)), - decoder_qkv_multiscales=((), (), (), (5,), (5,), (5,)), - downsample_block_type="conv", - upsample_block_type="interpolate", - decoder_norm_types="rms_norm", - decoder_act_fns="silu", - scaling_factor=0.41407, - ).to(dtype=dtype) + + ae = AutoencoderDC(**config).to(dtype=dtype) for key in list(original_state_dict.keys()): new_key = key[:] @@ -124,18 +122,22 @@ def get_ae_config(name: str): if name in ["dc-ae-f32c32-sana-1.0"]: config = { "latent_channels": 32, - "encoder_block_types": ("ResBlock", "ResBlock", "ResBlock", "EViTS5_GLU", "EViTS5_GLU", "EViTS5_GLU"), - "decoder_block_types": ("ResBlock", "ResBlock", "ResBlock", "EViTS5_GLU", "EViTS5_GLU", "EViTS5_GLU"), - "block_out_channels": (128, 256, 512, 512, 1024, 1024), + "encoder_block_types": ("ResBlock", "ResBlock", "ResBlock", "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock"), + "decoder_block_types": ("ResBlock", "ResBlock", "ResBlock", "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock"), + "encoder_block_out_channels": (128, 256, 512, 512, 1024, 1024), + "decoder_block_out_channels": (128, 256, 512, 512, 1024, 1024), "encoder_qkv_multiscales": ((), (), (), (5,), (5,), (5,)), "decoder_qkv_multiscales": ((), (), (), (5,), (5,), (5,)), "encoder_layers_per_block": (2, 2, 2, 3, 3, 3), "decoder_layers_per_block": [3, 3, 3, 3, 3, 3], "downsample_block_type": "conv", "upsample_block_type": "interpolate", + "decoder_norm_types": "rms_norm", + "decoder_act_fns": "silu", "scaling_factor": 0.41407, } elif name in ["dc-ae-f32c32-in-1.0", "dc-ae-f32c32-mix-1.0"]: + AE_KEYS_RENAME_DICT.update(AE_F32C32_KEYS) config = { "latent_channels": 32, "encoder_block_types": [ @@ -154,7 +156,8 @@ def get_ae_config(name: str): "EfficientViTBlock", "EfficientViTBlock", ], - "block_out_channels": [128, 256, 512, 512, 1024, 1024], + "encoder_block_out_channels": [128, 256, 512, 512, 1024, 1024], + "decoder_block_out_channels": [128, 256, 512, 512, 1024, 1024], "encoder_layers_per_block": [0, 4, 8, 2, 2, 2], "decoder_layers_per_block": [0, 5, 10, 2, 2, 2], "encoder_qkv_multiscales": ((), (), (), (), (), ()), @@ -166,9 +169,10 @@ def get_ae_config(name: str): config["scaling_factor"] = 0.3189 elif name == "dc-ae-f32c32-mix-1.0": config["scaling_factor"] = 0.4552 - elif name in ["dc-ae-f128c512-in-1.0", "dc-ae-f128c512-mix-1.0"]: + elif name in ["dc-ae-f64c128-in-1.0", "dc-ae-f64c128-mix-1.0"]: + AE_KEYS_RENAME_DICT.update(AE_F64C128_KEYS) config = { - "latent_channels": 512, + "latent_channels": 128, "encoder_block_types": [ "ResBlock", "ResBlock", @@ -177,7 +181,6 @@ def get_ae_config(name: str): "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock", - "EfficientViTBlock", ], "decoder_block_types": [ "ResBlock", @@ -187,13 +190,13 @@ def get_ae_config(name: str): "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock", - "EfficientViTBlock", ], - "block_out_channels": [128, 256, 512, 512, 1024, 1024, 2048, 2048], - "encoder_layers_per_block": [0, 4, 8, 2, 2, 2, 2, 2], - "decoder_layers_per_block": [0, 5, 10, 2, 2, 2, 2, 2], - "encoder_qkv_multiscales": ((), (), (), (), (), (), (), ()), - "decoder_qkv_multiscales": ((), (), (), (), (), (), (), ()), + "encoder_block_out_channels": [128, 256, 512, 512, 1024, 1024, 2048], + "decoder_block_out_channels": [128, 256, 512, 512, 1024, 1024, 2048], + "encoder_layers_per_block": [0, 4, 8, 2, 2, 2, 2], + "decoder_layers_per_block": [0, 5, 10, 2, 2, 2, 2], + "encoder_qkv_multiscales": ((), (), (), (), (), (), ()), + "decoder_qkv_multiscales": ((), (), (), (), (), (), ()), "decoder_norm_types": [ "batch_norm", "batch_norm", @@ -202,17 +205,17 @@ def get_ae_config(name: str): "rms_norm", "rms_norm", "rms_norm", - "rms_norm", ], - "decoder_act_fns": ["relu", "relu", "relu", "silu", "silu", "silu", "silu", "silu"], + "decoder_act_fns": ["relu", "relu", "relu", "silu", "silu", "silu", "silu"], } - if name == "dc-ae-f128c512-in-1.0": - config["scaling_factor"] = 0.4883 - elif name == "dc-ae-f128c512-mix-1.0": - config["scaling_factor"] = 0.3620 - elif name in ["dc-ae-f64c128-in-1.0", "dc-ae-f64c128-mix-1.0"]: + if name == "dc-ae-f64c128-in-1.0": + config["scaling_factor"] = 0.2889 + elif name == "dc-ae-f64c128-mix-1.0": + config["scaling_factor"] = 0.4538 + elif name in ["dc-ae-f128c512-in-1.0", "dc-ae-f128c512-mix-1.0"]: + AE_KEYS_RENAME_DICT.update(AE_F128C512_KEYS) config = { - "latent_channels": 128, + "latent_channels": 512, "encoder_block_types": [ "ResBlock", "ResBlock", @@ -221,6 +224,7 @@ def get_ae_config(name: str): "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock", + "EfficientViTBlock", ], "decoder_block_types": [ "ResBlock", @@ -230,12 +234,14 @@ def get_ae_config(name: str): "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock", + "EfficientViTBlock", ], - "block_out_channels": [128, 256, 512, 512, 1024, 1024, 2048], - "encoder_layers_per_block": [0, 4, 8, 2, 2, 2, 2], - "decoder_layers_per_block": [0, 5, 10, 2, 2, 2, 2], - "encoder_qkv_multiscales": ((), (), (), (), (), (), ()), - "decoder_qkv_multiscales": ((), (), (), (), (), (), ()), + "encoder_block_out_channels": [128, 256, 512, 512, 1024, 1024, 2048, 2048], + "decoder_block_out_channels": [128, 256, 512, 512, 1024, 1024, 2048, 2048], + "encoder_layers_per_block": [0, 4, 8, 2, 2, 2, 2, 2], + "decoder_layers_per_block": [0, 5, 10, 2, 2, 2, 2, 2], + "encoder_qkv_multiscales": ((), (), (), (), (), (), (), ()), + "decoder_qkv_multiscales": ((), (), (), (), (), (), (), ()), "decoder_norm_types": [ "batch_norm", "batch_norm", @@ -244,20 +250,37 @@ def get_ae_config(name: str): "rms_norm", "rms_norm", "rms_norm", + "rms_norm", ], - "decoder_act_fns": ["relu", "relu", "relu", "silu", "silu", "silu", "silu"], + "decoder_act_fns": ["relu", "relu", "relu", "silu", "silu", "silu", "silu", "silu"], } - if name == "dc-ae-f64c128-in-1.0": - config["scaling_factor"] = 0.2889 - elif name == "dc-ae-f64c128-mix-1.0": - config["scaling_factor"] = 0.4538 + if name == "dc-ae-f128c512-in-1.0": + config["scaling_factor"] = 0.4883 + elif name == "dc-ae-f128c512-mix-1.0": + config["scaling_factor"] = 0.3620 + else: + raise ValueError("Invalid config name provided.") return config def get_args(): parser = argparse.ArgumentParser() - parser.add_argument("--ae_ckpt_path", type=str, default=None, help="Path to original ae checkpoint") + parser.add_argument( + "--config_name", + type=str, + default="dc-ae-f32c32-sana-1.0", + choices=[ + "dc-ae-f32c32-sana-1.0", + "dc-ae-f32c32-in-1.0", + "dc-ae-f32c32-mix-1.0", + "dc-ae-f64c128-in-1.0", + "dc-ae-f64c128-mix-1.0", + "dc-ae-f128c512-in-1.0", + "dc-ae-f128c512-mix-1.0", + ], + help="The DCAE checkpoint to convert", + ) parser.add_argument("--output_path", type=str, required=True, help="Path where converted model should be saved") parser.add_argument("--dtype", default="fp32", help="Torch dtype to save the model in.") return parser.parse_args() @@ -282,6 +305,5 @@ def get_args(): dtype = DTYPE_MAPPING[args.dtype] variant = VARIANT_MAPPING[args.dtype] - if args.ae_ckpt_path is not None: - ae = convert_ae(args.ae_ckpt_path, dtype) - ae.save_pretrained(args.output_path, safe_serialization=True, max_shard_size="5GB", variant=variant) + ae = convert_ae(args.config_name, dtype) + ae.save_pretrained(args.output_path, safe_serialization=True, max_shard_size="5GB", variant=variant) diff --git a/src/diffusers/models/autoencoders/autoencoder_dc.py b/src/diffusers/models/autoencoders/autoencoder_dc.py index 62f64d5c9e2a..affd32b6ac7a 100644 --- a/src/diffusers/models/autoencoders/autoencoder_dc.py +++ b/src/diffusers/models/autoencoders/autoencoder_dc.py @@ -22,14 +22,14 @@ from ...configuration_utils import ConfigMixin, register_to_config from ..activations import get_activation from ..modeling_utils import ModelMixin -from ..normalization import RMSNormNd +from ..normalization import RMSNorm def get_norm_layer(name: Optional[str] = "batch_norm", num_features: Optional[int] = None) -> Optional[nn.Module]: if name is None: norm = None elif name == "rms_norm": - norm = RMSNormNd(num_features, eps=1e-5, elementwise_affine=True, bias=True, channel_dim=1) + norm = RMSNorm(num_features, eps=1e-5, elementwise_affine=True, bias=True) elif name == "batch_norm": norm = nn.BatchNorm2d(num_features=num_features) else: @@ -48,7 +48,7 @@ def __init__(self, in_channels: int, out_channels: int) -> None: self.conv_inverted = nn.Conv2d(in_channels, hidden_channels * 2, 1, 1, 0) self.conv_depth = nn.Conv2d(hidden_channels * 2, hidden_channels * 2, 3, 1, 1, groups=hidden_channels * 2) self.conv_point = nn.Conv2d(hidden_channels, out_channels, 1, 1, 0, bias=False) - self.norm = RMSNormNd(out_channels, eps=1e-5, elementwise_affine=True, bias=True, channel_dim=1) + self.norm = RMSNorm(out_channels, eps=1e-5, elementwise_affine=True, bias=True) def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: residual = hidden_states @@ -61,7 +61,7 @@ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: hidden_states = hidden_states * self.nonlinearity(gate) hidden_states = self.conv_point(hidden_states) - hidden_states = self.norm(hidden_states) + hidden_states = self.norm(hidden_states.movedim(1, -1)).movedim(-1, 1) return hidden_states + residual @@ -76,6 +76,8 @@ def __init__( ) -> None: super().__init__() + self.norm_type = norm_type + self.nonlinearity = get_activation(act_fn) if act_fn is not None else nn.Identity() self.conv1 = nn.Conv2d(in_channels, in_channels, 3, 1, 1) self.conv2 = nn.Conv2d(in_channels, out_channels, 3, 1, 1, bias=False) @@ -86,7 +88,11 @@ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: hidden_states = self.conv1(hidden_states) hidden_states = self.nonlinearity(hidden_states) hidden_states = self.conv2(hidden_states) - hidden_states = self.norm(hidden_states) + + if self.norm_type == "rms_norm": + hidden_states = self.norm(hidden_states.movedim(1, -1)).movedim(-1, 1) + else: + hidden_states = self.norm(hidden_states) return hidden_states + residual @@ -135,6 +141,7 @@ def __init__( self.eps = eps self.attention_head_dim = attention_head_dim + self.norm_type = norm_type num_attention_heads = ( int(in_channels // attention_head_dim * heads_ratio) @@ -223,7 +230,11 @@ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: hidden_states = self.quadratic_attention(qkv) hidden_states = self.proj_out(hidden_states) - hidden_states = self.norm_out(hidden_states) + + if self.norm_type == "rms_norm": + hidden_states = self.norm_out(hidden_states.movedim(1, -1)).movedim(-1, 1) + else: + hidden_states = self.norm_out(hidden_states) return hidden_states + residual @@ -373,10 +384,10 @@ def __init__( ): super().__init__() - num_stages = len(block_out_channels) + num_blocks = len(block_out_channels) if isinstance(block_type, str): - block_type = (block_type,) * num_stages + block_type = (block_type,) * num_blocks if layers_per_block[0] > 0: self.conv_in = nn.Conv2d( @@ -394,33 +405,33 @@ def __init__( shortcut=False, ) - stages = [] - for stage_id, (width, depth) in enumerate(zip(block_out_channels, layers_per_block)): - stage = [] + down_blocks = [] + for i, (out_channel, num_layers) in enumerate(zip(block_out_channels, layers_per_block)): + down_block_list = [] - for _ in range(depth): + for _ in range(num_layers): block = get_block( - block_type[stage_id], - width, - width, + block_type[i], + out_channel, + out_channel, norm_type="rms_norm", act_fn="silu", - qkv_mutliscales=qkv_multiscales[stage_id], + qkv_mutliscales=qkv_multiscales[i], ) - stage.append(block) + down_block_list.append(block) - if stage_id < num_stages - 1 and depth > 0: + if i < num_blocks - 1 and num_layers > 0: downsample_block = DCDownBlock2d( - in_channels=width, - out_channels=block_out_channels[stage_id + 1], + in_channels=out_channel, + out_channels=block_out_channels[i + 1], downsample=downsample_block_type == "pixel_unshuffle", shortcut=True, ) - stage.append(downsample_block) + down_block_list.append(downsample_block) - stages.append(nn.Sequential(*stage)) + down_blocks.append(nn.Sequential(*down_block_list)) - self.stages = nn.ModuleList(stages) + self.down_blocks = nn.ModuleList(down_blocks) self.conv_out = nn.Conv2d(block_out_channels[-1], latent_channels, 3, 1, 1) self.norm_factor = 1 @@ -430,8 +441,8 @@ def __init__( def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: hidden_states = self.conv_in(hidden_states) - for stage in self.stages: - hidden_states = stage(hidden_states) + for down_block in self.down_blocks: + hidden_states = down_block(hidden_states) x = F.pixel_unshuffle(hidden_states, self.norm_factor) x = x.unflatten(1, (-1, self.norm_group_size)) @@ -457,51 +468,51 @@ def __init__( ): super().__init__() - num_stages = len(block_out_channels) + num_blocks = len(block_out_channels) if isinstance(block_type, str): - block_type = (block_type,) * num_stages + block_type = (block_type,) * num_blocks if isinstance(norm_type, str): - norm_type = (norm_type,) * num_stages + norm_type = (norm_type,) * num_blocks if isinstance(act_fn, str): - act_fn = (act_fn,) * num_stages + act_fn = (act_fn,) * num_blocks self.conv_in = nn.Conv2d(latent_channels, block_out_channels[-1], 3, 1, 1) self.norm_factor = 1 self.norm_repeats = block_out_channels[-1] * self.norm_factor**2 // latent_channels - stages = [] - for stage_id, (width, depth) in reversed(list(enumerate(zip(block_out_channels, layers_per_block)))): - stage = [] + up_blocks = [] + for i, (out_channel, num_layers) in reversed(list(enumerate(zip(block_out_channels, layers_per_block)))): + up_block_list = [] - if stage_id < num_stages - 1 and depth > 0: + if i < num_blocks - 1 and num_layers > 0: upsample_block = DCUpBlock2d( - block_out_channels[stage_id + 1], - width, + block_out_channels[i + 1], + out_channel, interpolate=upsample_block_type == "interpolate", shortcut=upsample_shortcut, ) - stage.append(upsample_block) + up_block_list.append(upsample_block) - for _ in range(depth): + for _ in range(num_layers): block = get_block( - block_type[stage_id], - width, - width, - norm_type=norm_type[stage_id], - act_fn=act_fn[stage_id], - qkv_mutliscales=qkv_multiscales[stage_id], + block_type[i], + out_channel, + out_channel, + norm_type=norm_type[i], + act_fn=act_fn[i], + qkv_mutliscales=qkv_multiscales[i], ) - stage.append(block) + up_block_list.append(block) - stages.insert(0, nn.Sequential(*stage)) + up_blocks.insert(0, nn.Sequential(*up_block_list)) - self.stages = nn.ModuleList(stages) + self.up_blocks = nn.ModuleList(up_blocks) channels = block_out_channels[0] if layers_per_block[0] > 0 else block_out_channels[1] - self.norm_out = RMSNormNd(channels, eps=1e-5, elementwise_affine=True, bias=True, channel_dim=1) + self.norm_out = RMSNorm(channels, 1e-5, elementwise_affine=True, bias=True) self.conv_act = nn.ReLU() self.conv_out = None @@ -518,10 +529,10 @@ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: hidden_states = self.conv_in(hidden_states) + x - for stage in reversed(self.stages): - hidden_states = stage(hidden_states) + for up_block in reversed(self.up_blocks): + hidden_states = up_block(hidden_states) - hidden_states = self.norm_out(hidden_states) + hidden_states = self.norm_out(hidden_states.movedim(1, -1)).movedim(-1, 1) hidden_states = self.conv_act(hidden_states) hidden_states = self.conv_out(hidden_states) return hidden_states @@ -575,7 +586,8 @@ def __init__( latent_channels: int = 32, encoder_block_types: Union[str, Tuple[str]] = "ResBlock", decoder_block_types: Union[str, Tuple[str]] = "ResBlock", - block_out_channels: Tuple[int, ...] = (128, 256, 512, 512, 1024, 1024), + encoder_block_out_channels: Tuple[int, ...] = (128, 256, 512, 512, 1024, 1024), + decoder_block_out_channels: Tuple[int, ...] = (128, 256, 512, 512, 1024, 1024), encoder_layers_per_block: Tuple[int] = (2, 2, 2, 3, 3, 3), decoder_layers_per_block: Tuple[int] = (3, 3, 3, 3, 3, 3), encoder_qkv_multiscales: Tuple[Tuple[int, ...], ...] = ((), (), (), (5,), (5,), (5,)), @@ -592,7 +604,7 @@ def __init__( in_channels=in_channels, latent_channels=latent_channels, block_type=encoder_block_types, - block_out_channels=block_out_channels, + block_out_channels=encoder_block_out_channels, layers_per_block=encoder_layers_per_block, qkv_multiscales=encoder_qkv_multiscales, downsample_block_type=downsample_block_type, @@ -601,7 +613,7 @@ def __init__( in_channels=in_channels, latent_channels=latent_channels, block_type=decoder_block_types, - block_out_channels=block_out_channels, + block_out_channels=decoder_block_out_channels, layers_per_block=decoder_layers_per_block, qkv_multiscales=decoder_qkv_multiscales, norm_type=decoder_norm_types, @@ -609,7 +621,7 @@ def __init__( upsample_block_type=upsample_block_type, ) - self.spatial_compression_ratio = 2 ** (len(block_out_channels) - 1) + self.spatial_compression_ratio = 2 ** (len(encoder_block_out_channels) - 1) self.temporal_compression_ratio = 1 def encode(self, x: torch.Tensor) -> torch.Tensor: diff --git a/src/diffusers/models/normalization.py b/src/diffusers/models/normalization.py index b94cda63906a..cee5786204ce 100644 --- a/src/diffusers/models/normalization.py +++ b/src/diffusers/models/normalization.py @@ -572,28 +572,3 @@ def __init__(self, p: int = 2, dim: int = -1, eps: float = 1e-12): def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: return F.normalize(hidden_states, p=self.p, dim=self.dim, eps=self.eps) - - -class RMSNormNd(nn.Module): - def __init__( - self, - dim: int, - eps: float, - elementwise_affine: bool = True, - bias: bool = False, - channel_dim: int = -1, - ) -> None: - super().__init__() - - self.norm = RMSNorm(dim, eps=eps, elementwise_affine=elementwise_affine, bias=bias) - self.channel_dim = channel_dim - - def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: - if self.channel_dim != -1: - hidden_states = hidden_states.movedim(self.channel_dim, -1) - hidden_states = self.norm(hidden_states) - hidden_states = hidden_states.movedim(-1, self.channel_dim) - else: - hidden_states = self.norm(hidden_states) - - return hidden_states From eb64d52c42ad0e1e636486b0cc90297f08f20ba2 Mon Sep 17 00:00:00 2001 From: Aryan Date: Wed, 4 Dec 2024 08:01:52 +0100 Subject: [PATCH 054/141] make style --- scripts/convert_dcae_to_diffusers.py | 20 ++++++++++++++++--- .../models/autoencoders/autoencoder_dc.py | 4 ++-- 2 files changed, 19 insertions(+), 5 deletions(-) diff --git a/scripts/convert_dcae_to_diffusers.py b/scripts/convert_dcae_to_diffusers.py index da401cd082f0..b8c9e72f2d5a 100644 --- a/scripts/convert_dcae_to_diffusers.py +++ b/scripts/convert_dcae_to_diffusers.py @@ -99,7 +99,7 @@ def convert_ae(config_name: str, dtype: torch.dtype): hub_id = f"mit-han-lab/{config_name}" ckpt_path = hf_hub_download(hub_id, "model.safetensors") original_state_dict = get_state_dict(load_file(ckpt_path)) - + ae = AutoencoderDC(**config).to(dtype=dtype) for key in list(original_state_dict.keys()): @@ -122,8 +122,22 @@ def get_ae_config(name: str): if name in ["dc-ae-f32c32-sana-1.0"]: config = { "latent_channels": 32, - "encoder_block_types": ("ResBlock", "ResBlock", "ResBlock", "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock"), - "decoder_block_types": ("ResBlock", "ResBlock", "ResBlock", "EfficientViTBlock", "EfficientViTBlock", "EfficientViTBlock"), + "encoder_block_types": ( + "ResBlock", + "ResBlock", + "ResBlock", + "EfficientViTBlock", + "EfficientViTBlock", + "EfficientViTBlock", + ), + "decoder_block_types": ( + "ResBlock", + "ResBlock", + "ResBlock", + "EfficientViTBlock", + "EfficientViTBlock", + "EfficientViTBlock", + ), "encoder_block_out_channels": (128, 256, 512, 512, 1024, 1024), "decoder_block_out_channels": (128, 256, 512, 512, 1024, 1024), "encoder_qkv_multiscales": ((), (), (), (5,), (5,), (5,)), diff --git a/src/diffusers/models/autoencoders/autoencoder_dc.py b/src/diffusers/models/autoencoders/autoencoder_dc.py index affd32b6ac7a..41ef306a5d63 100644 --- a/src/diffusers/models/autoencoders/autoencoder_dc.py +++ b/src/diffusers/models/autoencoders/autoencoder_dc.py @@ -88,7 +88,7 @@ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: hidden_states = self.conv1(hidden_states) hidden_states = self.nonlinearity(hidden_states) hidden_states = self.conv2(hidden_states) - + if self.norm_type == "rms_norm": hidden_states = self.norm(hidden_states.movedim(1, -1)).movedim(-1, 1) else: @@ -230,7 +230,7 @@ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: hidden_states = self.quadratic_attention(qkv) hidden_states = self.proj_out(hidden_states) - + if self.norm_type == "rms_norm": hidden_states = self.norm_out(hidden_states.movedim(1, -1)).movedim(-1, 1) else: From 30c3238339c9b9d7425078a2b2a4c565daf6bd36 Mon Sep 17 00:00:00 2001 From: Aryan Date: Wed, 4 Dec 2024 11:30:50 +0100 Subject: [PATCH 055/141] move mla to attention processor file; split qkv conv to linears --- scripts/convert_dcae_to_diffusers.py | 14 +- src/diffusers/models/attention_processor.py | 155 ++++++++++++++++ .../models/autoencoders/autoencoder_dc.py | 165 +----------------- src/diffusers/models/normalization.py | 12 ++ 4 files changed, 180 insertions(+), 166 deletions(-) diff --git a/scripts/convert_dcae_to_diffusers.py b/scripts/convert_dcae_to_diffusers.py index b8c9e72f2d5a..05e8b8d613fa 100644 --- a/scripts/convert_dcae_to_diffusers.py +++ b/scripts/convert_dcae_to_diffusers.py @@ -13,13 +13,13 @@ def remove_keys_(key: str, state_dict: Dict[str, Any]): def remap_qkv_(key: str, state_dict: Dict[str, Any]): - # qkv = state_dict.pop(key) - # q, k, v = torch.chunk(qkv, 3, dim=0) - # parent_module, _, _ = key.rpartition(".qkv.conv.weight") - # state_dict[f"{parent_module}.to_q.weight"] = q.squeeze() - # state_dict[f"{parent_module}.to_k.weight"] = k.squeeze() - # state_dict[f"{parent_module}.to_v.weight"] = v.squeeze() - state_dict[key.replace("qkv.conv", "to_qkv")] = state_dict.pop(key) + qkv = state_dict.pop(key) + q, k, v = torch.chunk(qkv, 3, dim=0) + parent_module, _, _ = key.rpartition(".qkv.conv.weight") + state_dict[f"{parent_module}.to_q.weight"] = q.squeeze() + state_dict[f"{parent_module}.to_k.weight"] = k.squeeze() + state_dict[f"{parent_module}.to_v.weight"] = v.squeeze() + # state_dict[key.replace("qkv.conv", "to_qkv")] = state_dict.pop(key) AE_KEYS_RENAME_DICT = { diff --git a/src/diffusers/models/attention_processor.py b/src/diffusers/models/attention_processor.py index 7351801368dd..b7711a0ee124 100644 --- a/src/diffusers/models/attention_processor.py +++ b/src/diffusers/models/attention_processor.py @@ -752,6 +752,161 @@ def fuse_projections(self, fuse=True): self.fused_projections = fuse +class MultiscaleAttentionProjection(nn.Module): + def __init__( + self, + in_channels: int, + num_attention_heads: int, + kernel_size: int, + ) -> None: + super().__init__() + + self.proj_in = nn.Conv2d( + 3 * in_channels, + 3 * in_channels, + kernel_size, + padding=kernel_size // 2, + groups=3 * in_channels, + bias=False, + ) + self.proj_out = nn.Conv2d( + 3 * in_channels, 3 * in_channels, 1, 1, 0, groups=3 * num_attention_heads, bias=False + ) + + def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: + hidden_states = self.proj_in(hidden_states) + hidden_states = self.proj_out(hidden_states) + return hidden_states + + +class MultiscaleLinearAttention(nn.Module): + r"""Lightweight multi-scale linear attention""" + + def __init__( + self, + in_channels: int, + out_channels: int, + num_attention_heads: Optional[int] = None, + heads_ratio: float = 1.0, + attention_head_dim: int = 8, + norm_type: str = "batch_norm", + kernel_sizes: Tuple[int, ...] = (5,), + eps: float = 1e-15, + ): + super().__init__() + + # To prevent circular import + from .normalization import get_normalization + + self.eps = eps + self.attention_head_dim = attention_head_dim + self.norm_type = norm_type + + num_attention_heads = ( + int(in_channels // attention_head_dim * heads_ratio) + if num_attention_heads is None + else num_attention_heads + ) + inner_dim = num_attention_heads * attention_head_dim + + # self.to_qkv = nn.Conv2d(in_channels, 3 * inner_dim, 1, 1, 0, bias=False) + self.to_q = nn.Linear(in_channels, inner_dim, bias=False) + self.to_k = nn.Linear(in_channels, inner_dim, bias=False) + self.to_v = nn.Linear(in_channels, inner_dim, bias=False) + + self.to_qkv_multiscale = nn.ModuleList() + for kernel_size in kernel_sizes: + self.to_qkv_multiscale.append(MultiscaleAttentionProjection(inner_dim, num_attention_heads, kernel_size)) + + self.kernel_nonlinearity = nn.ReLU() + self.proj_out = nn.Conv2d(inner_dim * (1 + len(kernel_sizes)), out_channels, 1, 1, 0, bias=False) + self.norm_out = get_normalization(norm_type, num_features=out_channels) + + def linear_attention(self, qkv: torch.Tensor) -> torch.Tensor: + batch_size, _, height, width = qkv.shape + + qkv = qkv.float() + qkv = torch.reshape(qkv, (batch_size, -1, 3 * self.attention_head_dim, height * width)) + + query, key, value = ( + qkv[:, :, 0 : self.attention_head_dim], + qkv[:, :, self.attention_head_dim : 2 * self.attention_head_dim], + qkv[:, :, 2 * self.attention_head_dim :], + ) + + # lightweight linear attention + query = self.kernel_nonlinearity(query) + key = self.kernel_nonlinearity(key) + value = F.pad(value, (0, 0, 0, 1), mode="constant", value=1) + + key_T = key.transpose(-1, -2) + scores = torch.matmul(value, key_T) + output = torch.matmul(scores, query) + + output = output.float() + output = output[:, :, :-1] / (output[:, :, -1:] + self.eps) + output = torch.reshape(output, (batch_size, -1, height, width)) + + return output + + def quadratic_attention(self, qkv: torch.Tensor) -> torch.Tensor: + batch_size, _, height, width = list(qkv.size()) + + qkv = torch.reshape(qkv, (batch_size, -1, 3 * self.attention_head_dim, height * width)) + query, key, value = ( + qkv[:, :, 0 : self.attention_head_dim], + qkv[:, :, self.attention_head_dim : 2 * self.attention_head_dim], + qkv[:, :, 2 * self.attention_head_dim :], + ) + + query = self.kernel_nonlinearity(query) + key = self.kernel_nonlinearity(key) + + scores = torch.matmul(key.transpose(-1, -2), query) + + original_dtype = scores.dtype + scores = scores.float() + scores = scores / (torch.sum(scores, dim=2, keepdim=True) + self.eps) + scores = scores.to(original_dtype) + + output = torch.matmul(value, scores) + output = torch.reshape(output, (batch_size, -1, height, width)) + + return output + + def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: + residual = hidden_states + + # qkv = self.to_qkv(hidden_states) + hidden_states = hidden_states.movedim(1, 3) + query = self.to_q(hidden_states) + key = self.to_k(hidden_states) + value = self.to_v(hidden_states) + qkv = torch.cat([query, key, value], dim=3) + qkv = qkv.movedim(3, 1) + + multi_scale_qkv = [qkv] + for block in self.to_qkv_multiscale: + multi_scale_qkv.append(block(qkv)) + + qkv = torch.cat(multi_scale_qkv, dim=1) + + height, width = qkv.shape[-2:] + if height * width > self.attention_head_dim: + hidden_states = self.linear_attention(qkv).to(qkv.dtype) + else: + hidden_states = self.quadratic_attention(qkv) + + hidden_states = self.proj_out(hidden_states) + + if self.norm_type == "rms_norm": + hidden_states = self.norm_out(hidden_states.movedim(1, -1)).movedim(-1, 1) + else: + hidden_states = self.norm_out(hidden_states) + + return hidden_states + residual + + class AttnProcessor: r""" Default processor for performing attention-related computations. diff --git a/src/diffusers/models/autoencoders/autoencoder_dc.py b/src/diffusers/models/autoencoders/autoencoder_dc.py index 41ef306a5d63..6c3037deeffe 100644 --- a/src/diffusers/models/autoencoders/autoencoder_dc.py +++ b/src/diffusers/models/autoencoders/autoencoder_dc.py @@ -21,20 +21,9 @@ from ...configuration_utils import ConfigMixin, register_to_config from ..activations import get_activation +from ..attention_processor import MultiscaleLinearAttention from ..modeling_utils import ModelMixin -from ..normalization import RMSNorm - - -def get_norm_layer(name: Optional[str] = "batch_norm", num_features: Optional[int] = None) -> Optional[nn.Module]: - if name is None: - norm = None - elif name == "rms_norm": - norm = RMSNorm(num_features, eps=1e-5, elementwise_affine=True, bias=True) - elif name == "batch_norm": - norm = nn.BatchNorm2d(num_features=num_features) - else: - raise ValueError(f"norm {name} is not supported") - return norm +from ..normalization import RMSNorm, get_normalization class GLUMBConv(nn.Module): @@ -81,7 +70,7 @@ def __init__( self.nonlinearity = get_activation(act_fn) if act_fn is not None else nn.Identity() self.conv1 = nn.Conv2d(in_channels, in_channels, 3, 1, 1) self.conv2 = nn.Conv2d(in_channels, out_channels, 3, 1, 1, bias=False) - self.norm = get_norm_layer(norm_type, out_channels) + self.norm = get_normalization(norm_type, out_channels) def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: residual = hidden_states @@ -93,149 +82,7 @@ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: hidden_states = self.norm(hidden_states.movedim(1, -1)).movedim(-1, 1) else: hidden_states = self.norm(hidden_states) - return hidden_states + residual - - -class MLAProjection(nn.Module): - def __init__( - self, - in_channels: int, - num_attention_heads: int, - kernel_size: int, - ) -> None: - super().__init__() - - self.proj_in = nn.Conv2d( - 3 * in_channels, - 3 * in_channels, - kernel_size, - padding=kernel_size // 2, - groups=3 * in_channels, - bias=False, - ) - self.proj_out = nn.Conv2d( - 3 * in_channels, 3 * in_channels, 1, 1, 0, groups=3 * num_attention_heads, bias=False - ) - - def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: - hidden_states = self.proj_in(hidden_states) - hidden_states = self.proj_out(hidden_states) - return hidden_states - - -class LiteMLA(nn.Module): - r"""Lightweight multi-scale linear attention""" - - def __init__( - self, - in_channels: int, - out_channels: int, - num_attention_heads: Optional[int] = None, - heads_ratio: float = 1.0, - attention_head_dim: int = 8, - norm_type: str = "batch_norm", - kernel_sizes: Tuple[int, ...] = (5,), - eps: float = 1e-15, - ): - super().__init__() - - self.eps = eps - self.attention_head_dim = attention_head_dim - self.norm_type = norm_type - - num_attention_heads = ( - int(in_channels // attention_head_dim * heads_ratio) - if num_attention_heads is None - else num_attention_heads - ) - inner_dim = num_attention_heads * attention_head_dim - - self.to_qkv = nn.Conv2d(in_channels, 3 * inner_dim, 1, 1, 0, bias=False) - - self.to_qkv_multiscale = nn.ModuleList() - for kernel_size in kernel_sizes: - self.to_qkv_multiscale.append(MLAProjection(inner_dim, num_attention_heads, kernel_size)) - - self.kernel_nonlinearity = nn.ReLU() - self.proj_out = nn.Conv2d(inner_dim * (1 + len(kernel_sizes)), out_channels, 1, 1, 0, bias=False) - self.norm_out = get_norm_layer(norm_type, num_features=out_channels) - - def linear_attention(self, qkv: torch.Tensor) -> torch.Tensor: - batch_size, _, height, width = qkv.shape - - qkv = qkv.float() - qkv = torch.reshape(qkv, (batch_size, -1, 3 * self.attention_head_dim, height * width)) - - query, key, value = ( - qkv[:, :, 0 : self.attention_head_dim], - qkv[:, :, self.attention_head_dim : 2 * self.attention_head_dim], - qkv[:, :, 2 * self.attention_head_dim :], - ) - - # lightweight linear attention - query = self.kernel_nonlinearity(query) - key = self.kernel_nonlinearity(key) - value = F.pad(value, (0, 0, 0, 1), mode="constant", value=1) - - key_T = key.transpose(-1, -2) - scores = torch.matmul(value, key_T) - output = torch.matmul(scores, query) - - output = output.float() - output = output[:, :, :-1] / (output[:, :, -1:] + self.eps) - output = torch.reshape(output, (batch_size, -1, height, width)) - - return output - - def quadratic_attention(self, qkv: torch.Tensor) -> torch.Tensor: - batch_size, _, height, width = list(qkv.size()) - - qkv = torch.reshape(qkv, (batch_size, -1, 3 * self.attention_head_dim, height * width)) - query, key, value = ( - qkv[:, :, 0 : self.attention_head_dim], - qkv[:, :, self.attention_head_dim : 2 * self.attention_head_dim], - qkv[:, :, 2 * self.attention_head_dim :], - ) - - query = self.kernel_nonlinearity(query) - key = self.kernel_nonlinearity(key) - - scores = torch.matmul(key.transpose(-1, -2), query) - - original_dtype = scores.dtype - scores = scores.float() - scores = scores / (torch.sum(scores, dim=2, keepdim=True) + self.eps) - scores = scores.to(original_dtype) - - output = torch.matmul(value, scores) - output = torch.reshape(output, (batch_size, -1, height, width)) - - return output - - def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: - residual = hidden_states - - qkv = self.to_qkv(hidden_states) - - multi_scale_qkv = [qkv] - for block in self.to_qkv_multiscale: - multi_scale_qkv.append(block(qkv)) - - qkv = torch.cat(multi_scale_qkv, dim=1) - - height, width = qkv.shape[-2:] - if height * width > self.attention_head_dim: - hidden_states = self.linear_attention(qkv).to(qkv.dtype) - else: - hidden_states = self.quadratic_attention(qkv) - - hidden_states = self.proj_out(hidden_states) - - if self.norm_type == "rms_norm": - hidden_states = self.norm_out(hidden_states.movedim(1, -1)).movedim(-1, 1) - else: - hidden_states = self.norm_out(hidden_states) - + return hidden_states + residual @@ -247,10 +94,10 @@ def __init__( dim: int = 32, qkv_multiscales: Tuple[int, ...] = (5,), norm_type: str = "batch_norm", - ): + ) -> None: super().__init__() - self.attn = LiteMLA( + self.attn = MultiscaleLinearAttention( in_channels=in_channels, out_channels=in_channels, heads_ratio=heads_ratio, diff --git a/src/diffusers/models/normalization.py b/src/diffusers/models/normalization.py index cee5786204ce..78e0208987bb 100644 --- a/src/diffusers/models/normalization.py +++ b/src/diffusers/models/normalization.py @@ -572,3 +572,15 @@ def __init__(self, p: int = 2, dim: int = -1, eps: float = 1e-12): def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: return F.normalize(hidden_states, p=self.p, dim=self.dim, eps=self.eps) + + +def get_normalization(norm_type: str = "batch_norm", num_features: Optional[int] = None, eps: float = 1e-5, elementwise_affine: bool = True, bias: bool = True) -> nn.Module: + if norm_type == "rms_norm": + norm = RMSNorm(num_features, eps=eps, elementwise_affine=elementwise_affine, bias=bias) + elif norm_type == "layer_norm": + norm = nn.LayerNorm(num_features, eps=eps, elementwise_affine=elementwise_affine, bias=bias) + elif norm_type == "batch_norm": + norm = nn.BatchNorm2d(num_features, eps=eps, affine=elementwise_affine) + else: + raise ValueError(f"{norm_type=} is not supported.") + return norm From 39a947ce7d7011a93816a179ac9002c5809dc898 Mon Sep 17 00:00:00 2001 From: Aryan Date: Wed, 4 Dec 2024 12:37:34 +0100 Subject: [PATCH 056/141] refactor --- scripts/convert_dcae_to_diffusers.py | 8 +- src/diffusers/models/attention_processor.py | 210 ++++++++++-------- .../models/autoencoders/autoencoder_dc.py | 9 +- src/diffusers/models/normalization.py | 8 +- 4 files changed, 140 insertions(+), 95 deletions(-) diff --git a/scripts/convert_dcae_to_diffusers.py b/scripts/convert_dcae_to_diffusers.py index 05e8b8d613fa..52b32356f8ee 100644 --- a/scripts/convert_dcae_to_diffusers.py +++ b/scripts/convert_dcae_to_diffusers.py @@ -19,7 +19,11 @@ def remap_qkv_(key: str, state_dict: Dict[str, Any]): state_dict[f"{parent_module}.to_q.weight"] = q.squeeze() state_dict[f"{parent_module}.to_k.weight"] = k.squeeze() state_dict[f"{parent_module}.to_v.weight"] = v.squeeze() - # state_dict[key.replace("qkv.conv", "to_qkv")] = state_dict.pop(key) + + +def remap_proj_conv_(key: str, state_dict: Dict[str, Any]): + parent_module, _, _ = key.rpartition(".proj.conv.weight") + state_dict[f"{parent_module}.to_out.weight"] = state_dict.pop(key).squeeze() AE_KEYS_RENAME_DICT = { @@ -40,7 +44,6 @@ def remap_qkv_(key: str, state_dict: Dict[str, Any]): "conv1.conv": "conv1", "conv2.conv": "conv2", "conv2.norm": "norm", - "proj.conv": "proj_out", "proj.norm": "norm_out", # encoder "encoder.project_in.conv": "encoder.conv_in", @@ -76,6 +79,7 @@ def remap_qkv_(key: str, state_dict: Dict[str, Any]): AE_SPECIAL_KEYS_REMAP = { "qkv.conv.weight": remap_qkv_, + "proj.conv.weight": remap_proj_conv_, } diff --git a/src/diffusers/models/attention_processor.py b/src/diffusers/models/attention_processor.py index b7711a0ee124..ffb17aba502e 100644 --- a/src/diffusers/models/attention_processor.py +++ b/src/diffusers/models/attention_processor.py @@ -752,7 +752,7 @@ def fuse_projections(self, fuse=True): self.fused_projections = fuse -class MultiscaleAttentionProjection(nn.Module): +class SanaMultiscaleAttentionProjection(nn.Module): def __init__( self, in_channels: int, @@ -761,17 +761,16 @@ def __init__( ) -> None: super().__init__() + channels = 3 * in_channels self.proj_in = nn.Conv2d( - 3 * in_channels, - 3 * in_channels, + channels, + channels, kernel_size, padding=kernel_size // 2, groups=3 * in_channels, bias=False, ) - self.proj_out = nn.Conv2d( - 3 * in_channels, 3 * in_channels, 1, 1, 0, groups=3 * num_attention_heads, bias=False - ) + self.proj_out = nn.Conv2d(channels, channels, 1, 1, 0, groups=3 * num_attention_heads, bias=False) def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: hidden_states = self.proj_in(hidden_states) @@ -779,7 +778,7 @@ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: return hidden_states -class MultiscaleLinearAttention(nn.Module): +class SanaMultiscaleLinearAttention(nn.Module): r"""Lightweight multi-scale linear attention""" def __init__( @@ -792,6 +791,7 @@ def __init__( norm_type: str = "batch_norm", kernel_sizes: Tuple[int, ...] = (5,), eps: float = 1e-15, + residual_connection: bool = False, ): super().__init__() @@ -801,6 +801,7 @@ def __init__( self.eps = eps self.attention_head_dim = attention_head_dim self.norm_type = norm_type + self.residual_connection = residual_connection num_attention_heads = ( int(in_channels // attention_head_dim * heads_ratio) @@ -809,102 +810,32 @@ def __init__( ) inner_dim = num_attention_heads * attention_head_dim - # self.to_qkv = nn.Conv2d(in_channels, 3 * inner_dim, 1, 1, 0, bias=False) self.to_q = nn.Linear(in_channels, inner_dim, bias=False) self.to_k = nn.Linear(in_channels, inner_dim, bias=False) self.to_v = nn.Linear(in_channels, inner_dim, bias=False) self.to_qkv_multiscale = nn.ModuleList() for kernel_size in kernel_sizes: - self.to_qkv_multiscale.append(MultiscaleAttentionProjection(inner_dim, num_attention_heads, kernel_size)) + self.to_qkv_multiscale.append( + SanaMultiscaleAttentionProjection(inner_dim, num_attention_heads, kernel_size) + ) - self.kernel_nonlinearity = nn.ReLU() - self.proj_out = nn.Conv2d(inner_dim * (1 + len(kernel_sizes)), out_channels, 1, 1, 0, bias=False) + self.nonlinearity = nn.ReLU() + self.to_out = nn.Linear(inner_dim * (1 + len(kernel_sizes)), out_channels, bias=False) self.norm_out = get_normalization(norm_type, num_features=out_channels) - def linear_attention(self, qkv: torch.Tensor) -> torch.Tensor: - batch_size, _, height, width = qkv.shape - - qkv = qkv.float() - qkv = torch.reshape(qkv, (batch_size, -1, 3 * self.attention_head_dim, height * width)) - - query, key, value = ( - qkv[:, :, 0 : self.attention_head_dim], - qkv[:, :, self.attention_head_dim : 2 * self.attention_head_dim], - qkv[:, :, 2 * self.attention_head_dim :], - ) - - # lightweight linear attention - query = self.kernel_nonlinearity(query) - key = self.kernel_nonlinearity(key) - value = F.pad(value, (0, 0, 0, 1), mode="constant", value=1) - - key_T = key.transpose(-1, -2) - scores = torch.matmul(value, key_T) - output = torch.matmul(scores, query) - - output = output.float() - output = output[:, :, :-1] / (output[:, :, -1:] + self.eps) - output = torch.reshape(output, (batch_size, -1, height, width)) - - return output - - def quadratic_attention(self, qkv: torch.Tensor) -> torch.Tensor: - batch_size, _, height, width = list(qkv.size()) - - qkv = torch.reshape(qkv, (batch_size, -1, 3 * self.attention_head_dim, height * width)) - query, key, value = ( - qkv[:, :, 0 : self.attention_head_dim], - qkv[:, :, self.attention_head_dim : 2 * self.attention_head_dim], - qkv[:, :, 2 * self.attention_head_dim :], - ) - - query = self.kernel_nonlinearity(query) - key = self.kernel_nonlinearity(key) - - scores = torch.matmul(key.transpose(-1, -2), query) - - original_dtype = scores.dtype - scores = scores.float() - scores = scores / (torch.sum(scores, dim=2, keepdim=True) + self.eps) - scores = scores.to(original_dtype) - - output = torch.matmul(value, scores) - output = torch.reshape(output, (batch_size, -1, height, width)) - - return output + self.processor = SanaMultiscaleLinearAttnProcessor2_0() + self.processor_quadratic = SanaMultiscaleQuadraticAttnProcessor2_0() def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: - residual = hidden_states - - # qkv = self.to_qkv(hidden_states) - hidden_states = hidden_states.movedim(1, 3) - query = self.to_q(hidden_states) - key = self.to_k(hidden_states) - value = self.to_v(hidden_states) - qkv = torch.cat([query, key, value], dim=3) - qkv = qkv.movedim(3, 1) - - multi_scale_qkv = [qkv] - for block in self.to_qkv_multiscale: - multi_scale_qkv.append(block(qkv)) + height, width = hidden_states.shape[-2:] - qkv = torch.cat(multi_scale_qkv, dim=1) - - height, width = qkv.shape[-2:] if height * width > self.attention_head_dim: - hidden_states = self.linear_attention(qkv).to(qkv.dtype) - else: - hidden_states = self.quadratic_attention(qkv) - - hidden_states = self.proj_out(hidden_states) - - if self.norm_type == "rms_norm": - hidden_states = self.norm_out(hidden_states.movedim(1, -1)).movedim(-1, 1) + hidden_states = self.processor(self, hidden_states) else: - hidden_states = self.norm_out(hidden_states) + hidden_states = self.processor_quadratic(self, hidden_states) - return hidden_states + residual + return hidden_states class AttnProcessor: @@ -5160,6 +5091,109 @@ def __call__( return hidden_states +class SanaMultiscaleLinearAttnProcessor2_0: + r""" + Processor for implementing multiscale linear attention. + """ + + def __call__(self, attn: SanaMultiscaleLinearAttention, hidden_states: torch.Tensor) -> torch.Tensor: + residual = hidden_states + + batch_size, _, height, width = hidden_states.shape + original_dtype = hidden_states.dtype + + hidden_states = hidden_states.movedim(1, -1) + query = attn.to_q(hidden_states) + key = attn.to_k(hidden_states) + value = attn.to_v(hidden_states) + hidden_states = torch.cat([query, key, value], dim=3) + hidden_states = hidden_states.movedim(-1, 1) + + multiscale_hidden_states = [hidden_states] + for block in attn.to_qkv_multiscale: + multiscale_hidden_states.append(block(hidden_states)) + + hidden_states = torch.cat(multiscale_hidden_states, dim=1) + + hidden_states = hidden_states.to(dtype=torch.float32) + hidden_states = hidden_states.reshape(batch_size, -1, 3 * attn.attention_head_dim, height * width) + + query, key, value = hidden_states.chunk(3, dim=2) + query = attn.nonlinearity(query) + key = attn.nonlinearity(key) + value = F.pad(value, (0, 0, 0, 1), mode="constant", value=1) + + scores = torch.matmul(value, key.transpose(-1, -2)) + hidden_states = torch.matmul(scores, query) + + hidden_states = hidden_states.to(dtype=torch.float32) + hidden_states = hidden_states[:, :, :-1] / (hidden_states[:, :, -1:] + attn.eps) + hidden_states = hidden_states.to(dtype=original_dtype) + + hidden_states = torch.reshape(hidden_states, (batch_size, -1, height, width)) + hidden_states = attn.to_out(hidden_states.movedim(1, -1)).movedim(-1, 1) + + if attn.norm_type == "rms_norm": + hidden_states = attn.norm_out(hidden_states.movedim(1, -1)).movedim(-1, 1) + else: + hidden_states = attn.norm_out(hidden_states) + + if attn.residual_connection: + hidden_states = hidden_states + residual + + return hidden_states + + +class SanaMultiscaleQuadraticAttnProcessor2_0: + r""" + Processor for implementing multiscale quadratic attention. + """ + + def __call__(self, attn: SanaMultiscaleLinearAttention, hidden_states: torch.Tensor) -> torch.Tensor: + residual = hidden_states + + batch_size, _, height, width = list(hidden_states.size()) + original_dtype = hidden_states.dtype + + hidden_states = hidden_states.movedim(1, -1) + query = attn.to_q(hidden_states) + key = attn.to_k(hidden_states) + value = attn.to_v(hidden_states) + hidden_states = torch.cat([query, key, value], dim=3) + hidden_states = hidden_states.movedim(-1, 1) + + multi_scale_qkv = [hidden_states] + for block in attn.to_qkv_multiscale: + multi_scale_qkv.append(block(hidden_states)) + + hidden_states = torch.cat(multi_scale_qkv, dim=1) + + hidden_states = hidden_states.reshape(batch_size, -1, 3 * attn.attention_head_dim, height * width) + + query, key, value = hidden_states.chunk(3, dim=2) + query = attn.nonlinearity(query) + key = attn.nonlinearity(key) + + scores = torch.matmul(key.transpose(-1, -2), query) + scores = scores.to(dtype=torch.float32) + scores = scores / (torch.sum(scores, dim=2, keepdim=True) + attn.eps) + scores = scores.to(dtype=original_dtype) + hidden_states = torch.matmul(value, scores) + + hidden_states = torch.reshape(hidden_states, (batch_size, -1, height, width)) + hidden_states = attn.to_out(hidden_states.movedim(1, -1)).movedim(-1, 1) + + if attn.norm_type == "rms_norm": + hidden_states = attn.norm_out(hidden_states.movedim(1, -1)).movedim(-1, 1) + else: + hidden_states = attn.norm_out(hidden_states) + + if attn.residual_connection: + hidden_states = hidden_states + residual + + return hidden_states + + class LoRAAttnProcessor: def __init__(self): pass diff --git a/src/diffusers/models/autoencoders/autoencoder_dc.py b/src/diffusers/models/autoencoders/autoencoder_dc.py index 6c3037deeffe..6ac388ce641c 100644 --- a/src/diffusers/models/autoencoders/autoencoder_dc.py +++ b/src/diffusers/models/autoencoders/autoencoder_dc.py @@ -13,7 +13,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -from typing import Optional, Tuple, Union +from typing import Tuple, Union import torch import torch.nn as nn @@ -21,7 +21,7 @@ from ...configuration_utils import ConfigMixin, register_to_config from ..activations import get_activation -from ..attention_processor import MultiscaleLinearAttention +from ..attention_processor import SanaMultiscaleLinearAttention from ..modeling_utils import ModelMixin from ..normalization import RMSNorm, get_normalization @@ -82,7 +82,7 @@ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: hidden_states = self.norm(hidden_states.movedim(1, -1)).movedim(-1, 1) else: hidden_states = self.norm(hidden_states) - + return hidden_states + residual @@ -97,13 +97,14 @@ def __init__( ) -> None: super().__init__() - self.attn = MultiscaleLinearAttention( + self.attn = SanaMultiscaleLinearAttention( in_channels=in_channels, out_channels=in_channels, heads_ratio=heads_ratio, attention_head_dim=dim, norm_type=norm_type, kernel_sizes=qkv_multiscales, + residual_connection=True, ) self.conv_out = GLUMBConv( diff --git a/src/diffusers/models/normalization.py b/src/diffusers/models/normalization.py index 78e0208987bb..264de4d18d03 100644 --- a/src/diffusers/models/normalization.py +++ b/src/diffusers/models/normalization.py @@ -574,7 +574,13 @@ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: return F.normalize(hidden_states, p=self.p, dim=self.dim, eps=self.eps) -def get_normalization(norm_type: str = "batch_norm", num_features: Optional[int] = None, eps: float = 1e-5, elementwise_affine: bool = True, bias: bool = True) -> nn.Module: +def get_normalization( + norm_type: str = "batch_norm", + num_features: Optional[int] = None, + eps: float = 1e-5, + elementwise_affine: bool = True, + bias: bool = True, +) -> nn.Module: if norm_type == "rms_norm": norm = RMSNorm(num_features, eps=eps, elementwise_affine=elementwise_affine, bias=bias) elif norm_type == "layer_norm": From da834d5177d44e434f16cd6a67419136ad3c7d0d Mon Sep 17 00:00:00 2001 From: Aryan Date: Wed, 4 Dec 2024 13:18:51 +0100 Subject: [PATCH 057/141] add tests --- src/diffusers/models/attention_processor.py | 8 +- .../models/autoencoders/autoencoder_dc.py | 33 ++++--- .../stable_audio/pipeline_stable_audio.py | 3 +- .../test_models_autoencoder_dc.py | 87 +++++++++++++++++++ 4 files changed, 115 insertions(+), 16 deletions(-) create mode 100644 tests/models/autoencoders/test_models_autoencoder_dc.py diff --git a/src/diffusers/models/attention_processor.py b/src/diffusers/models/attention_processor.py index ffb17aba502e..12dd86dfe245 100644 --- a/src/diffusers/models/attention_processor.py +++ b/src/diffusers/models/attention_processor.py @@ -767,7 +767,7 @@ def __init__( channels, kernel_size, padding=kernel_size // 2, - groups=3 * in_channels, + groups=channels, bias=False, ) self.proj_out = nn.Conv2d(channels, channels, 1, 1, 0, groups=3 * num_attention_heads, bias=False) @@ -786,7 +786,7 @@ def __init__( in_channels: int, out_channels: int, num_attention_heads: Optional[int] = None, - heads_ratio: float = 1.0, + mult: float = 1.0, attention_head_dim: int = 8, norm_type: str = "batch_norm", kernel_sizes: Tuple[int, ...] = (5,), @@ -804,9 +804,7 @@ def __init__( self.residual_connection = residual_connection num_attention_heads = ( - int(in_channels // attention_head_dim * heads_ratio) - if num_attention_heads is None - else num_attention_heads + int(in_channels // attention_head_dim * mult) if num_attention_heads is None else num_attention_heads ) inner_dim = num_attention_heads * attention_head_dim diff --git a/src/diffusers/models/autoencoders/autoencoder_dc.py b/src/diffusers/models/autoencoders/autoencoder_dc.py index 6ac388ce641c..18174c5e82fb 100644 --- a/src/diffusers/models/autoencoders/autoencoder_dc.py +++ b/src/diffusers/models/autoencoders/autoencoder_dc.py @@ -24,6 +24,7 @@ from ..attention_processor import SanaMultiscaleLinearAttention from ..modeling_utils import ModelMixin from ..normalization import RMSNorm, get_normalization +from .vae import DecoderOutput class GLUMBConv(nn.Module): @@ -90,8 +91,8 @@ class EfficientViTBlock(nn.Module): def __init__( self, in_channels: int, - heads_ratio: float = 1.0, - dim: int = 32, + mult: float = 1.0, + attention_head_dim: int = 32, qkv_multiscales: Tuple[int, ...] = (5,), norm_type: str = "batch_norm", ) -> None: @@ -100,8 +101,8 @@ def __init__( self.attn = SanaMultiscaleLinearAttention( in_channels=in_channels, out_channels=in_channels, - heads_ratio=heads_ratio, - attention_head_dim=dim, + mult=mult, + attention_head_dim=attention_head_dim, norm_type=norm_type, kernel_sizes=qkv_multiscales, residual_connection=True, @@ -122,6 +123,7 @@ def get_block( block_type: str, in_channels: int, out_channels: int, + attention_head_dim: int, norm_type: str, act_fn: str, qkv_mutliscales: Tuple[int] = (), @@ -130,7 +132,9 @@ def get_block( block = ResBlock(in_channels, out_channels, norm_type, act_fn) elif block_type == "EfficientViTBlock": - block = EfficientViTBlock(in_channels, norm_type=norm_type, qkv_multiscales=qkv_mutliscales) + block = EfficientViTBlock( + in_channels, attention_head_dim=attention_head_dim, norm_type=norm_type, qkv_multiscales=qkv_mutliscales + ) else: raise ValueError(f"Block with {block_type=} is not supported.") @@ -224,6 +228,7 @@ def __init__( self, in_channels: int, latent_channels: int, + attention_head_dim: int = 32, block_type: Union[str, Tuple[str]] = "ResBlock", block_out_channels: Tuple[int] = (128, 256, 512, 512, 1024, 1024), layers_per_block: Tuple[int] = (2, 2, 2, 2, 2, 2), @@ -262,6 +267,7 @@ def __init__( block_type[i], out_channel, out_channel, + attention_head_dim=attention_head_dim, norm_type="rms_norm", act_fn="silu", qkv_mutliscales=qkv_multiscales[i], @@ -305,6 +311,7 @@ def __init__( self, in_channels: int, latent_channels: int, + attention_head_dim: int = 32, block_type: Union[str, Tuple[str]] = "ResBlock", block_out_channels: Tuple[int] = (128, 256, 512, 512, 1024, 1024), layers_per_block: Tuple[int] = (2, 2, 2, 2, 2, 2), @@ -348,6 +355,7 @@ def __init__( block_type[i], out_channel, out_channel, + attention_head_dim=attention_head_dim, norm_type=norm_type[i], act_fn=act_fn[i], qkv_mutliscales=qkv_multiscales[i], @@ -425,13 +433,14 @@ class AutoencoderDC(ModelMixin, ConfigMixin): A scaling factor applied during model operations. """ - _supports_gradient_checkpointing = True + _supports_gradient_checkpointing = False @register_to_config def __init__( self, in_channels: int = 3, latent_channels: int = 32, + attention_head_dim: int = 32, encoder_block_types: Union[str, Tuple[str]] = "ResBlock", decoder_block_types: Union[str, Tuple[str]] = "ResBlock", encoder_block_out_channels: Tuple[int, ...] = (128, 256, 512, 512, 1024, 1024), @@ -451,6 +460,7 @@ def __init__( self.encoder = Encoder( in_channels=in_channels, latent_channels=latent_channels, + attention_head_dim=attention_head_dim, block_type=encoder_block_types, block_out_channels=encoder_block_out_channels, layers_per_block=encoder_layers_per_block, @@ -460,6 +470,7 @@ def __init__( self.decoder = Decoder( in_channels=in_channels, latent_channels=latent_channels, + attention_head_dim=attention_head_dim, block_type=decoder_block_types, block_out_channels=decoder_block_out_channels, layers_per_block=decoder_layers_per_block, @@ -480,7 +491,9 @@ def decode(self, x: torch.Tensor) -> torch.Tensor: x = self.decoder(x) return x - def forward(self, x: torch.Tensor) -> torch.Tensor: - x = self.encoder(x) - x = self.decoder(x) - return x + def forward(self, sample: torch.Tensor, return_dict: bool = True) -> torch.Tensor: + z = self.encode(sample) + dec = self.decode(z) + if not return_dict: + return (dec,) + return DecoderOutput(sample=dec) diff --git a/src/diffusers/pipelines/stable_audio/pipeline_stable_audio.py b/src/diffusers/pipelines/stable_audio/pipeline_stable_audio.py index a30af53f77a7..cef63cf7e63d 100644 --- a/src/diffusers/pipelines/stable_audio/pipeline_stable_audio.py +++ b/src/diffusers/pipelines/stable_audio/pipeline_stable_audio.py @@ -34,6 +34,7 @@ from ..pipeline_utils import AudioPipelineOutput, DiffusionPipeline from .modeling_stable_audio import StableAudioProjectionModel + if is_torch_xla_available(): import torch_xla.core.xla_model as xm @@ -732,7 +733,7 @@ def __call__( if callback is not None and i % callback_steps == 0: step_idx = i // getattr(self.scheduler, "order", 1) callback(step_idx, t, latents) - + if XLA_AVAILABLE: xm.mark_step() diff --git a/tests/models/autoencoders/test_models_autoencoder_dc.py b/tests/models/autoencoders/test_models_autoencoder_dc.py new file mode 100644 index 000000000000..5f21593d8e04 --- /dev/null +++ b/tests/models/autoencoders/test_models_autoencoder_dc.py @@ -0,0 +1,87 @@ +# coding=utf-8 +# Copyright 2024 HuggingFace Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import unittest + +from diffusers import AutoencoderDC +from diffusers.utils.testing_utils import ( + enable_full_determinism, + floats_tensor, + torch_device, +) + +from ..test_modeling_common import ModelTesterMixin, UNetTesterMixin + + +enable_full_determinism() + + +class AutoencoderDCTests(ModelTesterMixin, UNetTesterMixin, unittest.TestCase): + model_class = AutoencoderDC + main_input_name = "sample" + base_precision = 1e-2 + + def get_autoencoder_dc_config(self): + return { + "in_channels": 3, + "latent_channels": 4, + "attention_head_dim": 2, + "encoder_block_types": ( + "ResBlock", + "EfficientViTBlock", + ), + "decoder_block_types": ( + "ResBlock", + "EfficientViTBlock", + ), + "encoder_block_out_channels": (8, 8), + "decoder_block_out_channels": (8, 8), + "encoder_qkv_multiscales": ((), (5,)), + "decoder_qkv_multiscales": ((), (5,)), + "encoder_layers_per_block": (1, 1), + "decoder_layers_per_block": [1, 1], + "downsample_block_type": "conv", + "upsample_block_type": "interpolate", + "decoder_norm_types": "rms_norm", + "decoder_act_fns": "silu", + "scaling_factor": 0.41407, + } + + @property + def dummy_input(self): + batch_size = 4 + num_channels = 3 + sizes = (32, 32) + + image = floats_tensor((batch_size, num_channels) + sizes).to(torch_device) + + return {"sample": image} + + @property + def input_shape(self): + return (3, 32, 32) + + @property + def output_shape(self): + return (3, 32, 32) + + def prepare_init_args_and_inputs_for_common(self): + init_dict = self.get_autoencoder_dc_config() + inputs_dict = self.dummy_input + return init_dict, inputs_dict + + @unittest.skip("AutoencoderDC does not support `norm_num_groups` because it does not use GroupNorm.") + def test_forward_with_norm_groups(self): + pass From d6c748c7e665cbf0f4392dedd2b4b32253b3d462 Mon Sep 17 00:00:00 2001 From: Aryan Date: Wed, 4 Dec 2024 20:56:24 +0100 Subject: [PATCH 058/141] from original file loader --- scripts/convert_dcae_to_diffusers.py | 4 - src/diffusers/loaders/single_file_model.py | 8 +- src/diffusers/loaders/single_file_utils.py | 256 +++++++++++++++++- .../models/autoencoders/autoencoder_dc.py | 3 +- 4 files changed, 264 insertions(+), 7 deletions(-) diff --git a/scripts/convert_dcae_to_diffusers.py b/scripts/convert_dcae_to_diffusers.py index 52b32356f8ee..15f79a8154e6 100644 --- a/scripts/convert_dcae_to_diffusers.py +++ b/scripts/convert_dcae_to_diffusers.py @@ -8,10 +8,6 @@ from diffusers import AutoencoderDC -def remove_keys_(key: str, state_dict: Dict[str, Any]): - state_dict.pop(key) - - def remap_qkv_(key: str, state_dict: Dict[str, Any]): qkv = state_dict.pop(key) q, k, v = torch.chunk(qkv, 3, dim=0) diff --git a/src/diffusers/loaders/single_file_model.py b/src/diffusers/loaders/single_file_model.py index be3139057078..403cf280635c 100644 --- a/src/diffusers/loaders/single_file_model.py +++ b/src/diffusers/loaders/single_file_model.py @@ -23,12 +23,14 @@ from .single_file_utils import ( SingleFileComponentError, convert_animatediff_checkpoint_to_diffusers, + convert_autoencoder_dc_checkpoint_to_diffusers, convert_controlnet_checkpoint, convert_flux_transformer_checkpoint_to_diffusers, convert_ldm_unet_checkpoint, convert_ldm_vae_checkpoint, convert_sd3_transformer_checkpoint_to_diffusers, convert_stable_cascade_unet_single_file_to_diffusers, + create_autoencoder_dc_config_from_original, create_controlnet_diffusers_config_from_ldm, create_unet_diffusers_config_from_ldm, create_vae_diffusers_config_from_ldm, @@ -82,6 +84,10 @@ "checkpoint_mapping_fn": convert_flux_transformer_checkpoint_to_diffusers, "default_subfolder": "transformer", }, + "AutoencoderDC": { + "checkpoint_mapping_fn": convert_autoencoder_dc_checkpoint_to_diffusers, + "config_mapping_fn": create_autoencoder_dc_config_from_original, + }, } @@ -228,7 +234,7 @@ def from_single_file(cls, pretrained_model_link_or_path_or_dict: Optional[str] = if config_mapping_fn is None: raise ValueError( ( - f"`original_config` has been provided for {mapping_class_name} but no mapping function" + f"`original_config` has been provided for {mapping_class_name} but no mapping function " "was found to convert the original config to a Diffusers config in" "`diffusers.loaders.single_file_utils`" ) diff --git a/src/diffusers/loaders/single_file_utils.py b/src/diffusers/loaders/single_file_utils.py index 10742873ded1..d86573da58db 100644 --- a/src/diffusers/loaders/single_file_utils.py +++ b/src/diffusers/loaders/single_file_utils.py @@ -12,7 +12,12 @@ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. -"""Conversion script for the Stable Diffusion checkpoints.""" + +""" +Conversion scripts for the various modeling checkpoints. These scripts convert original model implementations to +Diffusers adapted versions. This usually only involves renaming/remapping the state dict keys and changing some +modeling components partially (for example, splitting a single QKV linear to individual Q, K, V layers). +""" import copy import os @@ -92,6 +97,7 @@ "double_blocks.0.img_attn.norm.key_norm.scale", "model.diffusion_model.double_blocks.0.img_attn.norm.key_norm.scale", ], + "autoencoder_dc": "decoder.stages.0.op_list.0.main.conv.conv.weight", } DIFFUSERS_DEFAULT_PIPELINE_PATHS = { @@ -2198,3 +2204,251 @@ def swap_scale_shift(weight): ) return converted_state_dict + + +def create_autoencoder_dc_config_from_original(original_config, checkpoint, **kwargs): + model_name = original_config.get("model_name", "dc-ae-f32c32-sana-1.0") + print("trying:", model_name) + + if model_name in ["dc-ae-f32c32-sana-1.0"]: + config = { + "latent_channels": 32, + "encoder_block_types": ( + "ResBlock", + "ResBlock", + "ResBlock", + "EfficientViTBlock", + "EfficientViTBlock", + "EfficientViTBlock", + ), + "decoder_block_types": ( + "ResBlock", + "ResBlock", + "ResBlock", + "EfficientViTBlock", + "EfficientViTBlock", + "EfficientViTBlock", + ), + "encoder_block_out_channels": (128, 256, 512, 512, 1024, 1024), + "decoder_block_out_channels": (128, 256, 512, 512, 1024, 1024), + "encoder_qkv_multiscales": ((), (), (), (5,), (5,), (5,)), + "decoder_qkv_multiscales": ((), (), (), (5,), (5,), (5,)), + "encoder_layers_per_block": (2, 2, 2, 3, 3, 3), + "decoder_layers_per_block": [3, 3, 3, 3, 3, 3], + "downsample_block_type": "conv", + "upsample_block_type": "interpolate", + "decoder_norm_types": "rms_norm", + "decoder_act_fns": "silu", + "scaling_factor": 0.41407, + } + elif model_name in ["dc-ae-f32c32-in-1.0", "dc-ae-f32c32-mix-1.0"]: + config = { + "latent_channels": 32, + "encoder_block_types": [ + "ResBlock", + "ResBlock", + "ResBlock", + "EfficientViTBlock", + "EfficientViTBlock", + "EfficientViTBlock", + ], + "decoder_block_types": [ + "ResBlock", + "ResBlock", + "ResBlock", + "EfficientViTBlock", + "EfficientViTBlock", + "EfficientViTBlock", + ], + "encoder_block_out_channels": [128, 256, 512, 512, 1024, 1024], + "decoder_block_out_channels": [128, 256, 512, 512, 1024, 1024], + "encoder_layers_per_block": [0, 4, 8, 2, 2, 2], + "decoder_layers_per_block": [0, 5, 10, 2, 2, 2], + "encoder_qkv_multiscales": ((), (), (), (), (), ()), + "decoder_qkv_multiscales": ((), (), (), (), (), ()), + "decoder_norm_types": ["batch_norm", "batch_norm", "batch_norm", "rms_norm", "rms_norm", "rms_norm"], + "decoder_act_fns": ["relu", "relu", "relu", "silu", "silu", "silu"], + } + if model_name == "dc-ae-f32c32-in-1.0": + config["scaling_factor"] = 0.3189 + elif model_name == "dc-ae-f32c32-mix-1.0": + config["scaling_factor"] = 0.4552 + elif model_name in ["dc-ae-f64c128-in-1.0", "dc-ae-f64c128-mix-1.0"]: + config = { + "latent_channels": 128, + "encoder_block_types": [ + "ResBlock", + "ResBlock", + "ResBlock", + "EfficientViTBlock", + "EfficientViTBlock", + "EfficientViTBlock", + "EfficientViTBlock", + ], + "decoder_block_types": [ + "ResBlock", + "ResBlock", + "ResBlock", + "EfficientViTBlock", + "EfficientViTBlock", + "EfficientViTBlock", + "EfficientViTBlock", + ], + "encoder_block_out_channels": [128, 256, 512, 512, 1024, 1024, 2048], + "decoder_block_out_channels": [128, 256, 512, 512, 1024, 1024, 2048], + "encoder_layers_per_block": [0, 4, 8, 2, 2, 2, 2], + "decoder_layers_per_block": [0, 5, 10, 2, 2, 2, 2], + "encoder_qkv_multiscales": ((), (), (), (), (), (), ()), + "decoder_qkv_multiscales": ((), (), (), (), (), (), ()), + "decoder_norm_types": [ + "batch_norm", + "batch_norm", + "batch_norm", + "rms_norm", + "rms_norm", + "rms_norm", + "rms_norm", + ], + "decoder_act_fns": ["relu", "relu", "relu", "silu", "silu", "silu", "silu"], + } + if model_name == "dc-ae-f64c128-in-1.0": + config["scaling_factor"] = 0.2889 + elif model_name == "dc-ae-f64c128-mix-1.0": + config["scaling_factor"] = 0.4538 + elif model_name in ["dc-ae-f128c512-in-1.0", "dc-ae-f128c512-mix-1.0"]: + config = { + "latent_channels": 512, + "encoder_block_types": [ + "ResBlock", + "ResBlock", + "ResBlock", + "EfficientViTBlock", + "EfficientViTBlock", + "EfficientViTBlock", + "EfficientViTBlock", + "EfficientViTBlock", + ], + "decoder_block_types": [ + "ResBlock", + "ResBlock", + "ResBlock", + "EfficientViTBlock", + "EfficientViTBlock", + "EfficientViTBlock", + "EfficientViTBlock", + "EfficientViTBlock", + ], + "encoder_block_out_channels": [128, 256, 512, 512, 1024, 1024, 2048, 2048], + "decoder_block_out_channels": [128, 256, 512, 512, 1024, 1024, 2048, 2048], + "encoder_layers_per_block": [0, 4, 8, 2, 2, 2, 2, 2], + "decoder_layers_per_block": [0, 5, 10, 2, 2, 2, 2, 2], + "encoder_qkv_multiscales": ((), (), (), (), (), (), (), ()), + "decoder_qkv_multiscales": ((), (), (), (), (), (), (), ()), + "decoder_norm_types": [ + "batch_norm", + "batch_norm", + "batch_norm", + "rms_norm", + "rms_norm", + "rms_norm", + "rms_norm", + "rms_norm", + ], + "decoder_act_fns": ["relu", "relu", "relu", "silu", "silu", "silu", "silu", "silu"], + } + if model_name == "dc-ae-f128c512-in-1.0": + config["scaling_factor"] = 0.4883 + elif model_name == "dc-ae-f128c512-mix-1.0": + config["scaling_factor"] = 0.3620 + + config.update({"model_name": model_name}) + + return config + + +def convert_autoencoder_dc_checkpoint_to_diffusers(config, checkpoint, **kwargs): + converted_state_dict = {key: checkpoint.pop(key) for key in list(checkpoint.keys())} + model_name = config.pop("model_name") + + def remap_qkv_(key: str, state_dict): + qkv = state_dict.pop(key) + q, k, v = torch.chunk(qkv, 3, dim=0) + parent_module, _, _ = key.rpartition(".qkv.conv.weight") + state_dict[f"{parent_module}.to_q.weight"] = q.squeeze() + state_dict[f"{parent_module}.to_k.weight"] = k.squeeze() + state_dict[f"{parent_module}.to_v.weight"] = v.squeeze() + + def remap_proj_conv_(key: str, state_dict): + parent_module, _, _ = key.rpartition(".proj.conv.weight") + state_dict[f"{parent_module}.to_out.weight"] = state_dict.pop(key).squeeze() + + AE_KEYS_RENAME_DICT = { + # common + "main.": "", + "op_list.": "", + "context_module": "attn", + "local_module": "conv_out", + # NOTE: The below two lines work because scales in the available configs only have a tuple length of 1 + # If there were more scales, there would be more layers, so a loop would be better to handle this + "aggreg.0.0": "to_qkv_multiscale.0.proj_in", + "aggreg.0.1": "to_qkv_multiscale.0.proj_out", + "depth_conv.conv": "conv_depth", + "inverted_conv.conv": "conv_inverted", + "point_conv.conv": "conv_point", + "point_conv.norm": "norm", + "conv.conv.": "conv.", + "conv1.conv": "conv1", + "conv2.conv": "conv2", + "conv2.norm": "norm", + "proj.norm": "norm_out", + # encoder + "encoder.project_in.conv": "encoder.conv_in", + "encoder.project_out.0.conv": "encoder.conv_out", + "encoder.stages": "encoder.down_blocks", + # decoder + "decoder.project_in.conv": "decoder.conv_in", + "decoder.project_out.0": "decoder.norm_out", + "decoder.project_out.2.conv": "decoder.conv_out", + "decoder.stages": "decoder.up_blocks", + } + + AE_F32C32_KEYS = { + "encoder.project_in.conv": "encoder.conv_in.conv", + "decoder.project_out.2.conv": "decoder.conv_out.conv", + } + + AE_F64C128_KEYS = { + "encoder.project_in.conv": "encoder.conv_in.conv", + "decoder.project_out.2.conv": "decoder.conv_out.conv", + } + + AE_F128C512_KEYS = { + "encoder.project_in.conv": "encoder.conv_in.conv", + "decoder.project_out.2.conv": "decoder.conv_out.conv", + } + + AE_SPECIAL_KEYS_REMAP = { + "qkv.conv.weight": remap_qkv_, + "proj.conv.weight": remap_proj_conv_, + } + + if "f32c32" in model_name and "sana" not in model_name: + AE_KEYS_RENAME_DICT.update(AE_F32C32_KEYS) + elif "f64c128" in model_name: + AE_KEYS_RENAME_DICT.update(AE_F64C128_KEYS) + elif "f128c512" in model_name: + AE_KEYS_RENAME_DICT.update(AE_F128C512_KEYS) + + for key in list(converted_state_dict.keys()): + new_key = key[:] + for replace_key, rename_key in AE_KEYS_RENAME_DICT.items(): + new_key = new_key.replace(replace_key, rename_key) + converted_state_dict[new_key] = converted_state_dict.pop(key) + + for key in list(converted_state_dict.keys()): + for special_key, handler_fn_inplace in AE_SPECIAL_KEYS_REMAP.items(): + if special_key not in key: + continue + handler_fn_inplace(key, converted_state_dict) + + return converted_state_dict diff --git a/src/diffusers/models/autoencoders/autoencoder_dc.py b/src/diffusers/models/autoencoders/autoencoder_dc.py index 18174c5e82fb..fd802c54edda 100644 --- a/src/diffusers/models/autoencoders/autoencoder_dc.py +++ b/src/diffusers/models/autoencoders/autoencoder_dc.py @@ -20,6 +20,7 @@ import torch.nn.functional as F from ...configuration_utils import ConfigMixin, register_to_config +from ...loaders import FromOriginalModelMixin from ..activations import get_activation from ..attention_processor import SanaMultiscaleLinearAttention from ..modeling_utils import ModelMixin @@ -394,7 +395,7 @@ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: return hidden_states -class AutoencoderDC(ModelMixin, ConfigMixin): +class AutoencoderDC(ModelMixin, ConfigMixin, FromOriginalModelMixin): r""" An Autoencoder model introduced in [DCAE](https://arxiv.org/abs/2410.10733) and used in [SANA](https://arxiv.org/abs/2410.10629). From 31f9fc6c96cc22bc30248f8d70adb8395bc5aafb Mon Sep 17 00:00:00 2001 From: Aryan Date: Wed, 4 Dec 2024 21:10:00 +0100 Subject: [PATCH 059/141] add docs --- docs/source/en/_toctree.yml | 2 + docs/source/en/api/models/autoencoder_dc.md | 56 +++++++++++++++++++++ 2 files changed, 58 insertions(+) create mode 100644 docs/source/en/api/models/autoencoder_dc.md diff --git a/docs/source/en/_toctree.yml b/docs/source/en/_toctree.yml index 2faabfec30ce..47eb922f525e 100644 --- a/docs/source/en/_toctree.yml +++ b/docs/source/en/_toctree.yml @@ -314,6 +314,8 @@ title: AutoencoderKLMochi - local: api/models/asymmetricautoencoderkl title: AsymmetricAutoencoderKL + - local: api/models/autoencoder_dc + title: AutoencoderDC - local: api/models/consistency_decoder_vae title: ConsistencyDecoderVAE - local: api/models/autoencoder_oobleck diff --git a/docs/source/en/api/models/autoencoder_dc.md b/docs/source/en/api/models/autoencoder_dc.md new file mode 100644 index 000000000000..8a084a9b2172 --- /dev/null +++ b/docs/source/en/api/models/autoencoder_dc.md @@ -0,0 +1,56 @@ + + +# AutoencoderDC + +*The 2D Autoencoder model used in [SANA](https://arxiv.org/papers/2410.10629) and introduced in [DCAE](https://huggingface.co/papers/2410.10733) by authors Junyu Chen, Han Cai, Junsong Chen, Enze Xie, Shang Yang, Haotian Tang, Muyang Li, Yao Lu, Song Han from MIT HAN Lab.* + +The following DCAE models are released and supported in Diffusers: +- [`mit-han-lab/dc-ae-f32c32-sana-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f32c32-sana-1.0) +- [`mit-han-lab/dc-ae-f32c32-in-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f32c32-in-1.0) +- [`mit-han-lab/dc-ae-f32c32-mix-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f32c32-mix-1.0) +- [`mit-han-lab/dc-ae-f64c128-in-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f64c128-in-1.0) +- [`mit-han-lab/dc-ae-f64c128-mix-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f64c128-mix-1.0) +- [`mit-han-lab/dc-ae-f128c512-in-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f128c512-in-1.0) +- [`mit-han-lab/dc-ae-f128c512-mix-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f128c512-mix-1.0) + +The models can be loaded with the following code snippet. + +```python +from diffusers import AutoencoderDC + +ae = AutoencoderDC.from_pretrained("mit-han-lab/dc-ae-f32c32-sana-1.0-diffusers", torch_dtype=torch.float32).to("cuda") +``` + +## Single file loading + +The `AutoencoderDC` implementation supports loading checkpoints shipped in the original format by MIT HAN Lab. The following example demonstrates how to load the `f128c512` checkpoint: + +```python +from diffusers import AutoencoderDC + +model_name = "dc-ae-f128c512-mix-1.0" +ae = AutoencoderDC.from_single_file( + f"https://huggingface.co/mit-han-lab/{model_name}/model.safetensors", + original_config=f"https://huggingface.co/mit-han-lab/{model_name}/resolve/main/config.json" +) +``` + +## AutoencoderDC + +[[autodoc]] AutoencoderDC + - decode + - all + +## DecoderOutput + +[[autodoc]] models.autoencoders.vae.DecoderOutput + From 6f29e2aba170719681f4d7649b9690215c6e7e6b Mon Sep 17 00:00:00 2001 From: Aryan Date: Wed, 4 Dec 2024 22:24:01 +0100 Subject: [PATCH 060/141] add standard autoencoder methods --- src/diffusers/loaders/single_file_utils.py | 1 - .../models/autoencoders/autoencoder_dc.py | 152 +++++++++++++++++- src/diffusers/models/autoencoders/vae.py | 13 ++ 3 files changed, 157 insertions(+), 9 deletions(-) diff --git a/src/diffusers/loaders/single_file_utils.py b/src/diffusers/loaders/single_file_utils.py index d86573da58db..682adef10915 100644 --- a/src/diffusers/loaders/single_file_utils.py +++ b/src/diffusers/loaders/single_file_utils.py @@ -2208,7 +2208,6 @@ def swap_scale_shift(weight): def create_autoencoder_dc_config_from_original(original_config, checkpoint, **kwargs): model_name = original_config.get("model_name", "dc-ae-f32c32-sana-1.0") - print("trying:", model_name) if model_name in ["dc-ae-f32c32-sana-1.0"]: config = { diff --git a/src/diffusers/models/autoencoders/autoencoder_dc.py b/src/diffusers/models/autoencoders/autoencoder_dc.py index fd802c54edda..2e40cca1b048 100644 --- a/src/diffusers/models/autoencoders/autoencoder_dc.py +++ b/src/diffusers/models/autoencoders/autoencoder_dc.py @@ -13,7 +13,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -from typing import Tuple, Union +from typing import Optional, Tuple, Union import torch import torch.nn as nn @@ -21,11 +21,12 @@ from ...configuration_utils import ConfigMixin, register_to_config from ...loaders import FromOriginalModelMixin +from ...utils.accelerate_utils import apply_forward_hook from ..activations import get_activation from ..attention_processor import SanaMultiscaleLinearAttention from ..modeling_utils import ModelMixin from ..normalization import RMSNorm, get_normalization -from .vae import DecoderOutput +from .vae import DecoderOutput, EncoderOutput class GLUMBConv(nn.Module): @@ -484,13 +485,148 @@ def __init__( self.spatial_compression_ratio = 2 ** (len(encoder_block_out_channels) - 1) self.temporal_compression_ratio = 1 - def encode(self, x: torch.Tensor) -> torch.Tensor: - x = self.encoder(x) - return x + # When decoding a batch of video latents at a time, one can save memory by slicing across the batch dimension + # to perform decoding of a single video latent at a time. + self.use_slicing = False - def decode(self, x: torch.Tensor) -> torch.Tensor: - x = self.decoder(x) - return x + # When decoding spatially large video latents, the memory requirement is very high. By breaking the video latent + # frames spatially into smaller tiles and performing multiple forward passes for decoding, and then blending the + # intermediate tiles together, the memory requirement can be lowered. + self.use_tiling = False + + # The minimal tile height and width for spatial tiling to be used + self.tile_sample_min_height = 512 + self.tile_sample_min_width = 512 + + # The minimal distance between two spatial tiles + self.tile_sample_stride_height = 448 + self.tile_sample_stride_width = 448 + + def enable_tiling( + self, + tile_sample_min_height: Optional[int] = None, + tile_sample_min_width: Optional[int] = None, + tile_sample_stride_height: Optional[float] = None, + tile_sample_stride_width: Optional[float] = None, + ) -> None: + r""" + Enable tiled VAE decoding. When this option is enabled, the VAE will split the input tensor into tiles to + compute decoding and encoding in several steps. This is useful for saving a large amount of memory and to allow + processing larger images. + + Args: + tile_sample_min_height (`int`, *optional*): + The minimum height required for a sample to be separated into tiles across the height dimension. + tile_sample_min_width (`int`, *optional*): + The minimum width required for a sample to be separated into tiles across the width dimension. + tile_sample_stride_height (`int`, *optional*): + The minimum amount of overlap between two consecutive vertical tiles. This is to ensure that there are + no tiling artifacts produced across the height dimension. + tile_sample_stride_width (`int`, *optional*): + The stride between two consecutive horizontal tiles. This is to ensure that there are no tiling + artifacts produced across the width dimension. + """ + self.use_tiling = True + self.tile_sample_min_height = tile_sample_min_height or self.tile_sample_min_height + self.tile_sample_min_width = tile_sample_min_width or self.tile_sample_min_width + self.tile_sample_stride_height = tile_sample_stride_height or self.tile_sample_stride_height + self.tile_sample_stride_width = tile_sample_stride_width or self.tile_sample_stride_width + + def disable_tiling(self) -> None: + r""" + Disable tiled VAE decoding. If `enable_tiling` was previously enabled, this method will go back to computing + decoding in one step. + """ + self.use_tiling = False + + def enable_slicing(self) -> None: + r""" + Enable sliced VAE decoding. When this option is enabled, the VAE will split the input tensor in slices to + compute decoding in several steps. This is useful to save some memory and allow larger batch sizes. + """ + self.use_slicing = True + + def disable_slicing(self) -> None: + r""" + Disable sliced VAE decoding. If `enable_slicing` was previously enabled, this method will go back to computing + decoding in one step. + """ + self.use_slicing = False + + def _encode(self, x: torch.Tensor) -> torch.Tensor: + batch_size, num_channels, height, width = x.shape + + if self.use_tiling and (width > self.tile_sample_min_width or height > self.tile_sample_min_height): + return self.tiled_encode(x, return_dict=False)[0] + + encoded = self.encoder(x) + + return encoded + + @apply_forward_hook + def encode(self, x: torch.Tensor, return_dict: bool = True) -> torch.Tensor: + r""" + Encode a batch of images into latents. + + Args: + x (`torch.Tensor`): Input batch of images. + return_dict (`bool`, defaults to `True`): + Whether to return a [`~models.autoencoder_kl.AutoencoderKLOutput`] instead of a plain tuple. + + Returns: + The latent representations of the encoded videos. If `return_dict` is True, a + [`~models.autoencoder_kl.AutoencoderKLOutput`] is returned, otherwise a plain `tuple` is returned. + """ + if self.use_slicing and x.shape[0] > 1: + encoded_slices = [self._encode(x_slice) for x_slice in x.split(1)] + encoded = torch.cat(encoded_slices) + else: + encoded = self._encode(x) + + if not return_dict: + return (encoded,) + return EncoderOutput(latent=encoded) + + def _decode(self, z: torch.Tensor) -> torch.Tensor: + batch_size, num_channels, height, width = z.shape + + if self.use_tiling and (width > self.tile_latent_min_width or height > self.tile_latent_min_height): + return self.tiled_decode(z, return_dict=False)[0] + + decoded = self.decoder(z) + + return decoded + + @apply_forward_hook + def decode(self, z: torch.Tensor, return_dict: bool = True) -> torch.Tensor: + r""" + Decode a batch of images. + + Args: + z (`torch.Tensor`): Input batch of latent vectors. + return_dict (`bool`, defaults to `True`): + Whether to return a [`~models.vae.DecoderOutput`] instead of a plain tuple. + + Returns: + [`~models.vae.DecoderOutput`] or `tuple`: + If return_dict is True, a [`~models.vae.DecoderOutput`] is returned, otherwise a plain `tuple` is + returned. + """ + if self.use_slicing and z.size(0) > 1: + decoded_slices = [self._decode(z_slice).sample for z_slice in z.split(1)] + decoded = torch.cat(decoded_slices) + else: + decoded = self._decode(z) + + if not return_dict: + return (decoded,) + return DecoderOutput(sample=decoded) + + def tiled_encode(self, x: torch.Tensor, return_dict: bool = True) -> torch.Tensor: + raise NotImplementedError("`tiled_encode` has not been implemented for AutoencoderDC.") + + def tiled_decode(self, z: torch.Tensor, return_dict: bool = True) -> Union[DecoderOutput, torch.Tensor]: + raise NotImplementedError("`tiled_decode` has not been implemented for AutoencoderDC.") def forward(self, sample: torch.Tensor, return_dict: bool = True) -> torch.Tensor: z = self.encode(sample) diff --git a/src/diffusers/models/autoencoders/vae.py b/src/diffusers/models/autoencoders/vae.py index 2f3f4f2fc35c..7fc7d5a4d797 100644 --- a/src/diffusers/models/autoencoders/vae.py +++ b/src/diffusers/models/autoencoders/vae.py @@ -30,6 +30,19 @@ ) +@dataclass +class EncoderOutput(BaseOutput): + r""" + Output of encoding method. + + Args: + latent (`torch.Tensor` of shape `(batch_size, num_channels, latent_height, latent_width)`): + The encoded latent. + """ + + latent: torch.Tensor + + @dataclass class DecoderOutput(BaseOutput): r""" From b6e8fbac2969e96a98d2045a1ff14edce57d793b Mon Sep 17 00:00:00 2001 From: yiyixuxu Date: Wed, 4 Dec 2024 23:55:17 +0100 Subject: [PATCH 061/141] combine attention processor --- src/diffusers/models/attention_processor.py | 97 ++++++------------- .../models/autoencoders/autoencoder_dc.py | 2 + 2 files changed, 33 insertions(+), 66 deletions(-) diff --git a/src/diffusers/models/attention_processor.py b/src/diffusers/models/attention_processor.py index 12dd86dfe245..ce08cd8cfcdd 100644 --- a/src/diffusers/models/attention_processor.py +++ b/src/diffusers/models/attention_processor.py @@ -822,19 +822,27 @@ def __init__( self.to_out = nn.Linear(inner_dim * (1 + len(kernel_sizes)), out_channels, bias=False) self.norm_out = get_normalization(norm_type, num_features=out_channels) - self.processor = SanaMultiscaleLinearAttnProcessor2_0() - self.processor_quadratic = SanaMultiscaleQuadraticAttnProcessor2_0() + self.processor = SanaMultiscaleAttnProcessor2_0() - def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: - height, width = hidden_states.shape[-2:] + def apply_linear_attention(self, query: torch.Tensor, key: torch.Tensor, value: torch.Tensor) -> torch.Tensor: + value = F.pad(value, (0, 0, 0, 1), mode="constant", value=1) # Adds padding + scores = torch.matmul(value, key.transpose(-1, -2)) + hidden_states = torch.matmul(scores, query) - if height * width > self.attention_head_dim: - hidden_states = self.processor(self, hidden_states) - else: - hidden_states = self.processor_quadratic(self, hidden_states) + hidden_states = hidden_states.to(dtype=torch.float32) + hidden_states = hidden_states[:, :, :-1] / (hidden_states[:, :, -1:] + self.eps) + return hidden_states + def apply_quadratic_attention(self, query: torch.Tensor, key: torch.Tensor, value: torch.Tensor) -> torch.Tensor: + scores = torch.matmul(key.transpose(-1, -2), query) + scores = scores.to(dtype=torch.float32) + scores = scores / (torch.sum(scores, dim=2, keepdim=True) + self.eps) + hidden_states = torch.matmul(value, scores) return hidden_states + def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: + return self.processor(self, hidden_states) + class AttnProcessor: r""" @@ -5089,65 +5097,18 @@ def __call__( return hidden_states -class SanaMultiscaleLinearAttnProcessor2_0: +class SanaMultiscaleAttnProcessor2_0: r""" - Processor for implementing multiscale linear attention. + Processor for implementing multiscale quadratic attention. """ def __call__(self, attn: SanaMultiscaleLinearAttention, hidden_states: torch.Tensor) -> torch.Tensor: - residual = hidden_states - - batch_size, _, height, width = hidden_states.shape - original_dtype = hidden_states.dtype - - hidden_states = hidden_states.movedim(1, -1) - query = attn.to_q(hidden_states) - key = attn.to_k(hidden_states) - value = attn.to_v(hidden_states) - hidden_states = torch.cat([query, key, value], dim=3) - hidden_states = hidden_states.movedim(-1, 1) - - multiscale_hidden_states = [hidden_states] - for block in attn.to_qkv_multiscale: - multiscale_hidden_states.append(block(hidden_states)) - - hidden_states = torch.cat(multiscale_hidden_states, dim=1) - - hidden_states = hidden_states.to(dtype=torch.float32) - hidden_states = hidden_states.reshape(batch_size, -1, 3 * attn.attention_head_dim, height * width) - - query, key, value = hidden_states.chunk(3, dim=2) - query = attn.nonlinearity(query) - key = attn.nonlinearity(key) - value = F.pad(value, (0, 0, 0, 1), mode="constant", value=1) - - scores = torch.matmul(value, key.transpose(-1, -2)) - hidden_states = torch.matmul(scores, query) - - hidden_states = hidden_states.to(dtype=torch.float32) - hidden_states = hidden_states[:, :, :-1] / (hidden_states[:, :, -1:] + attn.eps) - hidden_states = hidden_states.to(dtype=original_dtype) - - hidden_states = torch.reshape(hidden_states, (batch_size, -1, height, width)) - hidden_states = attn.to_out(hidden_states.movedim(1, -1)).movedim(-1, 1) - - if attn.norm_type == "rms_norm": - hidden_states = attn.norm_out(hidden_states.movedim(1, -1)).movedim(-1, 1) + height, width = hidden_states.shape[-2:] + if height * width > attn.attention_head_dim: + use_linear_attention = True else: - hidden_states = attn.norm_out(hidden_states) + use_linear_attention = False - if attn.residual_connection: - hidden_states = hidden_states + residual - - return hidden_states - - -class SanaMultiscaleQuadraticAttnProcessor2_0: - r""" - Processor for implementing multiscale quadratic attention. - """ - - def __call__(self, attn: SanaMultiscaleLinearAttention, hidden_states: torch.Tensor) -> torch.Tensor: residual = hidden_states batch_size, _, height, width = list(hidden_states.size()) @@ -5166,17 +5127,21 @@ def __call__(self, attn: SanaMultiscaleLinearAttention, hidden_states: torch.Ten hidden_states = torch.cat(multi_scale_qkv, dim=1) + if use_linear_attention: + # for linear attention upcast hidden_states to float32 + hidden_states = hidden_states.to(dtype=torch.float32) + hidden_states = hidden_states.reshape(batch_size, -1, 3 * attn.attention_head_dim, height * width) query, key, value = hidden_states.chunk(3, dim=2) query = attn.nonlinearity(query) key = attn.nonlinearity(key) - scores = torch.matmul(key.transpose(-1, -2), query) - scores = scores.to(dtype=torch.float32) - scores = scores / (torch.sum(scores, dim=2, keepdim=True) + attn.eps) - scores = scores.to(dtype=original_dtype) - hidden_states = torch.matmul(value, scores) + if use_linear_attention: + hidden_states = attn.apply_linear_attention(query, key, value) + hidden_states = hidden_states.to(dtype=original_dtype) + else: + hidden_states = attn.apply_quadratic_attention(query, key, value) hidden_states = torch.reshape(hidden_states, (batch_size, -1, height, width)) hidden_states = attn.to_out(hidden_states.movedim(1, -1)).movedim(-1, 1) diff --git a/src/diffusers/models/autoencoders/autoencoder_dc.py b/src/diffusers/models/autoencoders/autoencoder_dc.py index 2e40cca1b048..80361e12c595 100644 --- a/src/diffusers/models/autoencoders/autoencoder_dc.py +++ b/src/diffusers/models/autoencoders/autoencoder_dc.py @@ -53,6 +53,7 @@ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: hidden_states = hidden_states * self.nonlinearity(gate) hidden_states = self.conv_point(hidden_states) + # move channel to the last dimension so we apply RMSnorm across channel dimension hidden_states = self.norm(hidden_states.movedim(1, -1)).movedim(-1, 1) return hidden_states + residual @@ -82,6 +83,7 @@ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: hidden_states = self.conv2(hidden_states) if self.norm_type == "rms_norm": + # move channel to the last dimension so we apply RMSnorm across channel dimension hidden_states = self.norm(hidden_states.movedim(1, -1)).movedim(-1, 1) else: hidden_states = self.norm(hidden_states) From f862bae81ebc33bb7407537916ae6f9bda4362c6 Mon Sep 17 00:00:00 2001 From: Aryan Date: Thu, 5 Dec 2024 07:51:58 +0100 Subject: [PATCH 062/141] fix tests --- src/diffusers/models/attention_processor.py | 2 +- src/diffusers/models/autoencoders/autoencoder_dc.py | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/diffusers/models/attention_processor.py b/src/diffusers/models/attention_processor.py index ce08cd8cfcdd..54027edcee97 100644 --- a/src/diffusers/models/attention_processor.py +++ b/src/diffusers/models/attention_processor.py @@ -786,8 +786,8 @@ def __init__( in_channels: int, out_channels: int, num_attention_heads: Optional[int] = None, - mult: float = 1.0, attention_head_dim: int = 8, + mult: float = 1.0, norm_type: str = "batch_norm", kernel_sizes: Tuple[int, ...] = (5,), eps: float = 1e-15, diff --git a/src/diffusers/models/autoencoders/autoencoder_dc.py b/src/diffusers/models/autoencoders/autoencoder_dc.py index 80361e12c595..60a7b39b50d0 100644 --- a/src/diffusers/models/autoencoders/autoencoder_dc.py +++ b/src/diffusers/models/autoencoders/autoencoder_dc.py @@ -631,8 +631,8 @@ def tiled_decode(self, z: torch.Tensor, return_dict: bool = True) -> Union[Decod raise NotImplementedError("`tiled_decode` has not been implemented for AutoencoderDC.") def forward(self, sample: torch.Tensor, return_dict: bool = True) -> torch.Tensor: - z = self.encode(sample) - dec = self.decode(z) + z = self.encode(sample, return_dict=False)[0] + decoded = self.decode(z, return_dict=False)[0] if not return_dict: - return (dec,) - return DecoderOutput(sample=dec) + return (decoded,) + return DecoderOutput(sample=decoded) From f9fce24a364e6ea9914dd75d4f19bd5f2ddf9ee2 Mon Sep 17 00:00:00 2001 From: Aryan Date: Thu, 5 Dec 2024 07:52:24 +0100 Subject: [PATCH 063/141] update --- src/diffusers/models/autoencoders/autoencoder_dc.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/diffusers/models/autoencoders/autoencoder_dc.py b/src/diffusers/models/autoencoders/autoencoder_dc.py index 60a7b39b50d0..fa367611a7ce 100644 --- a/src/diffusers/models/autoencoders/autoencoder_dc.py +++ b/src/diffusers/models/autoencoders/autoencoder_dc.py @@ -631,8 +631,8 @@ def tiled_decode(self, z: torch.Tensor, return_dict: bool = True) -> Union[Decod raise NotImplementedError("`tiled_decode` has not been implemented for AutoencoderDC.") def forward(self, sample: torch.Tensor, return_dict: bool = True) -> torch.Tensor: - z = self.encode(sample, return_dict=False)[0] - decoded = self.decode(z, return_dict=False)[0] + encoded = self.encode(sample, return_dict=False)[0] + decoded = self.decode(encoded, return_dict=False)[0] if not return_dict: return (decoded,) return DecoderOutput(sample=decoded) From 3c0b1ca38fd8d8666fc7855deae8760735f3a6a5 Mon Sep 17 00:00:00 2001 From: Junyu Chen Date: Thu, 5 Dec 2024 00:48:50 -0800 Subject: [PATCH 064/141] minor fix --- src/diffusers/models/autoencoders/autoencoder_dc.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/diffusers/models/autoencoders/autoencoder_dc.py b/src/diffusers/models/autoencoders/autoencoder_dc.py index fa367611a7ce..b385a7415294 100644 --- a/src/diffusers/models/autoencoders/autoencoder_dc.py +++ b/src/diffusers/models/autoencoders/autoencoder_dc.py @@ -323,7 +323,6 @@ def __init__( norm_type: Union[str, Tuple[str]] = "rms_norm", act_fn: Union[str, Tuple[str]] = "silu", upsample_block_type: str = "pixel_shuffle", - upsample_shortcut: str = "duplicating", ): super().__init__() @@ -350,7 +349,7 @@ def __init__( block_out_channels[i + 1], out_channel, interpolate=upsample_block_type == "interpolate", - shortcut=upsample_shortcut, + shortcut=True, ) up_block_list.append(upsample_block) From 91057d408a0fbbbc97bfc3d94d36ee9d24acab1b Mon Sep 17 00:00:00 2001 From: Junyu Chen Date: Thu, 5 Dec 2024 01:05:38 -0800 Subject: [PATCH 065/141] minor fix --- src/diffusers/models/autoencoders/autoencoder_dc.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/diffusers/models/autoencoders/autoencoder_dc.py b/src/diffusers/models/autoencoders/autoencoder_dc.py index b385a7415294..e18989d92fcb 100644 --- a/src/diffusers/models/autoencoders/autoencoder_dc.py +++ b/src/diffusers/models/autoencoders/autoencoder_dc.py @@ -565,7 +565,7 @@ def _encode(self, x: torch.Tensor) -> torch.Tensor: return encoded @apply_forward_hook - def encode(self, x: torch.Tensor, return_dict: bool = True) -> torch.Tensor: + def encode(self, x: torch.Tensor, return_dict: bool = True) -> Union[EncoderOutput, Tuple[torch.Tensor]]: r""" Encode a batch of images into latents. From eda66e19e5dccad5264cff8027fd036fc664544f Mon Sep 17 00:00:00 2001 From: Junyu Chen Date: Thu, 5 Dec 2024 02:54:21 -0800 Subject: [PATCH 066/141] minor fix & in/out shortcut rename --- .../models/autoencoders/autoencoder_dc.py | 48 +++++++++++-------- 1 file changed, 27 insertions(+), 21 deletions(-) diff --git a/src/diffusers/models/autoencoders/autoencoder_dc.py b/src/diffusers/models/autoencoders/autoencoder_dc.py index e18989d92fcb..b2f57e1afebb 100644 --- a/src/diffusers/models/autoencoders/autoencoder_dc.py +++ b/src/diffusers/models/autoencoders/autoencoder_dc.py @@ -238,6 +238,7 @@ def __init__( layers_per_block: Tuple[int] = (2, 2, 2, 2, 2, 2), qkv_multiscales: Tuple[Tuple[int, ...], ...] = ((), (), (), (5,), (5,), (5,)), downsample_block_type: str = "pixel_unshuffle", + out_shortcut: bool = True, ): super().__init__() @@ -292,21 +293,23 @@ def __init__( self.down_blocks = nn.ModuleList(down_blocks) self.conv_out = nn.Conv2d(block_out_channels[-1], latent_channels, 3, 1, 1) - self.norm_factor = 1 - norm_in_channels = block_out_channels[-1] - norm_out_channels = latent_channels - self.norm_group_size = norm_in_channels * self.norm_factor**2 // norm_out_channels + + self.out_shortcut = out_shortcut + if out_shortcut: + self.out_shortcut_average_group_size = block_out_channels[-1] // latent_channels def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: hidden_states = self.conv_in(hidden_states) for down_block in self.down_blocks: hidden_states = down_block(hidden_states) - x = F.pixel_unshuffle(hidden_states, self.norm_factor) - x = x.unflatten(1, (-1, self.norm_group_size)) - x = x.mean(dim=2) + if self.out_shortcut: + x = hidden_states.unflatten(1, (-1, self.out_shortcut_average_group_size)) + x = x.mean(dim=2) + hidden_states = self.conv_out(hidden_states) + x + else: + hidden_states = self.conv_out(hidden_states) - hidden_states = self.conv_out(hidden_states) + x return hidden_states @@ -323,6 +326,7 @@ def __init__( norm_type: Union[str, Tuple[str]] = "rms_norm", act_fn: Union[str, Tuple[str]] = "silu", upsample_block_type: str = "pixel_shuffle", + in_shortcut: bool = True, ): super().__init__() @@ -337,8 +341,9 @@ def __init__( self.conv_in = nn.Conv2d(latent_channels, block_out_channels[-1], 3, 1, 1) - self.norm_factor = 1 - self.norm_repeats = block_out_channels[-1] * self.norm_factor**2 // latent_channels + self.in_shortcut = in_shortcut + if in_shortcut: + self.in_shortcut_repeats = block_out_channels[-1] // latent_channels up_blocks = [] for i, (out_channel, num_layers) in reversed(list(enumerate(zip(block_out_channels, layers_per_block)))): @@ -383,10 +388,11 @@ def __init__( ) def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: - x = hidden_states.repeat_interleave(self.norm_repeats, dim=1) - x = F.pixel_shuffle(x, self.norm_factor) - - hidden_states = self.conv_in(hidden_states) + x + if self.in_shortcut: + x = hidden_states.repeat_interleave(self.in_shortcut_repeats, dim=1) + hidden_states = self.conv_in(hidden_states) + x + else: + hidden_states = self.conv_in(hidden_states) for up_block in reversed(self.up_blocks): hidden_states = up_block(hidden_states) @@ -511,7 +517,7 @@ def enable_tiling( tile_sample_stride_width: Optional[float] = None, ) -> None: r""" - Enable tiled VAE decoding. When this option is enabled, the VAE will split the input tensor into tiles to + Enable tiled AE decoding. When this option is enabled, the AE will split the input tensor into tiles to compute decoding and encoding in several steps. This is useful for saving a large amount of memory and to allow processing larger images. @@ -535,21 +541,21 @@ def enable_tiling( def disable_tiling(self) -> None: r""" - Disable tiled VAE decoding. If `enable_tiling` was previously enabled, this method will go back to computing + Disable tiled AE decoding. If `enable_tiling` was previously enabled, this method will go back to computing decoding in one step. """ self.use_tiling = False def enable_slicing(self) -> None: r""" - Enable sliced VAE decoding. When this option is enabled, the VAE will split the input tensor in slices to + Enable sliced AE decoding. When this option is enabled, the AE will split the input tensor in slices to compute decoding in several steps. This is useful to save some memory and allow larger batch sizes. """ self.use_slicing = True def disable_slicing(self) -> None: r""" - Disable sliced VAE decoding. If `enable_slicing` was previously enabled, this method will go back to computing + Disable sliced AE decoding. If `enable_slicing` was previously enabled, this method will go back to computing decoding in one step. """ self.use_slicing = False @@ -572,11 +578,11 @@ def encode(self, x: torch.Tensor, return_dict: bool = True) -> Union[EncoderOutp Args: x (`torch.Tensor`): Input batch of images. return_dict (`bool`, defaults to `True`): - Whether to return a [`~models.autoencoder_kl.AutoencoderKLOutput`] instead of a plain tuple. + Whether to return a [`~models.vae.EncoderOutput`] instead of a plain tuple. Returns: The latent representations of the encoded videos. If `return_dict` is True, a - [`~models.autoencoder_kl.AutoencoderKLOutput`] is returned, otherwise a plain `tuple` is returned. + [`~models.vae.EncoderOutput`] is returned, otherwise a plain `tuple` is returned. """ if self.use_slicing and x.shape[0] > 1: encoded_slices = [self._encode(x_slice) for x_slice in x.split(1)] @@ -599,7 +605,7 @@ def _decode(self, z: torch.Tensor) -> torch.Tensor: return decoded @apply_forward_hook - def decode(self, z: torch.Tensor, return_dict: bool = True) -> torch.Tensor: + def decode(self, z: torch.Tensor, return_dict: bool = True) -> Union[DecoderOutput, Tuple[torch.Tensor]]: r""" Decode a batch of images. From e3d33e6afa971ddfa2adfe3312ccca98bf769897 Mon Sep 17 00:00:00 2001 From: Junyu Chen Date: Thu, 5 Dec 2024 03:16:00 -0800 Subject: [PATCH 067/141] minor fix --- src/diffusers/models/autoencoders/autoencoder_dc.py | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/src/diffusers/models/autoencoders/autoencoder_dc.py b/src/diffusers/models/autoencoders/autoencoder_dc.py index b2f57e1afebb..3ca10e28720e 100644 --- a/src/diffusers/models/autoencoders/autoencoder_dc.py +++ b/src/diffusers/models/autoencoders/autoencoder_dc.py @@ -420,8 +420,10 @@ class AutoencoderDC(ModelMixin, ConfigMixin, FromOriginalModelMixin): The type(s) of block to use in the encoder. decoder_block_types (`Union[str, Tuple[str]]`, defaults to `"ResBlock"`): The type(s) of block to use in the decoder. - block_out_channels (`Tuple[int, ...]`, defaults to `(128, 256, 512, 512, 1024, 1024)`): - The number of output channels for each block in the encoder/decoder. + encoder_block_out_channels (`Tuple[int, ...]`, defaults to `(128, 256, 512, 512, 1024, 1024)`): + The number of output channels for each block in the encoder. + decoder_block_out_channels (`Tuple[int, ...]`, defaults to `(128, 256, 512, 512, 1024, 1024)`): + The number of output channels for each block in the decoder. encoder_layers_per_block (`Tuple[int]`, defaults to `(2, 2, 2, 3, 3, 3)`): The number of layers per block in the encoder. decoder_layers_per_block (`Tuple[int]`, defaults to `(3, 3, 3, 3, 3, 3)`): @@ -439,7 +441,10 @@ class AutoencoderDC(ModelMixin, ConfigMixin, FromOriginalModelMixin): decoder_act_fns (`Union[str, Tuple[str]]`, defaults to `"silu"`): The activation function(s) to use in the decoder. scaling_factor (`float`, defaults to `1.0`): - A scaling factor applied during model operations. + The multiplicative inverse of the root mean square of the latent features. This is used to scale the + latent space to have unit variance when training the diffusion model. The latents are scaled with the + formula `z = z * scaling_factor` before being passed to the diffusion model. When decoding, the latents + are scaled back to the original scale with the formula: `z = 1 / scaling_factor * z`. """ _supports_gradient_checkpointing = False From 2b370df400ed43b6744aa5947e98b9d5fd91d37f Mon Sep 17 00:00:00 2001 From: Aryan Date: Thu, 5 Dec 2024 19:27:49 +0100 Subject: [PATCH 068/141] make style --- .../models/autoencoders/autoencoder_dc.py | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/src/diffusers/models/autoencoders/autoencoder_dc.py b/src/diffusers/models/autoencoders/autoencoder_dc.py index 3ca10e28720e..76a2f0e4fb4d 100644 --- a/src/diffusers/models/autoencoders/autoencoder_dc.py +++ b/src/diffusers/models/autoencoders/autoencoder_dc.py @@ -441,10 +441,10 @@ class AutoencoderDC(ModelMixin, ConfigMixin, FromOriginalModelMixin): decoder_act_fns (`Union[str, Tuple[str]]`, defaults to `"silu"`): The activation function(s) to use in the decoder. scaling_factor (`float`, defaults to `1.0`): - The multiplicative inverse of the root mean square of the latent features. This is used to scale the - latent space to have unit variance when training the diffusion model. The latents are scaled with the - formula `z = z * scaling_factor` before being passed to the diffusion model. When decoding, the latents - are scaled back to the original scale with the formula: `z = 1 / scaling_factor * z`. + The multiplicative inverse of the root mean square of the latent features. This is used to scale the latent + space to have unit variance when training the diffusion model. The latents are scaled with the formula `z = + z * scaling_factor` before being passed to the diffusion model. When decoding, the latents are scaled back + to the original scale with the formula: `z = 1 / scaling_factor * z`. """ _supports_gradient_checkpointing = False @@ -522,8 +522,8 @@ def enable_tiling( tile_sample_stride_width: Optional[float] = None, ) -> None: r""" - Enable tiled AE decoding. When this option is enabled, the AE will split the input tensor into tiles to - compute decoding and encoding in several steps. This is useful for saving a large amount of memory and to allow + Enable tiled AE decoding. When this option is enabled, the AE will split the input tensor into tiles to compute + decoding and encoding in several steps. This is useful for saving a large amount of memory and to allow processing larger images. Args: @@ -553,8 +553,8 @@ def disable_tiling(self) -> None: def enable_slicing(self) -> None: r""" - Enable sliced AE decoding. When this option is enabled, the AE will split the input tensor in slices to - compute decoding in several steps. This is useful to save some memory and allow larger batch sizes. + Enable sliced AE decoding. When this option is enabled, the AE will split the input tensor in slices to compute + decoding in several steps. This is useful to save some memory and allow larger batch sizes. """ self.use_slicing = True From 94355abe64b76846d5f592963f2413758d6d5d81 Mon Sep 17 00:00:00 2001 From: Junyu Chen Date: Thu, 5 Dec 2024 23:05:33 -0800 Subject: [PATCH 069/141] fix paper link --- docs/source/en/api/models/autoencoder_dc.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/en/api/models/autoencoder_dc.md b/docs/source/en/api/models/autoencoder_dc.md index 8a084a9b2172..7522b3e6a93c 100644 --- a/docs/source/en/api/models/autoencoder_dc.md +++ b/docs/source/en/api/models/autoencoder_dc.md @@ -11,7 +11,7 @@ specific language governing permissions and limitations under the License. --> # AutoencoderDC -*The 2D Autoencoder model used in [SANA](https://arxiv.org/papers/2410.10629) and introduced in [DCAE](https://huggingface.co/papers/2410.10733) by authors Junyu Chen, Han Cai, Junsong Chen, Enze Xie, Shang Yang, Haotian Tang, Muyang Li, Yao Lu, Song Han from MIT HAN Lab.* +*The 2D Autoencoder model used in [SANA](https://huggingface.co/papers/2410.10629) and introduced in [DCAE](https://huggingface.co/papers/2410.10733) by authors Junyu Chen\*, Han Cai\*, Junsong Chen, Enze Xie, Shang Yang, Haotian Tang, Muyang Li, Yao Lu, Song Han from MIT HAN Lab.* The following DCAE models are released and supported in Diffusers: - [`mit-han-lab/dc-ae-f32c32-sana-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f32c32-sana-1.0) From 116c0495bd072005867bdeb43b14f040e21f224b Mon Sep 17 00:00:00 2001 From: Aryan Date: Fri, 6 Dec 2024 09:45:44 +0100 Subject: [PATCH 070/141] update docs --- docs/source/en/api/models/autoencoder_dc.md | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/docs/source/en/api/models/autoencoder_dc.md b/docs/source/en/api/models/autoencoder_dc.md index 7522b3e6a93c..6fe9f048b5a4 100644 --- a/docs/source/en/api/models/autoencoder_dc.md +++ b/docs/source/en/api/models/autoencoder_dc.md @@ -14,13 +14,16 @@ specific language governing permissions and limitations under the License. --> *The 2D Autoencoder model used in [SANA](https://huggingface.co/papers/2410.10629) and introduced in [DCAE](https://huggingface.co/papers/2410.10733) by authors Junyu Chen\*, Han Cai\*, Junsong Chen, Enze Xie, Shang Yang, Haotian Tang, Muyang Li, Yao Lu, Song Han from MIT HAN Lab.* The following DCAE models are released and supported in Diffusers: -- [`mit-han-lab/dc-ae-f32c32-sana-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f32c32-sana-1.0) -- [`mit-han-lab/dc-ae-f32c32-in-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f32c32-in-1.0) -- [`mit-han-lab/dc-ae-f32c32-mix-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f32c32-mix-1.0) -- [`mit-han-lab/dc-ae-f64c128-in-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f64c128-in-1.0) -- [`mit-han-lab/dc-ae-f64c128-mix-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f64c128-mix-1.0) -- [`mit-han-lab/dc-ae-f128c512-in-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f128c512-in-1.0) -- [`mit-han-lab/dc-ae-f128c512-mix-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f128c512-mix-1.0) + +| diffusers format | original format | +|:----------------:|:---------------:| +| [`mit-han-lab/dc-ae-f32c32-sana-1.0-diffusers`](https://huggingface.co/mit-han-lab/dc-ae-f32c32-sana-1.0-diffusers) | [`mit-han-lab/dc-ae-f32c32-sana-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f32c32-sana-1.0) +| [`mit-han-lab/dc-ae-f32c32-in-1.0-diffusers`](https://huggingface.co/mit-han-lab/dc-ae-f32c32-in-1.0-diffusers) | [`mit-han-lab/dc-ae-f32c32-in-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f32c32-in-1.0) +| [`mit-han-lab/dc-ae-f32c32-mix-1.0-diffusers`](https://huggingface.co/mit-han-lab/dc-ae-f32c32-mix-1.0-diffusers) | [`mit-han-lab/dc-ae-f32c32-mix-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f32c32-mix-1.0) +| [`mit-han-lab/dc-ae-f64c128-in-1.0-diffusers`](https://huggingface.co/mit-han-lab/dc-ae-f64c128-in-1.0-diffusers) | [`mit-han-lab/dc-ae-f64c128-in-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f64c128-in-1.0) +| [`mit-han-lab/dc-ae-f64c128-mix-1.0-diffusers`](https://huggingface.co/mit-han-lab/dc-ae-f64c128-mix-1.0-diffusers) | [`mit-han-lab/dc-ae-f64c128-mix-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f64c128-mix-1.0) +| [`mit-han-lab/dc-ae-f128c512-in-1.0-diffusers`](https://huggingface.co/mit-han-lab/dc-ae-f128c512-in-1.0-diffusers) | [`mit-han-lab/dc-ae-f128c512-in-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f128c512-in-1.0) +| [`mit-han-lab/dc-ae-f128c512-mix-1.0-diffusers`](https://huggingface.co/mit-han-lab/dc-ae-f128c512-mix-1.0-diffusers) | [`mit-han-lab/dc-ae-f128c512-mix-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f128c512-mix-1.0) The models can be loaded with the following code snippet. From b6e0aba6d0cf1fe4052198c814ef3dcf204ede21 Mon Sep 17 00:00:00 2001 From: Aryan Date: Fri, 6 Dec 2024 14:26:17 +0100 Subject: [PATCH 071/141] update single file loading --- docs/source/en/api/models/autoencoder_dc.md | 2 +- src/diffusers/loaders/single_file_model.py | 2 - src/diffusers/loaders/single_file_utils.py | 192 ++------------------ 3 files changed, 16 insertions(+), 180 deletions(-) diff --git a/docs/source/en/api/models/autoencoder_dc.md b/docs/source/en/api/models/autoencoder_dc.md index 6fe9f048b5a4..e7eb3382f817 100644 --- a/docs/source/en/api/models/autoencoder_dc.md +++ b/docs/source/en/api/models/autoencoder_dc.md @@ -43,7 +43,7 @@ from diffusers import AutoencoderDC model_name = "dc-ae-f128c512-mix-1.0" ae = AutoencoderDC.from_single_file( f"https://huggingface.co/mit-han-lab/{model_name}/model.safetensors", - original_config=f"https://huggingface.co/mit-han-lab/{model_name}/resolve/main/config.json" + config=f"mit-han-lab/{model_name}-diffusers", ) ``` diff --git a/src/diffusers/loaders/single_file_model.py b/src/diffusers/loaders/single_file_model.py index 403cf280635c..3b27323c20cb 100644 --- a/src/diffusers/loaders/single_file_model.py +++ b/src/diffusers/loaders/single_file_model.py @@ -30,7 +30,6 @@ convert_ldm_vae_checkpoint, convert_sd3_transformer_checkpoint_to_diffusers, convert_stable_cascade_unet_single_file_to_diffusers, - create_autoencoder_dc_config_from_original, create_controlnet_diffusers_config_from_ldm, create_unet_diffusers_config_from_ldm, create_vae_diffusers_config_from_ldm, @@ -86,7 +85,6 @@ }, "AutoencoderDC": { "checkpoint_mapping_fn": convert_autoencoder_dc_checkpoint_to_diffusers, - "config_mapping_fn": create_autoencoder_dc_config_from_original, }, } diff --git a/src/diffusers/loaders/single_file_utils.py b/src/diffusers/loaders/single_file_utils.py index 682adef10915..0aec7ab559ef 100644 --- a/src/diffusers/loaders/single_file_utils.py +++ b/src/diffusers/loaders/single_file_utils.py @@ -570,6 +570,10 @@ def infer_diffusers_model_type(checkpoint): model_type = "flux-dev" else: model_type = "flux-schnell" + + elif any(key in checkpoint for key in CHECKPOINT_KEY_NAMES["autoencoder_dc"]): + model_type = "autoencoder_dc" + else: model_type = "v1" @@ -2206,168 +2210,8 @@ def swap_scale_shift(weight): return converted_state_dict -def create_autoencoder_dc_config_from_original(original_config, checkpoint, **kwargs): - model_name = original_config.get("model_name", "dc-ae-f32c32-sana-1.0") - - if model_name in ["dc-ae-f32c32-sana-1.0"]: - config = { - "latent_channels": 32, - "encoder_block_types": ( - "ResBlock", - "ResBlock", - "ResBlock", - "EfficientViTBlock", - "EfficientViTBlock", - "EfficientViTBlock", - ), - "decoder_block_types": ( - "ResBlock", - "ResBlock", - "ResBlock", - "EfficientViTBlock", - "EfficientViTBlock", - "EfficientViTBlock", - ), - "encoder_block_out_channels": (128, 256, 512, 512, 1024, 1024), - "decoder_block_out_channels": (128, 256, 512, 512, 1024, 1024), - "encoder_qkv_multiscales": ((), (), (), (5,), (5,), (5,)), - "decoder_qkv_multiscales": ((), (), (), (5,), (5,), (5,)), - "encoder_layers_per_block": (2, 2, 2, 3, 3, 3), - "decoder_layers_per_block": [3, 3, 3, 3, 3, 3], - "downsample_block_type": "conv", - "upsample_block_type": "interpolate", - "decoder_norm_types": "rms_norm", - "decoder_act_fns": "silu", - "scaling_factor": 0.41407, - } - elif model_name in ["dc-ae-f32c32-in-1.0", "dc-ae-f32c32-mix-1.0"]: - config = { - "latent_channels": 32, - "encoder_block_types": [ - "ResBlock", - "ResBlock", - "ResBlock", - "EfficientViTBlock", - "EfficientViTBlock", - "EfficientViTBlock", - ], - "decoder_block_types": [ - "ResBlock", - "ResBlock", - "ResBlock", - "EfficientViTBlock", - "EfficientViTBlock", - "EfficientViTBlock", - ], - "encoder_block_out_channels": [128, 256, 512, 512, 1024, 1024], - "decoder_block_out_channels": [128, 256, 512, 512, 1024, 1024], - "encoder_layers_per_block": [0, 4, 8, 2, 2, 2], - "decoder_layers_per_block": [0, 5, 10, 2, 2, 2], - "encoder_qkv_multiscales": ((), (), (), (), (), ()), - "decoder_qkv_multiscales": ((), (), (), (), (), ()), - "decoder_norm_types": ["batch_norm", "batch_norm", "batch_norm", "rms_norm", "rms_norm", "rms_norm"], - "decoder_act_fns": ["relu", "relu", "relu", "silu", "silu", "silu"], - } - if model_name == "dc-ae-f32c32-in-1.0": - config["scaling_factor"] = 0.3189 - elif model_name == "dc-ae-f32c32-mix-1.0": - config["scaling_factor"] = 0.4552 - elif model_name in ["dc-ae-f64c128-in-1.0", "dc-ae-f64c128-mix-1.0"]: - config = { - "latent_channels": 128, - "encoder_block_types": [ - "ResBlock", - "ResBlock", - "ResBlock", - "EfficientViTBlock", - "EfficientViTBlock", - "EfficientViTBlock", - "EfficientViTBlock", - ], - "decoder_block_types": [ - "ResBlock", - "ResBlock", - "ResBlock", - "EfficientViTBlock", - "EfficientViTBlock", - "EfficientViTBlock", - "EfficientViTBlock", - ], - "encoder_block_out_channels": [128, 256, 512, 512, 1024, 1024, 2048], - "decoder_block_out_channels": [128, 256, 512, 512, 1024, 1024, 2048], - "encoder_layers_per_block": [0, 4, 8, 2, 2, 2, 2], - "decoder_layers_per_block": [0, 5, 10, 2, 2, 2, 2], - "encoder_qkv_multiscales": ((), (), (), (), (), (), ()), - "decoder_qkv_multiscales": ((), (), (), (), (), (), ()), - "decoder_norm_types": [ - "batch_norm", - "batch_norm", - "batch_norm", - "rms_norm", - "rms_norm", - "rms_norm", - "rms_norm", - ], - "decoder_act_fns": ["relu", "relu", "relu", "silu", "silu", "silu", "silu"], - } - if model_name == "dc-ae-f64c128-in-1.0": - config["scaling_factor"] = 0.2889 - elif model_name == "dc-ae-f64c128-mix-1.0": - config["scaling_factor"] = 0.4538 - elif model_name in ["dc-ae-f128c512-in-1.0", "dc-ae-f128c512-mix-1.0"]: - config = { - "latent_channels": 512, - "encoder_block_types": [ - "ResBlock", - "ResBlock", - "ResBlock", - "EfficientViTBlock", - "EfficientViTBlock", - "EfficientViTBlock", - "EfficientViTBlock", - "EfficientViTBlock", - ], - "decoder_block_types": [ - "ResBlock", - "ResBlock", - "ResBlock", - "EfficientViTBlock", - "EfficientViTBlock", - "EfficientViTBlock", - "EfficientViTBlock", - "EfficientViTBlock", - ], - "encoder_block_out_channels": [128, 256, 512, 512, 1024, 1024, 2048, 2048], - "decoder_block_out_channels": [128, 256, 512, 512, 1024, 1024, 2048, 2048], - "encoder_layers_per_block": [0, 4, 8, 2, 2, 2, 2, 2], - "decoder_layers_per_block": [0, 5, 10, 2, 2, 2, 2, 2], - "encoder_qkv_multiscales": ((), (), (), (), (), (), (), ()), - "decoder_qkv_multiscales": ((), (), (), (), (), (), (), ()), - "decoder_norm_types": [ - "batch_norm", - "batch_norm", - "batch_norm", - "rms_norm", - "rms_norm", - "rms_norm", - "rms_norm", - "rms_norm", - ], - "decoder_act_fns": ["relu", "relu", "relu", "silu", "silu", "silu", "silu", "silu"], - } - if model_name == "dc-ae-f128c512-in-1.0": - config["scaling_factor"] = 0.4883 - elif model_name == "dc-ae-f128c512-mix-1.0": - config["scaling_factor"] = 0.3620 - - config.update({"model_name": model_name}) - - return config - - def convert_autoencoder_dc_checkpoint_to_diffusers(config, checkpoint, **kwargs): converted_state_dict = {key: checkpoint.pop(key) for key in list(checkpoint.keys())} - model_name = config.pop("model_name") def remap_qkv_(key: str, state_dict): qkv = state_dict.pop(key) @@ -2411,17 +2255,7 @@ def remap_proj_conv_(key: str, state_dict): "decoder.stages": "decoder.up_blocks", } - AE_F32C32_KEYS = { - "encoder.project_in.conv": "encoder.conv_in.conv", - "decoder.project_out.2.conv": "decoder.conv_out.conv", - } - - AE_F64C128_KEYS = { - "encoder.project_in.conv": "encoder.conv_in.conv", - "decoder.project_out.2.conv": "decoder.conv_out.conv", - } - - AE_F128C512_KEYS = { + AE_F32C32_F64C128_F128C512_KEYS = { "encoder.project_in.conv": "encoder.conv_in.conv", "decoder.project_out.2.conv": "decoder.conv_out.conv", } @@ -2431,12 +2265,16 @@ def remap_proj_conv_(key: str, state_dict): "proj.conv.weight": remap_proj_conv_, } - if "f32c32" in model_name and "sana" not in model_name: - AE_KEYS_RENAME_DICT.update(AE_F32C32_KEYS) - elif "f64c128" in model_name: - AE_KEYS_RENAME_DICT.update(AE_F64C128_KEYS) - elif "f128c512" in model_name: - AE_KEYS_RENAME_DICT.update(AE_F128C512_KEYS) + if ( + ( + config["latent_channels"] == 32 + and config["upsample_block_type"] == "pixel_shuffle" + and config["downsample_block_type"] == "pixel_unshuffle" + ) + or config["latent_channels"] == 128 + or config["latent_channels"] == 512 + ): + AE_KEYS_RENAME_DICT.update(AE_F32C32_F64C128_F128C512_KEYS) for key in list(converted_state_dict.keys()): new_key = key[:] From dbae8f1d6b2b25a0590a467496a91bc9955e04eb Mon Sep 17 00:00:00 2001 From: Aryan Date: Fri, 6 Dec 2024 14:40:02 +0100 Subject: [PATCH 072/141] make style --- src/diffusers/models/attention.py | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/src/diffusers/models/attention.py b/src/diffusers/models/attention.py index bef5dc73a96f..02ed1f965abf 100644 --- a/src/diffusers/models/attention.py +++ b/src/diffusers/models/attention.py @@ -22,13 +22,7 @@ from .activations import GEGLU, GELU, ApproximateGELU, FP32SiLU, SwiGLU from .attention_processor import Attention, JointAttnProcessor2_0 from .embeddings import SinusoidalPositionalEmbedding -from .normalization import ( - AdaLayerNorm, - AdaLayerNormContinuous, - AdaLayerNormZero, - RMSNorm, - SD35AdaLayerNormZeroX, -) +from .normalization import AdaLayerNorm, AdaLayerNormContinuous, AdaLayerNormZero, RMSNorm, SD35AdaLayerNormZeroX logger = logging.get_logger(__name__) From 042c2a0cac3fc077e6559f62fb9236a67a8c8bc6 Mon Sep 17 00:00:00 2001 From: Aryan Date: Fri, 6 Dec 2024 19:58:17 +0100 Subject: [PATCH 073/141] remove single file loading support; todo for DN6 --- docs/source/en/api/models/autoencoder_dc.md | 14 ---- src/diffusers/loaders/single_file_model.py | 6 +- src/diffusers/loaders/single_file_utils.py | 93 +-------------------- 3 files changed, 2 insertions(+), 111 deletions(-) diff --git a/docs/source/en/api/models/autoencoder_dc.md b/docs/source/en/api/models/autoencoder_dc.md index e7eb3382f817..64e90df57307 100644 --- a/docs/source/en/api/models/autoencoder_dc.md +++ b/docs/source/en/api/models/autoencoder_dc.md @@ -33,20 +33,6 @@ from diffusers import AutoencoderDC ae = AutoencoderDC.from_pretrained("mit-han-lab/dc-ae-f32c32-sana-1.0-diffusers", torch_dtype=torch.float32).to("cuda") ``` -## Single file loading - -The `AutoencoderDC` implementation supports loading checkpoints shipped in the original format by MIT HAN Lab. The following example demonstrates how to load the `f128c512` checkpoint: - -```python -from diffusers import AutoencoderDC - -model_name = "dc-ae-f128c512-mix-1.0" -ae = AutoencoderDC.from_single_file( - f"https://huggingface.co/mit-han-lab/{model_name}/model.safetensors", - config=f"mit-han-lab/{model_name}-diffusers", -) -``` - ## AutoencoderDC [[autodoc]] AutoencoderDC diff --git a/src/diffusers/loaders/single_file_model.py b/src/diffusers/loaders/single_file_model.py index 3b27323c20cb..be3139057078 100644 --- a/src/diffusers/loaders/single_file_model.py +++ b/src/diffusers/loaders/single_file_model.py @@ -23,7 +23,6 @@ from .single_file_utils import ( SingleFileComponentError, convert_animatediff_checkpoint_to_diffusers, - convert_autoencoder_dc_checkpoint_to_diffusers, convert_controlnet_checkpoint, convert_flux_transformer_checkpoint_to_diffusers, convert_ldm_unet_checkpoint, @@ -83,9 +82,6 @@ "checkpoint_mapping_fn": convert_flux_transformer_checkpoint_to_diffusers, "default_subfolder": "transformer", }, - "AutoencoderDC": { - "checkpoint_mapping_fn": convert_autoencoder_dc_checkpoint_to_diffusers, - }, } @@ -232,7 +228,7 @@ def from_single_file(cls, pretrained_model_link_or_path_or_dict: Optional[str] = if config_mapping_fn is None: raise ValueError( ( - f"`original_config` has been provided for {mapping_class_name} but no mapping function " + f"`original_config` has been provided for {mapping_class_name} but no mapping function" "was found to convert the original config to a Diffusers config in" "`diffusers.loaders.single_file_utils`" ) diff --git a/src/diffusers/loaders/single_file_utils.py b/src/diffusers/loaders/single_file_utils.py index 0aec7ab559ef..10742873ded1 100644 --- a/src/diffusers/loaders/single_file_utils.py +++ b/src/diffusers/loaders/single_file_utils.py @@ -12,12 +12,7 @@ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. - -""" -Conversion scripts for the various modeling checkpoints. These scripts convert original model implementations to -Diffusers adapted versions. This usually only involves renaming/remapping the state dict keys and changing some -modeling components partially (for example, splitting a single QKV linear to individual Q, K, V layers). -""" +"""Conversion script for the Stable Diffusion checkpoints.""" import copy import os @@ -97,7 +92,6 @@ "double_blocks.0.img_attn.norm.key_norm.scale", "model.diffusion_model.double_blocks.0.img_attn.norm.key_norm.scale", ], - "autoencoder_dc": "decoder.stages.0.op_list.0.main.conv.conv.weight", } DIFFUSERS_DEFAULT_PIPELINE_PATHS = { @@ -570,10 +564,6 @@ def infer_diffusers_model_type(checkpoint): model_type = "flux-dev" else: model_type = "flux-schnell" - - elif any(key in checkpoint for key in CHECKPOINT_KEY_NAMES["autoencoder_dc"]): - model_type = "autoencoder_dc" - else: model_type = "v1" @@ -2208,84 +2198,3 @@ def swap_scale_shift(weight): ) return converted_state_dict - - -def convert_autoencoder_dc_checkpoint_to_diffusers(config, checkpoint, **kwargs): - converted_state_dict = {key: checkpoint.pop(key) for key in list(checkpoint.keys())} - - def remap_qkv_(key: str, state_dict): - qkv = state_dict.pop(key) - q, k, v = torch.chunk(qkv, 3, dim=0) - parent_module, _, _ = key.rpartition(".qkv.conv.weight") - state_dict[f"{parent_module}.to_q.weight"] = q.squeeze() - state_dict[f"{parent_module}.to_k.weight"] = k.squeeze() - state_dict[f"{parent_module}.to_v.weight"] = v.squeeze() - - def remap_proj_conv_(key: str, state_dict): - parent_module, _, _ = key.rpartition(".proj.conv.weight") - state_dict[f"{parent_module}.to_out.weight"] = state_dict.pop(key).squeeze() - - AE_KEYS_RENAME_DICT = { - # common - "main.": "", - "op_list.": "", - "context_module": "attn", - "local_module": "conv_out", - # NOTE: The below two lines work because scales in the available configs only have a tuple length of 1 - # If there were more scales, there would be more layers, so a loop would be better to handle this - "aggreg.0.0": "to_qkv_multiscale.0.proj_in", - "aggreg.0.1": "to_qkv_multiscale.0.proj_out", - "depth_conv.conv": "conv_depth", - "inverted_conv.conv": "conv_inverted", - "point_conv.conv": "conv_point", - "point_conv.norm": "norm", - "conv.conv.": "conv.", - "conv1.conv": "conv1", - "conv2.conv": "conv2", - "conv2.norm": "norm", - "proj.norm": "norm_out", - # encoder - "encoder.project_in.conv": "encoder.conv_in", - "encoder.project_out.0.conv": "encoder.conv_out", - "encoder.stages": "encoder.down_blocks", - # decoder - "decoder.project_in.conv": "decoder.conv_in", - "decoder.project_out.0": "decoder.norm_out", - "decoder.project_out.2.conv": "decoder.conv_out", - "decoder.stages": "decoder.up_blocks", - } - - AE_F32C32_F64C128_F128C512_KEYS = { - "encoder.project_in.conv": "encoder.conv_in.conv", - "decoder.project_out.2.conv": "decoder.conv_out.conv", - } - - AE_SPECIAL_KEYS_REMAP = { - "qkv.conv.weight": remap_qkv_, - "proj.conv.weight": remap_proj_conv_, - } - - if ( - ( - config["latent_channels"] == 32 - and config["upsample_block_type"] == "pixel_shuffle" - and config["downsample_block_type"] == "pixel_unshuffle" - ) - or config["latent_channels"] == 128 - or config["latent_channels"] == 512 - ): - AE_KEYS_RENAME_DICT.update(AE_F32C32_F64C128_F128C512_KEYS) - - for key in list(converted_state_dict.keys()): - new_key = key[:] - for replace_key, rename_key in AE_KEYS_RENAME_DICT.items(): - new_key = new_key.replace(replace_key, rename_key) - converted_state_dict[new_key] = converted_state_dict.pop(key) - - for key in list(converted_state_dict.keys()): - for special_key, handler_fn_inplace in AE_SPECIAL_KEYS_REMAP.items(): - if special_key not in key: - continue - handler_fn_inplace(key, converted_state_dict) - - return converted_state_dict From f2525b94407dfe472052d3d89c5818c8cdb466a8 Mon Sep 17 00:00:00 2001 From: Aryan Date: Sat, 7 Dec 2024 00:29:36 +0530 Subject: [PATCH 074/141] Apply suggestions from code review Co-authored-by: Steven Liu <59462357+stevhliu@users.noreply.github.com> --- docs/source/en/api/models/autoencoder_dc.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/source/en/api/models/autoencoder_dc.md b/docs/source/en/api/models/autoencoder_dc.md index 64e90df57307..056c5f3c9c84 100644 --- a/docs/source/en/api/models/autoencoder_dc.md +++ b/docs/source/en/api/models/autoencoder_dc.md @@ -13,9 +13,9 @@ specific language governing permissions and limitations under the License. --> *The 2D Autoencoder model used in [SANA](https://huggingface.co/papers/2410.10629) and introduced in [DCAE](https://huggingface.co/papers/2410.10733) by authors Junyu Chen\*, Han Cai\*, Junsong Chen, Enze Xie, Shang Yang, Haotian Tang, Muyang Li, Yao Lu, Song Han from MIT HAN Lab.* -The following DCAE models are released and supported in Diffusers: +The following DCAE models are released and supported in Diffusers. -| diffusers format | original format | +| Diffusers format | Original format | |:----------------:|:---------------:| | [`mit-han-lab/dc-ae-f32c32-sana-1.0-diffusers`](https://huggingface.co/mit-han-lab/dc-ae-f32c32-sana-1.0-diffusers) | [`mit-han-lab/dc-ae-f32c32-sana-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f32c32-sana-1.0) | [`mit-han-lab/dc-ae-f32c32-in-1.0-diffusers`](https://huggingface.co/mit-han-lab/dc-ae-f32c32-in-1.0-diffusers) | [`mit-han-lab/dc-ae-f32c32-in-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f32c32-in-1.0) @@ -25,7 +25,7 @@ The following DCAE models are released and supported in Diffusers: | [`mit-han-lab/dc-ae-f128c512-in-1.0-diffusers`](https://huggingface.co/mit-han-lab/dc-ae-f128c512-in-1.0-diffusers) | [`mit-han-lab/dc-ae-f128c512-in-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f128c512-in-1.0) | [`mit-han-lab/dc-ae-f128c512-mix-1.0-diffusers`](https://huggingface.co/mit-han-lab/dc-ae-f128c512-mix-1.0-diffusers) | [`mit-han-lab/dc-ae-f128c512-mix-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f128c512-mix-1.0) -The models can be loaded with the following code snippet. +Load a model in Diffusers format with [`~ModelMixin.from_pretrained`], and load a model in the original checkpoint format with [`~FromOriginalModelMixin.from_pretrained`]. ```python from diffusers import AutoencoderDC From 6122b84a367134a893e156dcb3574c50b85a2d95 Mon Sep 17 00:00:00 2001 From: Aryan Date: Fri, 6 Dec 2024 20:03:51 +0100 Subject: [PATCH 075/141] add abstract --- docs/source/en/api/models/autoencoder_dc.md | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/docs/source/en/api/models/autoencoder_dc.md b/docs/source/en/api/models/autoencoder_dc.md index 056c5f3c9c84..f9931e099254 100644 --- a/docs/source/en/api/models/autoencoder_dc.md +++ b/docs/source/en/api/models/autoencoder_dc.md @@ -11,7 +11,11 @@ specific language governing permissions and limitations under the License. --> # AutoencoderDC -*The 2D Autoencoder model used in [SANA](https://huggingface.co/papers/2410.10629) and introduced in [DCAE](https://huggingface.co/papers/2410.10733) by authors Junyu Chen\*, Han Cai\*, Junsong Chen, Enze Xie, Shang Yang, Haotian Tang, Muyang Li, Yao Lu, Song Han from MIT HAN Lab.* +The 2D Autoencoder model used in [SANA](https://huggingface.co/papers/2410.10629) and introduced in [DCAE](https://huggingface.co/papers/2410.10733) by authors Junyu Chen\*, Han Cai\*, Junsong Chen, Enze Xie, Shang Yang, Haotian Tang, Muyang Li, Yao Lu, Song Han from MIT HAN Lab. + +The abstract from the paper is: + +*We present Deep Compression Autoencoder (DC-AE), a new family of autoencoder models for accelerating high-resolution diffusion models. Existing autoencoder models have demonstrated impressive results at a moderate spatial compression ratio (e.g., 8x), but fail to maintain satisfactory reconstruction accuracy for high spatial compression ratios (e.g., 64x). We address this challenge by introducing two key techniques: (1) Residual Autoencoding, where we design our models to learn residuals based on the space-to-channel transformed features to alleviate the optimization difficulty of high spatial-compression autoencoders; (2) Decoupled High-Resolution Adaptation, an efficient decoupled three-phases training strategy for mitigating the generalization penalty of high spatial-compression autoencoders. With these designs, we improve the autoencoder's spatial compression ratio up to 128 while maintaining the reconstruction quality. Applying our DC-AE to latent diffusion models, we achieve significant speedup without accuracy drop. For example, on ImageNet 512x512, our DC-AE provides 19.1x inference speedup and 17.9x training speedup on H100 GPU for UViT-H while achieving a better FID, compared with the widely used SD-VAE-f8 autoencoder. Our code is available at [this https URL](https://github.com/mit-han-lab/efficientvit).* The following DCAE models are released and supported in Diffusers. @@ -25,7 +29,7 @@ The following DCAE models are released and supported in Diffusers. | [`mit-han-lab/dc-ae-f128c512-in-1.0-diffusers`](https://huggingface.co/mit-han-lab/dc-ae-f128c512-in-1.0-diffusers) | [`mit-han-lab/dc-ae-f128c512-in-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f128c512-in-1.0) | [`mit-han-lab/dc-ae-f128c512-mix-1.0-diffusers`](https://huggingface.co/mit-han-lab/dc-ae-f128c512-mix-1.0-diffusers) | [`mit-han-lab/dc-ae-f128c512-mix-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f128c512-mix-1.0) -Load a model in Diffusers format with [`~ModelMixin.from_pretrained`], and load a model in the original checkpoint format with [`~FromOriginalModelMixin.from_pretrained`]. +Load a model in Diffusers format with [`~ModelMixin.from_pretrained`]. ```python from diffusers import AutoencoderDC @@ -36,8 +40,9 @@ ae = AutoencoderDC.from_pretrained("mit-han-lab/dc-ae-f32c32-sana-1.0-diffusers" ## AutoencoderDC [[autodoc]] AutoencoderDC - - decode - - all + - encode + - decode + - all ## DecoderOutput From 5f5a1709a5321db06f3f54daf8ef2c1d9b1a4c58 Mon Sep 17 00:00:00 2001 From: junsong Date: Tue, 5 Nov 2024 01:08:47 -0800 Subject: [PATCH 076/141] 1. add DCAE into diffusers; 2. make style and make quality; --- sana.py | 14 ++++++++++++++ src/diffusers/__init__.py | 3 +++ src/diffusers/models/autoencoders/__init__.py | 1 + 3 files changed, 18 insertions(+) create mode 100644 sana.py diff --git a/sana.py b/sana.py new file mode 100644 index 000000000000..830e9443597a --- /dev/null +++ b/sana.py @@ -0,0 +1,14 @@ +from diffusers import DCAE, DCAE_HF +from diffsuers import SanaPipeline + + +# vae = DCAE() +dc_ae = DCAE_HF.from_pretrained(f"mit-han-lab/dc-ae-f32c32-sana-1.0") +print(dc_ae) + +# pipe = Sana() + + + + + diff --git a/src/diffusers/__init__.py b/src/diffusers/__init__.py index 913672992a8c..5323eb91f9c5 100644 --- a/src/diffusers/__init__.py +++ b/src/diffusers/__init__.py @@ -129,6 +129,7 @@ "UNetSpatioTemporalConditionModel", "UVit2DModel", "VQModel", + "DCAE", ] ) _import_structure["optimization"] = [ @@ -570,6 +571,8 @@ from .utils.dummy_pt_objects import * # noqa F403 else: from .models import ( + DCAE, + DCAE_HF, AllegroTransformer3DModel, AsymmetricAutoencoderKL, AuraFlowTransformer2DModel, diff --git a/src/diffusers/models/autoencoders/__init__.py b/src/diffusers/models/autoencoders/__init__.py index 7a36e88f1a36..4dc514b478e9 100644 --- a/src/diffusers/models/autoencoders/__init__.py +++ b/src/diffusers/models/autoencoders/__init__.py @@ -8,4 +8,5 @@ from .autoencoder_oobleck import AutoencoderOobleck from .autoencoder_tiny import AutoencoderTiny from .consistency_decoder_vae import ConsistencyDecoderVAE +from .dc_ae import DCAE, DCAE_HF from .vq_model import VQModel From b33da4de3b54ca5bc95d306a90b23bd8f6e1e39d Mon Sep 17 00:00:00 2001 From: junsong Date: Tue, 5 Nov 2024 01:10:38 -0800 Subject: [PATCH 077/141] add DCAE_HF into diffusers; --- src/diffusers/__init__.py | 1 + 1 file changed, 1 insertion(+) diff --git a/src/diffusers/__init__.py b/src/diffusers/__init__.py index 5323eb91f9c5..f03cdbaf0cce 100644 --- a/src/diffusers/__init__.py +++ b/src/diffusers/__init__.py @@ -130,6 +130,7 @@ "UVit2DModel", "VQModel", "DCAE", + "DCAE_HF", ] ) _import_structure["optimization"] = [ From 0407d5ade8455b1874f2d388d28214d365b99729 Mon Sep 17 00:00:00 2001 From: junsong Date: Tue, 5 Nov 2024 01:11:57 -0800 Subject: [PATCH 078/141] bug fixed; --- sana.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sana.py b/sana.py index 830e9443597a..72b9083dbd76 100644 --- a/sana.py +++ b/sana.py @@ -1,5 +1,5 @@ from diffusers import DCAE, DCAE_HF -from diffsuers import SanaPipeline +# from diffusers import SanaPipeline # vae = DCAE() From fdc95753c4aeb7cc5ff1c6dff9f2d082d1b14d2c Mon Sep 17 00:00:00 2001 From: junsongc Date: Tue, 5 Nov 2024 17:26:22 +0800 Subject: [PATCH 079/141] add SanaPipeline, SanaTransformer2D into diffusers; --- sana.py | 2 +- src/diffusers/__init__.py | 4 + src/diffusers/models/__init__.py | 2 + src/diffusers/models/transformers/__init__.py | 1 + .../transformers/sana_transformer_2d.py | 446 +++++++++ src/diffusers/pipelines/__init__.py | 2 + src/diffusers/pipelines/sana/__init__.py | 53 ++ src/diffusers/pipelines/sana/pipeline_sana.py | 888 ++++++++++++++++++ 8 files changed, 1397 insertions(+), 1 deletion(-) create mode 100644 src/diffusers/models/transformers/sana_transformer_2d.py create mode 100644 src/diffusers/pipelines/sana/__init__.py create mode 100644 src/diffusers/pipelines/sana/pipeline_sana.py diff --git a/sana.py b/sana.py index 72b9083dbd76..db33ef1915fe 100644 --- a/sana.py +++ b/sana.py @@ -1,5 +1,5 @@ from diffusers import DCAE, DCAE_HF -# from diffusers import SanaPipeline +from diffusers import SanaPipeline # vae = DCAE() diff --git a/src/diffusers/__init__.py b/src/diffusers/__init__.py index f03cdbaf0cce..62b96ba0f9d4 100644 --- a/src/diffusers/__init__.py +++ b/src/diffusers/__init__.py @@ -110,6 +110,7 @@ "MultiAdapter", "MultiControlNetModel", "PixArtTransformer2DModel", + "SanaTransformer2DModel", "PriorTransformer", "SD3ControlNetModel", "SD3MultiControlNetModel", @@ -329,6 +330,7 @@ "PixArtSigmaPAGPipeline", "PixArtSigmaPipeline", "ReduxImageEncoder", + "SanaPipeline", "SemanticStableDiffusionPipeline", "ShapEImg2ImgPipeline", "ShapEPipeline", @@ -607,6 +609,7 @@ MultiAdapter, MultiControlNetModel, PixArtTransformer2DModel, + SanaTransformer2DModel, PriorTransformer, SD3ControlNetModel, SD3MultiControlNetModel, @@ -803,6 +806,7 @@ PixArtSigmaPAGPipeline, PixArtSigmaPipeline, ReduxImageEncoder, + SanaPipeline, SemanticStableDiffusionPipeline, ShapEImg2ImgPipeline, ShapEPipeline, diff --git a/src/diffusers/models/__init__.py b/src/diffusers/models/__init__.py index 7183d40b6f91..fe58a646a74c 100644 --- a/src/diffusers/models/__init__.py +++ b/src/diffusers/models/__init__.py @@ -57,6 +57,7 @@ _import_structure["transformers.latte_transformer_3d"] = ["LatteTransformer3DModel"] _import_structure["transformers.lumina_nextdit2d"] = ["LuminaNextDiT2DModel"] _import_structure["transformers.pixart_transformer_2d"] = ["PixArtTransformer2DModel"] + _import_structure["transformers.sana_transformer_2d"] = ["SanaTransformer2DModel"] _import_structure["transformers.prior_transformer"] = ["PriorTransformer"] _import_structure["transformers.stable_audio_transformer"] = ["StableAudioDiTModel"] _import_structure["transformers.t5_film_transformer"] = ["T5FilmDecoder"] @@ -128,6 +129,7 @@ LuminaNextDiT2DModel, MochiTransformer3DModel, PixArtTransformer2DModel, + SanaTransformer2DModel, PriorTransformer, SD3Transformer2DModel, StableAudioDiTModel, diff --git a/src/diffusers/models/transformers/__init__.py b/src/diffusers/models/transformers/__init__.py index a2c087d708a4..3e0db159265c 100644 --- a/src/diffusers/models/transformers/__init__.py +++ b/src/diffusers/models/transformers/__init__.py @@ -20,3 +20,4 @@ from .transformer_mochi import MochiTransformer3DModel from .transformer_sd3 import SD3Transformer2DModel from .transformer_temporal import TransformerTemporalModel + from .sana_transformer_2d import SanaTransformer2DModel diff --git a/src/diffusers/models/transformers/sana_transformer_2d.py b/src/diffusers/models/transformers/sana_transformer_2d.py new file mode 100644 index 000000000000..0614a2724a7b --- /dev/null +++ b/src/diffusers/models/transformers/sana_transformer_2d.py @@ -0,0 +1,446 @@ +# Copyright 2024 The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +from typing import Any, Dict, Optional, Union + +import torch +from torch import nn + +from ...configuration_utils import ConfigMixin, register_to_config +from ...utils import is_torch_version, logging +from ..attention import BasicTransformerBlock +from ..attention_processor import Attention, AttentionProcessor, AttnProcessor, FusedAttnProcessor2_0 +from ..embeddings import PatchEmbed, PixArtAlphaTextProjection +from ..modeling_outputs import Transformer2DModelOutput +from ..modeling_utils import ModelMixin +from ..normalization import AdaLayerNormSingle + + +logger = logging.get_logger(__name__) # pylint: disable=invalid-name + + +class SanaTransformer2DModel(ModelMixin, ConfigMixin): + # TODO: Change pixart name below + r""" + A 2D Transformer model as introduced in Sana family of models (https://arxiv.org/abs/2310.00426, + https://arxiv.org/abs/2403.04692). + + Parameters: + num_attention_heads (int, optional, defaults to 16): The number of heads to use for multi-head attention. + attention_head_dim (int, optional, defaults to 72): The number of channels in each head. + in_channels (int, defaults to 4): The number of channels in the input. + out_channels (int, optional): + The number of channels in the output. Specify this parameter if the output channel number differs from the + input. + num_layers (int, optional, defaults to 28): The number of layers of Transformer blocks to use. + dropout (float, optional, defaults to 0.0): The dropout probability to use within the Transformer blocks. + norm_num_groups (int, optional, defaults to 32): + Number of groups for group normalization within Transformer blocks. + cross_attention_dim (int, optional): + The dimensionality for cross-attention layers, typically matching the encoder's hidden dimension. + attention_bias (bool, optional, defaults to True): + Configure if the Transformer blocks' attention should contain a bias parameter. + sample_size (int, defaults to 128): + The width of the latent images. This parameter is fixed during training. + patch_size (int, defaults to 2): + Size of the patches the model processes, relevant for architectures working on non-sequential data. + activation_fn (str, optional, defaults to "gelu-approximate"): + Activation function to use in feed-forward networks within Transformer blocks. + num_embeds_ada_norm (int, optional, defaults to 1000): + Number of embeddings for AdaLayerNorm, fixed during training and affects the maximum denoising steps during + inference. + upcast_attention (bool, optional, defaults to False): + If true, upcasts the attention mechanism dimensions for potentially improved performance. + norm_type (str, optional, defaults to "ada_norm_zero"): + Specifies the type of normalization used, can be 'ada_norm_zero'. + norm_elementwise_affine (bool, optional, defaults to False): + If true, enables element-wise affine parameters in the normalization layers. + norm_eps (float, optional, defaults to 1e-6): + A small constant added to the denominator in normalization layers to prevent division by zero. + interpolation_scale (int, optional): Scale factor to use during interpolating the position embeddings. + use_additional_conditions (bool, optional): If we're using additional conditions as inputs. + attention_type (str, optional, defaults to "default"): Kind of attention mechanism to be used. + caption_channels (int, optional, defaults to None): + Number of channels to use for projecting the caption embeddings. + use_linear_projection (bool, optional, defaults to False): + Deprecated argument. Will be removed in a future version. + num_vector_embeds (bool, optional, defaults to False): + Deprecated argument. Will be removed in a future version. + """ + + _supports_gradient_checkpointing = True + _no_split_modules = ["BasicTransformerBlock", "PatchEmbed"] + + @register_to_config + def __init__( + self, + num_attention_heads: int = 16, + attention_head_dim: int = 72, + in_channels: int = 4, + out_channels: Optional[int] = 8, + num_layers: int = 28, + dropout: float = 0.0, + norm_num_groups: int = 32, + cross_attention_dim: Optional[int] = 1152, + attention_bias: bool = True, + sample_size: int = 128, + patch_size: int = 2, + activation_fn: str = "gelu-approximate", + num_embeds_ada_norm: Optional[int] = 1000, + upcast_attention: bool = False, + norm_type: str = "ada_norm_single", + norm_elementwise_affine: bool = False, + norm_eps: float = 1e-6, + interpolation_scale: Optional[int] = None, + use_additional_conditions: Optional[bool] = None, + caption_channels: Optional[int] = None, + attention_type: Optional[str] = "default", + ): + super().__init__() + + # Validate inputs. + if norm_type != "ada_norm_single": + raise NotImplementedError( + f"Forward pass is not implemented when `patch_size` is not None and `norm_type` is '{norm_type}'." + ) + elif norm_type == "ada_norm_single" and num_embeds_ada_norm is None: + raise ValueError( + f"When using a `patch_size` and this `norm_type` ({norm_type}), `num_embeds_ada_norm` cannot be None." + ) + + # Set some common variables used across the board. + self.attention_head_dim = attention_head_dim + self.inner_dim = self.config.num_attention_heads * self.config.attention_head_dim + self.out_channels = in_channels if out_channels is None else out_channels + if use_additional_conditions is None: + if sample_size == 128: + use_additional_conditions = True + else: + use_additional_conditions = False + self.use_additional_conditions = use_additional_conditions + + self.gradient_checkpointing = False + + # 2. Initialize the position embedding and transformer blocks. + self.height = self.config.sample_size + self.width = self.config.sample_size + + interpolation_scale = ( + self.config.interpolation_scale + if self.config.interpolation_scale is not None + else max(self.config.sample_size // 64, 1) + ) + self.pos_embed = PatchEmbed( + height=self.config.sample_size, + width=self.config.sample_size, + patch_size=self.config.patch_size, + in_channels=self.config.in_channels, + embed_dim=self.inner_dim, + interpolation_scale=interpolation_scale, + ) + + self.transformer_blocks = nn.ModuleList( + [ + BasicTransformerBlock( + self.inner_dim, + self.config.num_attention_heads, + self.config.attention_head_dim, + dropout=self.config.dropout, + cross_attention_dim=self.config.cross_attention_dim, + activation_fn=self.config.activation_fn, + num_embeds_ada_norm=self.config.num_embeds_ada_norm, + attention_bias=self.config.attention_bias, + upcast_attention=self.config.upcast_attention, + norm_type=norm_type, + norm_elementwise_affine=self.config.norm_elementwise_affine, + norm_eps=self.config.norm_eps, + attention_type=self.config.attention_type, + ) + for _ in range(self.config.num_layers) + ] + ) + + # 3. Output blocks. + self.norm_out = nn.LayerNorm(self.inner_dim, elementwise_affine=False, eps=1e-6) + self.scale_shift_table = nn.Parameter(torch.randn(2, self.inner_dim) / self.inner_dim**0.5) + self.proj_out = nn.Linear(self.inner_dim, self.config.patch_size * self.config.patch_size * self.out_channels) + + self.adaln_single = AdaLayerNormSingle( + self.inner_dim, use_additional_conditions=self.use_additional_conditions + ) + self.caption_projection = None + if self.config.caption_channels is not None: + self.caption_projection = PixArtAlphaTextProjection( + in_features=self.config.caption_channels, hidden_size=self.inner_dim + ) + + def _set_gradient_checkpointing(self, module, value=False): + if hasattr(module, "gradient_checkpointing"): + module.gradient_checkpointing = value + + @property + # Copied from diffusers.models.unets.unet_2d_condition.UNet2DConditionModel.attn_processors + def attn_processors(self) -> Dict[str, AttentionProcessor]: + r""" + Returns: + `dict` of attention processors: A dictionary containing all attention processors used in the model with + indexed by its weight name. + """ + # set recursively + processors = {} + + def fn_recursive_add_processors(name: str, module: torch.nn.Module, processors: Dict[str, AttentionProcessor]): + if hasattr(module, "get_processor"): + processors[f"{name}.processor"] = module.get_processor() + + for sub_name, child in module.named_children(): + fn_recursive_add_processors(f"{name}.{sub_name}", child, processors) + + return processors + + for name, module in self.named_children(): + fn_recursive_add_processors(name, module, processors) + + return processors + + # Copied from diffusers.models.unets.unet_2d_condition.UNet2DConditionModel.set_attn_processor + def set_attn_processor(self, processor: Union[AttentionProcessor, Dict[str, AttentionProcessor]]): + r""" + Sets the attention processor to use to compute attention. + + Parameters: + processor (`dict` of `AttentionProcessor` or only `AttentionProcessor`): + The instantiated processor class or a dictionary of processor classes that will be set as the processor + for **all** `Attention` layers. + + If `processor` is a dict, the key needs to define the path to the corresponding cross attention + processor. This is strongly recommended when setting trainable attention processors. + + """ + count = len(self.attn_processors.keys()) + + if isinstance(processor, dict) and len(processor) != count: + raise ValueError( + f"A dict of processors was passed, but the number of processors {len(processor)} does not match the" + f" number of attention layers: {count}. Please make sure to pass {count} processor classes." + ) + + def fn_recursive_attn_processor(name: str, module: torch.nn.Module, processor): + if hasattr(module, "set_processor"): + if not isinstance(processor, dict): + module.set_processor(processor) + else: + module.set_processor(processor.pop(f"{name}.processor")) + + for sub_name, child in module.named_children(): + fn_recursive_attn_processor(f"{name}.{sub_name}", child, processor) + + for name, module in self.named_children(): + fn_recursive_attn_processor(name, module, processor) + + def set_default_attn_processor(self): + """ + Disables custom attention processors and sets the default attention implementation. + + Safe to just use `AttnProcessor()` as PixArt doesn't have any exotic attention processors in default model. + """ + self.set_attn_processor(AttnProcessor()) + + # Copied from diffusers.models.unets.unet_2d_condition.UNet2DConditionModel.fuse_qkv_projections + def fuse_qkv_projections(self): + """ + Enables fused QKV projections. For self-attention modules, all projection matrices (i.e., query, key, value) + are fused. For cross-attention modules, key and value projection matrices are fused. + + + + This API is 🧪 experimental. + + + """ + self.original_attn_processors = None + + for _, attn_processor in self.attn_processors.items(): + if "Added" in str(attn_processor.__class__.__name__): + raise ValueError("`fuse_qkv_projections()` is not supported for models having added KV projections.") + + self.original_attn_processors = self.attn_processors + + for module in self.modules(): + if isinstance(module, Attention): + module.fuse_projections(fuse=True) + + self.set_attn_processor(FusedAttnProcessor2_0()) + + # Copied from diffusers.models.unets.unet_2d_condition.UNet2DConditionModel.unfuse_qkv_projections + def unfuse_qkv_projections(self): + """Disables the fused QKV projection if enabled. + + + + This API is 🧪 experimental. + + + + """ + if self.original_attn_processors is not None: + self.set_attn_processor(self.original_attn_processors) + + def forward( + self, + hidden_states: torch.Tensor, + encoder_hidden_states: Optional[torch.Tensor] = None, + timestep: Optional[torch.LongTensor] = None, + added_cond_kwargs: Dict[str, torch.Tensor] = None, + cross_attention_kwargs: Dict[str, Any] = None, + attention_mask: Optional[torch.Tensor] = None, + encoder_attention_mask: Optional[torch.Tensor] = None, + return_dict: bool = True, + ): + """ + The [`PixArtTransformer2DModel`] forward method. + + Args: + hidden_states (`torch.FloatTensor` of shape `(batch size, channel, height, width)`): + Input `hidden_states`. + encoder_hidden_states (`torch.FloatTensor` of shape `(batch size, sequence len, embed dims)`, *optional*): + Conditional embeddings for cross attention layer. If not given, cross-attention defaults to + self-attention. + timestep (`torch.LongTensor`, *optional*): + Used to indicate denoising step. Optional timestep to be applied as an embedding in `AdaLayerNorm`. + added_cond_kwargs: (`Dict[str, Any]`, *optional*): Additional conditions to be used as inputs. + cross_attention_kwargs ( `Dict[str, Any]`, *optional*): + A kwargs dictionary that if specified is passed along to the `AttentionProcessor` as defined under + `self.processor` in + [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). + attention_mask ( `torch.Tensor`, *optional*): + An attention mask of shape `(batch, key_tokens)` is applied to `encoder_hidden_states`. If `1` the mask + is kept, otherwise if `0` it is discarded. Mask will be converted into a bias, which adds large + negative values to the attention scores corresponding to "discard" tokens. + encoder_attention_mask ( `torch.Tensor`, *optional*): + Cross-attention mask applied to `encoder_hidden_states`. Two formats supported: + + * Mask `(batch, sequence_length)` True = keep, False = discard. + * Bias `(batch, 1, sequence_length)` 0 = keep, -10000 = discard. + + If `ndim == 2`: will be interpreted as a mask, then converted into a bias consistent with the format + above. This bias will be added to the cross-attention scores. + return_dict (`bool`, *optional*, defaults to `True`): + Whether or not to return a [`~models.unets.unet_2d_condition.UNet2DConditionOutput`] instead of a plain + tuple. + + Returns: + If `return_dict` is True, an [`~models.transformer_2d.Transformer2DModelOutput`] is returned, otherwise a + `tuple` where the first element is the sample tensor. + """ + if self.use_additional_conditions and added_cond_kwargs is None: + raise ValueError("`added_cond_kwargs` cannot be None when using additional conditions for `adaln_single`.") + + # ensure attention_mask is a bias, and give it a singleton query_tokens dimension. + # we may have done this conversion already, e.g. if we came here via UNet2DConditionModel#forward. + # we can tell by counting dims; if ndim == 2: it's a mask rather than a bias. + # expects mask of shape: + # [batch, key_tokens] + # adds singleton query_tokens dimension: + # [batch, 1, key_tokens] + # this helps to broadcast it as a bias over attention scores, which will be in one of the following shapes: + # [batch, heads, query_tokens, key_tokens] (e.g. torch sdp attn) + # [batch * heads, query_tokens, key_tokens] (e.g. xformers or classic attn) + if attention_mask is not None and attention_mask.ndim == 2: + # assume that mask is expressed as: + # (1 = keep, 0 = discard) + # convert mask into a bias that can be added to attention scores: + # (keep = +0, discard = -10000.0) + attention_mask = (1 - attention_mask.to(hidden_states.dtype)) * -10000.0 + attention_mask = attention_mask.unsqueeze(1) + + # convert encoder_attention_mask to a bias the same way we do for attention_mask + if encoder_attention_mask is not None and encoder_attention_mask.ndim == 2: + encoder_attention_mask = (1 - encoder_attention_mask.to(hidden_states.dtype)) * -10000.0 + encoder_attention_mask = encoder_attention_mask.unsqueeze(1) + + # 1. Input + batch_size = hidden_states.shape[0] + height, width = ( + hidden_states.shape[-2] // self.config.patch_size, + hidden_states.shape[-1] // self.config.patch_size, + ) + hidden_states = self.pos_embed(hidden_states) + + timestep, embedded_timestep = self.adaln_single( + timestep, added_cond_kwargs, batch_size=batch_size, hidden_dtype=hidden_states.dtype + ) + + if self.caption_projection is not None: + encoder_hidden_states = self.caption_projection(encoder_hidden_states) + encoder_hidden_states = encoder_hidden_states.view(batch_size, -1, hidden_states.shape[-1]) + + # 2. Blocks + for block in self.transformer_blocks: + if self.training and self.gradient_checkpointing: + + def create_custom_forward(module, return_dict=None): + def custom_forward(*inputs): + if return_dict is not None: + return module(*inputs, return_dict=return_dict) + else: + return module(*inputs) + + return custom_forward + + ckpt_kwargs: Dict[str, Any] = {"use_reentrant": False} if is_torch_version(">=", "1.11.0") else {} + hidden_states = torch.utils.checkpoint.checkpoint( + create_custom_forward(block), + hidden_states, + attention_mask, + encoder_hidden_states, + encoder_attention_mask, + timestep, + cross_attention_kwargs, + None, + **ckpt_kwargs, + ) + else: + hidden_states = block( + hidden_states, + attention_mask=attention_mask, + encoder_hidden_states=encoder_hidden_states, + encoder_attention_mask=encoder_attention_mask, + timestep=timestep, + cross_attention_kwargs=cross_attention_kwargs, + class_labels=None, + ) + + # 3. Output + shift, scale = ( + self.scale_shift_table[None] + embedded_timestep[:, None].to(self.scale_shift_table.device) + ).chunk(2, dim=1) + hidden_states = self.norm_out(hidden_states) + # Modulation + hidden_states = hidden_states * (1 + scale.to(hidden_states.device)) + shift.to(hidden_states.device) + hidden_states = self.proj_out(hidden_states) + hidden_states = hidden_states.squeeze(1) + + # unpatchify + hidden_states = hidden_states.reshape( + shape=(-1, height, width, self.config.patch_size, self.config.patch_size, self.out_channels) + ) + hidden_states = torch.einsum("nhwpqc->nchpwq", hidden_states) + output = hidden_states.reshape( + shape=(-1, self.out_channels, height * self.config.patch_size, width * self.config.patch_size) + ) + + if not return_dict: + return (output,) + + return Transformer2DModelOutput(sample=output) diff --git a/src/diffusers/pipelines/__init__.py b/src/diffusers/pipelines/__init__.py index 6d3a20511696..165638d4eb8f 100644 --- a/src/diffusers/pipelines/__init__.py +++ b/src/diffusers/pipelines/__init__.py @@ -258,6 +258,7 @@ _import_structure["paint_by_example"] = ["PaintByExamplePipeline"] _import_structure["pia"] = ["PIAPipeline"] _import_structure["pixart_alpha"] = ["PixArtAlphaPipeline", "PixArtSigmaPipeline"] + _import_structure["sana"] = ["SanaPipeline"] _import_structure["semantic_stable_diffusion"] = ["SemanticStableDiffusionPipeline"] _import_structure["shap_e"] = ["ShapEImg2ImgPipeline", "ShapEPipeline"] _import_structure["stable_audio"] = [ @@ -605,6 +606,7 @@ from .paint_by_example import PaintByExamplePipeline from .pia import PIAPipeline from .pixart_alpha import PixArtAlphaPipeline, PixArtSigmaPipeline + from .sana import SanaPipeline from .semantic_stable_diffusion import SemanticStableDiffusionPipeline from .shap_e import ShapEImg2ImgPipeline, ShapEPipeline from .stable_audio import StableAudioPipeline, StableAudioProjectionModel diff --git a/src/diffusers/pipelines/sana/__init__.py b/src/diffusers/pipelines/sana/__init__.py new file mode 100644 index 000000000000..b0130b2ab566 --- /dev/null +++ b/src/diffusers/pipelines/sana/__init__.py @@ -0,0 +1,53 @@ +from typing import TYPE_CHECKING + +from ...utils import ( + DIFFUSERS_SLOW_IMPORT, + OptionalDependencyNotAvailable, + _LazyModule, + get_objects_from_module, + is_torch_available, + is_transformers_available, +) + + +_dummy_objects = {} +_import_structure = {} + + +try: + if not (is_transformers_available() and is_torch_available()): + raise OptionalDependencyNotAvailable() +except OptionalDependencyNotAvailable: + from ...utils import dummy_torch_and_transformers_objects # noqa F403 + + _dummy_objects.update(get_objects_from_module(dummy_torch_and_transformers_objects)) +else: + _import_structure["pipeline_sana"] = ["SanaPipeline"] + +if TYPE_CHECKING or DIFFUSERS_SLOW_IMPORT: + try: + if not (is_transformers_available() and is_torch_available()): + raise OptionalDependencyNotAvailable() + + except OptionalDependencyNotAvailable: + from ...utils.dummy_torch_and_transformers_objects import * + else: + from .pipeline_sana import ( + SanaPipeline, + ASPECT_RATIO_256_BIN, + ASPECT_RATIO_512_BIN, + ASPECT_RATIO_1024_BIN, + ASPECT_RATIO_2048_BIN, + ) +else: + import sys + + sys.modules[__name__] = _LazyModule( + __name__, + globals()["__file__"], + _import_structure, + module_spec=__spec__, + ) + + for name, value in _dummy_objects.items(): + setattr(sys.modules[__name__], name, value) diff --git a/src/diffusers/pipelines/sana/pipeline_sana.py b/src/diffusers/pipelines/sana/pipeline_sana.py new file mode 100644 index 000000000000..97208c500e47 --- /dev/null +++ b/src/diffusers/pipelines/sana/pipeline_sana.py @@ -0,0 +1,888 @@ +# Copyright 2024 PixArt-Sigma Authors and The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import html +import inspect +import re +import urllib.parse as ul +from typing import Callable, List, Optional, Tuple, Union + +import torch +from transformers import AutoModelForCausalLM, AutoTokenizer + +from ...image_processor import PixArtImageProcessor +from ...models import AutoencoderKL, SanaTransformer2DModel +from ...schedulers import KarrasDiffusionSchedulers +from ...utils import ( + BACKENDS_MAPPING, + deprecate, + is_bs4_available, + is_ftfy_available, + logging, + replace_example_docstring, +) +from ...utils.torch_utils import randn_tensor +from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput +from ..pixart_alpha.pipeline_pixart_alpha import ( + ASPECT_RATIO_256_BIN, + ASPECT_RATIO_512_BIN, + ASPECT_RATIO_1024_BIN, +) +from ..pixart_alpha.pipeline_pixart_sigma import ASPECT_RATIO_2048_BIN + +tokenizer = AutoTokenizer.from_pretrained(text_encoder_dict[name]) +tokenizer.padding_side = "right" +text_encoder = ( + AutoModelForCausalLM.from_pretrained(text_encoder_dict[name], torch_dtype=torch.bfloat16) + .get_decoder() + .to(device) +) + +logger = logging.get_logger(__name__) # pylint: disable=invalid-name + +if is_bs4_available(): + from bs4 import BeautifulSoup + +if is_ftfy_available(): + import ftfy + + +ASPECT_RATIO_2048_BIN = { + "0.25": [1024.0, 4096.0], + "0.26": [1024.0, 3968.0], + "0.27": [1024.0, 3840.0], + "0.28": [1024.0, 3712.0], + "0.32": [1152.0, 3584.0], + "0.33": [1152.0, 3456.0], + "0.35": [1152.0, 3328.0], + "0.4": [1280.0, 3200.0], + "0.42": [1280.0, 3072.0], + "0.48": [1408.0, 2944.0], + "0.5": [1408.0, 2816.0], + "0.52": [1408.0, 2688.0], + "0.57": [1536.0, 2688.0], + "0.6": [1536.0, 2560.0], + "0.68": [1664.0, 2432.0], + "0.72": [1664.0, 2304.0], + "0.78": [1792.0, 2304.0], + "0.82": [1792.0, 2176.0], + "0.88": [1920.0, 2176.0], + "0.94": [1920.0, 2048.0], + "1.0": [2048.0, 2048.0], + "1.07": [2048.0, 1920.0], + "1.13": [2176.0, 1920.0], + "1.21": [2176.0, 1792.0], + "1.29": [2304.0, 1792.0], + "1.38": [2304.0, 1664.0], + "1.46": [2432.0, 1664.0], + "1.67": [2560.0, 1536.0], + "1.75": [2688.0, 1536.0], + "2.0": [2816.0, 1408.0], + "2.09": [2944.0, 1408.0], + "2.4": [3072.0, 1280.0], + "2.5": [3200.0, 1280.0], + "2.89": [3328.0, 1152.0], + "3.0": [3456.0, 1152.0], + "3.11": [3584.0, 1152.0], + "3.62": [3712.0, 1024.0], + "3.75": [3840.0, 1024.0], + "3.88": [3968.0, 1024.0], + "4.0": [4096.0, 1024.0], +} + + +EXAMPLE_DOC_STRING = """ + Examples: + ```py + >>> import torch + >>> from diffusers import PixArtSigmaPipeline + + >>> # You can replace the checkpoint id with "PixArt-alpha/PixArt-Sigma-XL-2-512-MS" too. + >>> pipe = PixArtSigmaPipeline.from_pretrained( + ... "PixArt-alpha/PixArt-Sigma-XL-2-1024-MS", torch_dtype=torch.float16 + ... ) + >>> # Enable memory optimizations. + >>> # pipe.enable_model_cpu_offload() + + >>> prompt = "A small cactus with a happy face in the Sahara desert." + >>> image = pipe(prompt).images[0] + ``` +""" + + +# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.retrieve_timesteps +def retrieve_timesteps( + scheduler, + num_inference_steps: Optional[int] = None, + device: Optional[Union[str, torch.device]] = None, + timesteps: Optional[List[int]] = None, + sigmas: Optional[List[float]] = None, + **kwargs, +): + r""" + Calls the scheduler's `set_timesteps` method and retrieves timesteps from the scheduler after the call. Handles + custom timesteps. Any kwargs will be supplied to `scheduler.set_timesteps`. + + Args: + scheduler (`SchedulerMixin`): + The scheduler to get timesteps from. + num_inference_steps (`int`): + The number of diffusion steps used when generating samples with a pre-trained model. If used, `timesteps` + must be `None`. + device (`str` or `torch.device`, *optional*): + The device to which the timesteps should be moved to. If `None`, the timesteps are not moved. + timesteps (`List[int]`, *optional*): + Custom timesteps used to override the timestep spacing strategy of the scheduler. If `timesteps` is passed, + `num_inference_steps` and `sigmas` must be `None`. + sigmas (`List[float]`, *optional*): + Custom sigmas used to override the timestep spacing strategy of the scheduler. If `sigmas` is passed, + `num_inference_steps` and `timesteps` must be `None`. + + Returns: + `Tuple[torch.Tensor, int]`: A tuple where the first element is the timestep schedule from the scheduler and the + second element is the number of inference steps. + """ + if timesteps is not None and sigmas is not None: + raise ValueError("Only one of `timesteps` or `sigmas` can be passed. Please choose one to set custom values") + if timesteps is not None: + accepts_timesteps = "timesteps" in set(inspect.signature(scheduler.set_timesteps).parameters.keys()) + if not accepts_timesteps: + raise ValueError( + f"The current scheduler class {scheduler.__class__}'s `set_timesteps` does not support custom" + f" timestep schedules. Please check whether you are using the correct scheduler." + ) + scheduler.set_timesteps(timesteps=timesteps, device=device, **kwargs) + timesteps = scheduler.timesteps + num_inference_steps = len(timesteps) + elif sigmas is not None: + accept_sigmas = "sigmas" in set(inspect.signature(scheduler.set_timesteps).parameters.keys()) + if not accept_sigmas: + raise ValueError( + f"The current scheduler class {scheduler.__class__}'s `set_timesteps` does not support custom" + f" sigmas schedules. Please check whether you are using the correct scheduler." + ) + scheduler.set_timesteps(sigmas=sigmas, device=device, **kwargs) + timesteps = scheduler.timesteps + num_inference_steps = len(timesteps) + else: + scheduler.set_timesteps(num_inference_steps, device=device, **kwargs) + timesteps = scheduler.timesteps + return timesteps, num_inference_steps + + +class SanaPipeline(DiffusionPipeline): + r""" + Pipeline for text-to-image generation using PixArt-Sigma. + """ + + bad_punct_regex = re.compile( + r"[" + + "#®•©™&@·º½¾¿¡§~" + + r"\)" + + r"\(" + + r"\]" + + r"\[" + + r"\}" + + r"\{" + + r"\|" + + "\\" + + r"\/" + + r"\*" + + r"]{1,}" + ) # noqa + + _optional_components = ["tokenizer", "text_encoder"] + model_cpu_offload_seq = "text_encoder->transformer->vae" + + def __init__( + self, + tokenizer: AutoTokenizer, + text_encoder: AutoModelForCausalLM, + vae: AutoencoderKL, + transformer: PixArtTransformer2DModel, + scheduler: KarrasDiffusionSchedulers, + ): + super().__init__() + + self.register_modules( + tokenizer=tokenizer, text_encoder=text_encoder, vae=vae, transformer=transformer, scheduler=scheduler + ) + + self.vae_scale_factor = 2 ** (len(self.vae.config.block_out_channels) - 1) + self.image_processor = PixArtImageProcessor(vae_scale_factor=self.vae_scale_factor) + + # Copied from diffusers.pipelines.pixart_alpha.pipeline_pixart_alpha.PixArtAlphaPipeline.encode_prompt with 120->300 + def encode_prompt( + self, + prompt: Union[str, List[str]], + do_classifier_free_guidance: bool = True, + negative_prompt: str = "", + num_images_per_prompt: int = 1, + device: Optional[torch.device] = None, + prompt_embeds: Optional[torch.Tensor] = None, + negative_prompt_embeds: Optional[torch.Tensor] = None, + prompt_attention_mask: Optional[torch.Tensor] = None, + negative_prompt_attention_mask: Optional[torch.Tensor] = None, + clean_caption: bool = False, + max_sequence_length: int = 300, + **kwargs, + ): + r""" + Encodes the prompt into text encoder hidden states. + + Args: + prompt (`str` or `List[str]`, *optional*): + prompt to be encoded + negative_prompt (`str` or `List[str]`, *optional*): + The prompt not to guide the image generation. If not defined, one has to pass `negative_prompt_embeds` + instead. Ignored when not using guidance (i.e., ignored if `guidance_scale` is less than `1`). For + PixArt-Alpha, this should be "". + do_classifier_free_guidance (`bool`, *optional*, defaults to `True`): + whether to use classifier free guidance or not + num_images_per_prompt (`int`, *optional*, defaults to 1): + number of images that should be generated per prompt + device: (`torch.device`, *optional*): + torch device to place the resulting embeddings on + prompt_embeds (`torch.Tensor`, *optional*): + Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not + provided, text embeddings will be generated from `prompt` input argument. + negative_prompt_embeds (`torch.Tensor`, *optional*): + Pre-generated negative text embeddings. For PixArt-Alpha, it's should be the embeddings of the "" + string. + clean_caption (`bool`, defaults to `False`): + If `True`, the function will preprocess and clean the provided caption before encoding. + max_sequence_length (`int`, defaults to 300): Maximum sequence length to use for the prompt. + """ + + if "mask_feature" in kwargs: + deprecation_message = "The use of `mask_feature` is deprecated. It is no longer used in any computation and that doesn't affect the end results. It will be removed in a future version." + deprecate("mask_feature", "1.0.0", deprecation_message, standard_warn=False) + + if device is None: + device = self._execution_device + + if prompt is not None and isinstance(prompt, str): + batch_size = 1 + elif prompt is not None and isinstance(prompt, list): + batch_size = len(prompt) + else: + batch_size = prompt_embeds.shape[0] + + # See Section 3.1. of the paper. + max_length = max_sequence_length + + if prompt_embeds is None: + prompt = self._text_preprocessing(prompt, clean_caption=clean_caption) + text_inputs = self.tokenizer( + prompt, + padding="max_length", + max_length=max_length, + truncation=True, + add_special_tokens=True, + return_tensors="pt", + ) + text_input_ids = text_inputs.input_ids + untruncated_ids = self.tokenizer(prompt, padding="longest", return_tensors="pt").input_ids + + if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal( + text_input_ids, untruncated_ids + ): + removed_text = self.tokenizer.batch_decode(untruncated_ids[:, max_length - 1 : -1]) + logger.warning( + "The following part of your input was truncated because T5 can only handle sequences up to" + f" {max_length} tokens: {removed_text}" + ) + + prompt_attention_mask = text_inputs.attention_mask + prompt_attention_mask = prompt_attention_mask.to(device) + + prompt_embeds = self.text_encoder(text_input_ids.to(device), attention_mask=prompt_attention_mask) + prompt_embeds = prompt_embeds[0] + + if self.text_encoder is not None: + dtype = self.text_encoder.dtype + elif self.transformer is not None: + dtype = self.transformer.dtype + else: + dtype = None + + prompt_embeds = prompt_embeds.to(dtype=dtype, device=device) + + bs_embed, seq_len, _ = prompt_embeds.shape + # duplicate text embeddings and attention mask for each generation per prompt, using mps friendly method + prompt_embeds = prompt_embeds.repeat(1, num_images_per_prompt, 1) + prompt_embeds = prompt_embeds.view(bs_embed * num_images_per_prompt, seq_len, -1) + prompt_attention_mask = prompt_attention_mask.view(bs_embed, -1) + prompt_attention_mask = prompt_attention_mask.repeat(num_images_per_prompt, 1) + + # get unconditional embeddings for classifier free guidance + if do_classifier_free_guidance and negative_prompt_embeds is None: + uncond_tokens = [negative_prompt] * batch_size if isinstance(negative_prompt, str) else negative_prompt + uncond_tokens = self._text_preprocessing(uncond_tokens, clean_caption=clean_caption) + max_length = prompt_embeds.shape[1] + uncond_input = self.tokenizer( + uncond_tokens, + padding="max_length", + max_length=max_length, + truncation=True, + return_attention_mask=True, + add_special_tokens=True, + return_tensors="pt", + ) + negative_prompt_attention_mask = uncond_input.attention_mask + negative_prompt_attention_mask = negative_prompt_attention_mask.to(device) + + negative_prompt_embeds = self.text_encoder( + uncond_input.input_ids.to(device), attention_mask=negative_prompt_attention_mask + ) + negative_prompt_embeds = negative_prompt_embeds[0] + + if do_classifier_free_guidance: + # duplicate unconditional embeddings for each generation per prompt, using mps friendly method + seq_len = negative_prompt_embeds.shape[1] + + negative_prompt_embeds = negative_prompt_embeds.to(dtype=dtype, device=device) + + negative_prompt_embeds = negative_prompt_embeds.repeat(1, num_images_per_prompt, 1) + negative_prompt_embeds = negative_prompt_embeds.view(batch_size * num_images_per_prompt, seq_len, -1) + + negative_prompt_attention_mask = negative_prompt_attention_mask.view(bs_embed, -1) + negative_prompt_attention_mask = negative_prompt_attention_mask.repeat(num_images_per_prompt, 1) + else: + negative_prompt_embeds = None + negative_prompt_attention_mask = None + + return prompt_embeds, prompt_attention_mask, negative_prompt_embeds, negative_prompt_attention_mask + + # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.prepare_extra_step_kwargs + def prepare_extra_step_kwargs(self, generator, eta): + # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature + # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers. + # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502 + # and should be between [0, 1] + + accepts_eta = "eta" in set(inspect.signature(self.scheduler.step).parameters.keys()) + extra_step_kwargs = {} + if accepts_eta: + extra_step_kwargs["eta"] = eta + + # check if the scheduler accepts generator + accepts_generator = "generator" in set(inspect.signature(self.scheduler.step).parameters.keys()) + if accepts_generator: + extra_step_kwargs["generator"] = generator + return extra_step_kwargs + + # Copied from diffusers.pipelines.pixart_alpha.pipeline_pixart_alpha.PixArtAlphaPipeline.check_inputs + def check_inputs( + self, + prompt, + height, + width, + negative_prompt, + callback_steps, + prompt_embeds=None, + negative_prompt_embeds=None, + prompt_attention_mask=None, + negative_prompt_attention_mask=None, + ): + if height % 8 != 0 or width % 8 != 0: + raise ValueError(f"`height` and `width` have to be divisible by 8 but are {height} and {width}.") + + if (callback_steps is None) or ( + callback_steps is not None and (not isinstance(callback_steps, int) or callback_steps <= 0) + ): + raise ValueError( + f"`callback_steps` has to be a positive integer but is {callback_steps} of type" + f" {type(callback_steps)}." + ) + + if prompt is not None and prompt_embeds is not None: + raise ValueError( + f"Cannot forward both `prompt`: {prompt} and `prompt_embeds`: {prompt_embeds}. Please make sure to" + " only forward one of the two." + ) + elif prompt is None and prompt_embeds is None: + raise ValueError( + "Provide either `prompt` or `prompt_embeds`. Cannot leave both `prompt` and `prompt_embeds` undefined." + ) + elif prompt is not None and (not isinstance(prompt, str) and not isinstance(prompt, list)): + raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}") + + if prompt is not None and negative_prompt_embeds is not None: + raise ValueError( + f"Cannot forward both `prompt`: {prompt} and `negative_prompt_embeds`:" + f" {negative_prompt_embeds}. Please make sure to only forward one of the two." + ) + + if negative_prompt is not None and negative_prompt_embeds is not None: + raise ValueError( + f"Cannot forward both `negative_prompt`: {negative_prompt} and `negative_prompt_embeds`:" + f" {negative_prompt_embeds}. Please make sure to only forward one of the two." + ) + + if prompt_embeds is not None and prompt_attention_mask is None: + raise ValueError("Must provide `prompt_attention_mask` when specifying `prompt_embeds`.") + + if negative_prompt_embeds is not None and negative_prompt_attention_mask is None: + raise ValueError("Must provide `negative_prompt_attention_mask` when specifying `negative_prompt_embeds`.") + + if prompt_embeds is not None and negative_prompt_embeds is not None: + if prompt_embeds.shape != negative_prompt_embeds.shape: + raise ValueError( + "`prompt_embeds` and `negative_prompt_embeds` must have the same shape when passed directly, but" + f" got: `prompt_embeds` {prompt_embeds.shape} != `negative_prompt_embeds`" + f" {negative_prompt_embeds.shape}." + ) + if prompt_attention_mask.shape != negative_prompt_attention_mask.shape: + raise ValueError( + "`prompt_attention_mask` and `negative_prompt_attention_mask` must have the same shape when passed directly, but" + f" got: `prompt_attention_mask` {prompt_attention_mask.shape} != `negative_prompt_attention_mask`" + f" {negative_prompt_attention_mask.shape}." + ) + + # Copied from diffusers.pipelines.deepfloyd_if.pipeline_if.IFPipeline._text_preprocessing + def _text_preprocessing(self, text, clean_caption=False): + if clean_caption and not is_bs4_available(): + logger.warning(BACKENDS_MAPPING["bs4"][-1].format("Setting `clean_caption=True`")) + logger.warning("Setting `clean_caption` to False...") + clean_caption = False + + if clean_caption and not is_ftfy_available(): + logger.warning(BACKENDS_MAPPING["ftfy"][-1].format("Setting `clean_caption=True`")) + logger.warning("Setting `clean_caption` to False...") + clean_caption = False + + if not isinstance(text, (tuple, list)): + text = [text] + + def process(text: str): + if clean_caption: + text = self._clean_caption(text) + text = self._clean_caption(text) + else: + text = text.lower().strip() + return text + + return [process(t) for t in text] + + # Copied from diffusers.pipelines.deepfloyd_if.pipeline_if.IFPipeline._clean_caption + def _clean_caption(self, caption): + caption = str(caption) + caption = ul.unquote_plus(caption) + caption = caption.strip().lower() + caption = re.sub("", "person", caption) + # urls: + caption = re.sub( + r"\b((?:https?:(?:\/{1,3}|[a-zA-Z0-9%])|[a-zA-Z0-9.\-]+[.](?:com|co|ru|net|org|edu|gov|it)[\w/-]*\b\/?(?!@)))", # noqa + "", + caption, + ) # regex for urls + caption = re.sub( + r"\b((?:www:(?:\/{1,3}|[a-zA-Z0-9%])|[a-zA-Z0-9.\-]+[.](?:com|co|ru|net|org|edu|gov|it)[\w/-]*\b\/?(?!@)))", # noqa + "", + caption, + ) # regex for urls + # html: + caption = BeautifulSoup(caption, features="html.parser").text + + # @ + caption = re.sub(r"@[\w\d]+\b", "", caption) + + # 31C0—31EF CJK Strokes + # 31F0—31FF Katakana Phonetic Extensions + # 3200—32FF Enclosed CJK Letters and Months + # 3300—33FF CJK Compatibility + # 3400—4DBF CJK Unified Ideographs Extension A + # 4DC0—4DFF Yijing Hexagram Symbols + # 4E00—9FFF CJK Unified Ideographs + caption = re.sub(r"[\u31c0-\u31ef]+", "", caption) + caption = re.sub(r"[\u31f0-\u31ff]+", "", caption) + caption = re.sub(r"[\u3200-\u32ff]+", "", caption) + caption = re.sub(r"[\u3300-\u33ff]+", "", caption) + caption = re.sub(r"[\u3400-\u4dbf]+", "", caption) + caption = re.sub(r"[\u4dc0-\u4dff]+", "", caption) + caption = re.sub(r"[\u4e00-\u9fff]+", "", caption) + ####################################################### + + # все виды тире / all types of dash --> "-" + caption = re.sub( + r"[\u002D\u058A\u05BE\u1400\u1806\u2010-\u2015\u2E17\u2E1A\u2E3A\u2E3B\u2E40\u301C\u3030\u30A0\uFE31\uFE32\uFE58\uFE63\uFF0D]+", # noqa + "-", + caption, + ) + + # кавычки к одному стандарту + caption = re.sub(r"[`´«»“”¨]", '"', caption) + caption = re.sub(r"[‘’]", "'", caption) + + # " + caption = re.sub(r""?", "", caption) + # & + caption = re.sub(r"&", "", caption) + + # ip adresses: + caption = re.sub(r"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}", " ", caption) + + # article ids: + caption = re.sub(r"\d:\d\d\s+$", "", caption) + + # \n + caption = re.sub(r"\\n", " ", caption) + + # "#123" + caption = re.sub(r"#\d{1,3}\b", "", caption) + # "#12345.." + caption = re.sub(r"#\d{5,}\b", "", caption) + # "123456.." + caption = re.sub(r"\b\d{6,}\b", "", caption) + # filenames: + caption = re.sub(r"[\S]+\.(?:png|jpg|jpeg|bmp|webp|eps|pdf|apk|mp4)", "", caption) + + # + caption = re.sub(r"[\"\']{2,}", r'"', caption) # """AUSVERKAUFT""" + caption = re.sub(r"[\.]{2,}", r" ", caption) # """AUSVERKAUFT""" + + caption = re.sub(self.bad_punct_regex, r" ", caption) # ***AUSVERKAUFT***, #AUSVERKAUFT + caption = re.sub(r"\s+\.\s+", r" ", caption) # " . " + + # this-is-my-cute-cat / this_is_my_cute_cat + regex2 = re.compile(r"(?:\-|\_)") + if len(re.findall(regex2, caption)) > 3: + caption = re.sub(regex2, " ", caption) + + caption = ftfy.fix_text(caption) + caption = html.unescape(html.unescape(caption)) + + caption = re.sub(r"\b[a-zA-Z]{1,3}\d{3,15}\b", "", caption) # jc6640 + caption = re.sub(r"\b[a-zA-Z]+\d+[a-zA-Z]+\b", "", caption) # jc6640vc + caption = re.sub(r"\b\d+[a-zA-Z]+\d+\b", "", caption) # 6640vc231 + + caption = re.sub(r"(worldwide\s+)?(free\s+)?shipping", "", caption) + caption = re.sub(r"(free\s)?download(\sfree)?", "", caption) + caption = re.sub(r"\bclick\b\s(?:for|on)\s\w+", "", caption) + caption = re.sub(r"\b(?:png|jpg|jpeg|bmp|webp|eps|pdf|apk|mp4)(\simage[s]?)?", "", caption) + caption = re.sub(r"\bpage\s+\d+\b", "", caption) + + caption = re.sub(r"\b\d*[a-zA-Z]+\d+[a-zA-Z]+\d+[a-zA-Z\d]*\b", r" ", caption) # j2d1a2a... + + caption = re.sub(r"\b\d+\.?\d*[xх×]\d+\.?\d*\b", "", caption) + + caption = re.sub(r"\b\s+\:\s+", r": ", caption) + caption = re.sub(r"(\D[,\./])\b", r"\1 ", caption) + caption = re.sub(r"\s+", " ", caption) + + caption.strip() + + caption = re.sub(r"^[\"\']([\w\W]+)[\"\']$", r"\1", caption) + caption = re.sub(r"^[\'\_,\-\:;]", r"", caption) + caption = re.sub(r"[\'\_,\-\:\-\+]$", r"", caption) + caption = re.sub(r"^\.\S+$", "", caption) + + return caption.strip() + + # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.prepare_latents + def prepare_latents(self, batch_size, num_channels_latents, height, width, dtype, device, generator, latents=None): + shape = ( + batch_size, + num_channels_latents, + int(height) // self.vae_scale_factor, + int(width) // self.vae_scale_factor, + ) + if isinstance(generator, list) and len(generator) != batch_size: + raise ValueError( + f"You have passed a list of generators of length {len(generator)}, but requested an effective batch" + f" size of {batch_size}. Make sure the batch size matches the length of the generators." + ) + + if latents is None: + latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype) + else: + latents = latents.to(device) + + # scale the initial noise by the standard deviation required by the scheduler + latents = latents * self.scheduler.init_noise_sigma + return latents + + @torch.no_grad() + @replace_example_docstring(EXAMPLE_DOC_STRING) + def __call__( + self, + prompt: Union[str, List[str]] = None, + negative_prompt: str = "", + num_inference_steps: int = 20, + timesteps: List[int] = None, + sigmas: List[float] = None, + guidance_scale: float = 4.5, + num_images_per_prompt: Optional[int] = 1, + height: Optional[int] = None, + width: Optional[int] = None, + eta: float = 0.0, + generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None, + latents: Optional[torch.Tensor] = None, + prompt_embeds: Optional[torch.Tensor] = None, + prompt_attention_mask: Optional[torch.Tensor] = None, + negative_prompt_embeds: Optional[torch.Tensor] = None, + negative_prompt_attention_mask: Optional[torch.Tensor] = None, + output_type: Optional[str] = "pil", + return_dict: bool = True, + callback: Optional[Callable[[int, int, torch.Tensor], None]] = None, + callback_steps: int = 1, + clean_caption: bool = True, + use_resolution_binning: bool = True, + max_sequence_length: int = 300, + **kwargs, + ) -> Union[ImagePipelineOutput, Tuple]: + """ + Function invoked when calling the pipeline for generation. + + Args: + prompt (`str` or `List[str]`, *optional*): + The prompt or prompts to guide the image generation. If not defined, one has to pass `prompt_embeds`. + instead. + negative_prompt (`str` or `List[str]`, *optional*): + The prompt or prompts not to guide the image generation. If not defined, one has to pass + `negative_prompt_embeds` instead. Ignored when not using guidance (i.e., ignored if `guidance_scale` is + less than `1`). + num_inference_steps (`int`, *optional*, defaults to 100): + The number of denoising steps. More denoising steps usually lead to a higher quality image at the + expense of slower inference. + timesteps (`List[int]`, *optional*): + Custom timesteps to use for the denoising process with schedulers which support a `timesteps` argument + in their `set_timesteps` method. If not defined, the default behavior when `num_inference_steps` is + passed will be used. Must be in descending order. + sigmas (`List[float]`, *optional*): + Custom sigmas to use for the denoising process with schedulers which support a `sigmas` argument in + their `set_timesteps` method. If not defined, the default behavior when `num_inference_steps` is passed + will be used. + guidance_scale (`float`, *optional*, defaults to 4.5): + Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598). + `guidance_scale` is defined as `w` of equation 2. of [Imagen + Paper](https://arxiv.org/pdf/2205.11487.pdf). Guidance scale is enabled by setting `guidance_scale > + 1`. Higher guidance scale encourages to generate images that are closely linked to the text `prompt`, + usually at the expense of lower image quality. + num_images_per_prompt (`int`, *optional*, defaults to 1): + The number of images to generate per prompt. + height (`int`, *optional*, defaults to self.unet.config.sample_size): + The height in pixels of the generated image. + width (`int`, *optional*, defaults to self.unet.config.sample_size): + The width in pixels of the generated image. + eta (`float`, *optional*, defaults to 0.0): + Corresponds to parameter eta (η) in the DDIM paper: https://arxiv.org/abs/2010.02502. Only applies to + [`schedulers.DDIMScheduler`], will be ignored for others. + generator (`torch.Generator` or `List[torch.Generator]`, *optional*): + One or a list of [torch generator(s)](https://pytorch.org/docs/stable/generated/torch.Generator.html) + to make generation deterministic. + latents (`torch.Tensor`, *optional*): + Pre-generated noisy latents, sampled from a Gaussian distribution, to be used as inputs for image + generation. Can be used to tweak the same generation with different prompts. If not provided, a latents + tensor will ge generated by sampling using the supplied random `generator`. + prompt_embeds (`torch.Tensor`, *optional*): + Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not + provided, text embeddings will be generated from `prompt` input argument. + prompt_attention_mask (`torch.Tensor`, *optional*): Pre-generated attention mask for text embeddings. + negative_prompt_embeds (`torch.Tensor`, *optional*): + Pre-generated negative text embeddings. For PixArt-Sigma this negative prompt should be "". If not + provided, negative_prompt_embeds will be generated from `negative_prompt` input argument. + negative_prompt_attention_mask (`torch.Tensor`, *optional*): + Pre-generated attention mask for negative text embeddings. + output_type (`str`, *optional*, defaults to `"pil"`): + The output format of the generate image. Choose between + [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` or `np.array`. + return_dict (`bool`, *optional*, defaults to `True`): + Whether or not to return a [`~pipelines.stable_diffusion.IFPipelineOutput`] instead of a plain tuple. + callback (`Callable`, *optional*): + A function that will be called every `callback_steps` steps during inference. The function will be + called with the following arguments: `callback(step: int, timestep: int, latents: torch.Tensor)`. + callback_steps (`int`, *optional*, defaults to 1): + The frequency at which the `callback` function will be called. If not specified, the callback will be + called at every step. + clean_caption (`bool`, *optional*, defaults to `True`): + Whether or not to clean the caption before creating embeddings. Requires `beautifulsoup4` and `ftfy` to + be installed. If the dependencies are not installed, the embeddings will be created from the raw + prompt. + use_resolution_binning (`bool` defaults to `True`): + If set to `True`, the requested height and width are first mapped to the closest resolutions using + `ASPECT_RATIO_1024_BIN`. After the produced latents are decoded into images, they are resized back to + the requested resolution. Useful for generating non-square images. + max_sequence_length (`int` defaults to 300): Maximum sequence length to use with the `prompt`. + + Examples: + + Returns: + [`~pipelines.ImagePipelineOutput`] or `tuple`: + If `return_dict` is `True`, [`~pipelines.ImagePipelineOutput`] is returned, otherwise a `tuple` is + returned where the first element is a list with the generated images + """ + # 1. Check inputs. Raise error if not correct + height = height or self.transformer.config.sample_size * self.vae_scale_factor + width = width or self.transformer.config.sample_size * self.vae_scale_factor + if use_resolution_binning: + if self.transformer.config.sample_size == 256: + aspect_ratio_bin = ASPECT_RATIO_2048_BIN + elif self.transformer.config.sample_size == 128: + aspect_ratio_bin = ASPECT_RATIO_1024_BIN + elif self.transformer.config.sample_size == 64: + aspect_ratio_bin = ASPECT_RATIO_512_BIN + elif self.transformer.config.sample_size == 32: + aspect_ratio_bin = ASPECT_RATIO_256_BIN + else: + raise ValueError("Invalid sample size") + orig_height, orig_width = height, width + height, width = self.image_processor.classify_height_width_bin(height, width, ratios=aspect_ratio_bin) + + self.check_inputs( + prompt, + height, + width, + negative_prompt, + callback_steps, + prompt_embeds, + negative_prompt_embeds, + prompt_attention_mask, + negative_prompt_attention_mask, + ) + + # 2. Default height and width to transformer + if prompt is not None and isinstance(prompt, str): + batch_size = 1 + elif prompt is not None and isinstance(prompt, list): + batch_size = len(prompt) + else: + batch_size = prompt_embeds.shape[0] + + device = self._execution_device + + # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2) + # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1` + # corresponds to doing no classifier free guidance. + do_classifier_free_guidance = guidance_scale > 1.0 + + # 3. Encode input prompt + ( + prompt_embeds, + prompt_attention_mask, + negative_prompt_embeds, + negative_prompt_attention_mask, + ) = self.encode_prompt( + prompt, + do_classifier_free_guidance, + negative_prompt=negative_prompt, + num_images_per_prompt=num_images_per_prompt, + device=device, + prompt_embeds=prompt_embeds, + negative_prompt_embeds=negative_prompt_embeds, + prompt_attention_mask=prompt_attention_mask, + negative_prompt_attention_mask=negative_prompt_attention_mask, + clean_caption=clean_caption, + max_sequence_length=max_sequence_length, + ) + if do_classifier_free_guidance: + prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds], dim=0) + prompt_attention_mask = torch.cat([negative_prompt_attention_mask, prompt_attention_mask], dim=0) + + # 4. Prepare timesteps + timesteps, num_inference_steps = retrieve_timesteps( + self.scheduler, num_inference_steps, device, timesteps, sigmas + ) + + # 5. Prepare latents. + latent_channels = self.transformer.config.in_channels + latents = self.prepare_latents( + batch_size * num_images_per_prompt, + latent_channels, + height, + width, + prompt_embeds.dtype, + device, + generator, + latents, + ) + + # 6. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline + extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta) + + # 6.1 Prepare micro-conditions. + added_cond_kwargs = {"resolution": None, "aspect_ratio": None} + + # 7. Denoising loop + num_warmup_steps = max(len(timesteps) - num_inference_steps * self.scheduler.order, 0) + + with self.progress_bar(total=num_inference_steps) as progress_bar: + for i, t in enumerate(timesteps): + latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents + latent_model_input = self.scheduler.scale_model_input(latent_model_input, t) + + current_timestep = t + if not torch.is_tensor(current_timestep): + # TODO: this requires sync between CPU and GPU. So try to pass timesteps as tensors if you can + # This would be a good case for the `match` statement (Python 3.10+) + is_mps = latent_model_input.device.type == "mps" + if isinstance(current_timestep, float): + dtype = torch.float32 if is_mps else torch.float64 + else: + dtype = torch.int32 if is_mps else torch.int64 + current_timestep = torch.tensor([current_timestep], dtype=dtype, device=latent_model_input.device) + elif len(current_timestep.shape) == 0: + current_timestep = current_timestep[None].to(latent_model_input.device) + # broadcast to batch dimension in a way that's compatible with ONNX/Core ML + current_timestep = current_timestep.expand(latent_model_input.shape[0]) + + # predict noise model_output + noise_pred = self.transformer( + latent_model_input, + encoder_hidden_states=prompt_embeds, + encoder_attention_mask=prompt_attention_mask, + timestep=current_timestep, + added_cond_kwargs=added_cond_kwargs, + return_dict=False, + )[0] + + # perform guidance + if do_classifier_free_guidance: + noise_pred_uncond, noise_pred_text = noise_pred.chunk(2) + noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) + + # learned sigma + if self.transformer.config.out_channels // 2 == latent_channels: + noise_pred = noise_pred.chunk(2, dim=1)[0] + else: + noise_pred = noise_pred + + # compute previous image: x_t -> x_t-1 + latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs, return_dict=False)[0] + + # call the callback, if provided + if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0): + progress_bar.update() + if callback is not None and i % callback_steps == 0: + step_idx = i // getattr(self.scheduler, "order", 1) + callback(step_idx, t, latents) + + if not output_type == "latent": + image = self.vae.decode(latents / self.vae.config.scaling_factor, return_dict=False)[0] + if use_resolution_binning: + image = self.image_processor.resize_and_crop_tensor(image, orig_width, orig_height) + else: + image = latents + + if not output_type == "latent": + image = self.image_processor.postprocess(image, output_type=output_type) + + # Offload all models + self.maybe_free_model_hooks() + + if not return_dict: + return (image,) + + return ImagePipelineOutput(images=image) From b90ec21f15e669bda700d8d4a69a30bd62989caa Mon Sep 17 00:00:00 2001 From: junsongc Date: Tue, 5 Nov 2024 17:35:48 +0800 Subject: [PATCH 080/141] add sanaLinearAttnProcessor2_0; --- src/diffusers/models/attention_processor.py | 94 +++++++++++++++++++ src/diffusers/pipelines/sana/pipeline_sana.py | 13 +-- 2 files changed, 97 insertions(+), 10 deletions(-) diff --git a/src/diffusers/models/attention_processor.py b/src/diffusers/models/attention_processor.py index c3ff5749862a..ac703c73819c 100644 --- a/src/diffusers/models/attention_processor.py +++ b/src/diffusers/models/attention_processor.py @@ -5190,6 +5190,99 @@ def __init__(self): super().__init__() +class SanaLinearAttnProcessor2_0: + r""" + Processor for implementing scaled dot-product linear attention. + """ + + def __init__(self): + pass + + def __call__( + self, + attn: Attention, + hidden_states: torch.Tensor, + encoder_hidden_states: Optional[torch.Tensor] = None, + attention_mask: Optional[torch.Tensor] = None, + temb: Optional[torch.Tensor] = None, + *args, + **kwargs, + ) -> torch.Tensor: + if len(args) > 0 or kwargs.get("scale", None) is not None: + deprecation_message = "The `scale` argument is deprecated and will be ignored. Please remove it, as passing it will raise an error in the future. `scale` should directly be passed while calling the underlying pipeline component i.e., via `cross_attention_kwargs`." + deprecate("scale", "1.0.0", deprecation_message) + + residual = hidden_states + if attn.spatial_norm is not None: + hidden_states = attn.spatial_norm(hidden_states, temb) + + input_ndim = hidden_states.ndim + + if input_ndim == 4: + batch_size, channel, height, width = hidden_states.shape + hidden_states = hidden_states.view(batch_size, channel, height * width).transpose(1, 2) + + batch_size, sequence_length, _ = ( + hidden_states.shape if encoder_hidden_states is None else encoder_hidden_states.shape + ) + + if attention_mask is not None: + attention_mask = attn.prepare_attention_mask(attention_mask, sequence_length, batch_size) + # scaled_dot_product_attention expects attention_mask shape to be + # (batch, heads, source_length, target_length) + attention_mask = attention_mask.view(batch_size, attn.heads, -1, attention_mask.shape[-1]) + + if attn.group_norm is not None: + hidden_states = attn.group_norm(hidden_states.transpose(1, 2)).transpose(1, 2) + + query = attn.to_q(hidden_states) + + if encoder_hidden_states is None: + encoder_hidden_states = hidden_states + elif attn.norm_cross: + encoder_hidden_states = attn.norm_encoder_hidden_states(encoder_hidden_states) + + key = attn.to_k(encoder_hidden_states) + value = attn.to_v(encoder_hidden_states) + + inner_dim = key.shape[-1] + head_dim = inner_dim // attn.heads + + query = query.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2) + + key = key.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2) + value = value.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2) + + if attn.norm_q is not None: + query = attn.norm_q(query) + if attn.norm_k is not None: + key = attn.norm_k(key) + + # the output of sdp = (batch, num_heads, seq_len, head_dim) + # TODO: add support for attn.scale when we move to Torch 2.1 + hidden_states = F.scaled_dot_product_attention( + query, key, value, attn_mask=attention_mask, dropout_p=0.0, is_causal=False + ) + + hidden_states = hidden_states.transpose(1, 2).reshape(batch_size, -1, attn.heads * head_dim) + hidden_states = hidden_states.to(query.dtype) + + # linear proj + hidden_states = attn.to_out[0](hidden_states) + # dropout + hidden_states = attn.to_out[1](hidden_states) + + if input_ndim == 4: + hidden_states = hidden_states.transpose(-1, -2).reshape(batch_size, channel, height, width) + + if attn.residual_connection: + hidden_states = hidden_states + residual + + hidden_states = hidden_states / attn.rescale_output_factor + + return hidden_states + + ADDED_KV_ATTENTION_PROCESSORS = ( AttnAddedKVProcessor, SlicedAttnAddedKVProcessor, @@ -5250,4 +5343,5 @@ def __init__(self): LoRAAttnProcessor2_0, LoRAXFormersAttnProcessor, LoRAAttnAddedKVProcessor, + SanaLinearAttnProcessor2_0, ] diff --git a/src/diffusers/pipelines/sana/pipeline_sana.py b/src/diffusers/pipelines/sana/pipeline_sana.py index 97208c500e47..d94ecf486eb7 100644 --- a/src/diffusers/pipelines/sana/pipeline_sana.py +++ b/src/diffusers/pipelines/sana/pipeline_sana.py @@ -23,7 +23,7 @@ from ...image_processor import PixArtImageProcessor from ...models import AutoencoderKL, SanaTransformer2DModel -from ...schedulers import KarrasDiffusionSchedulers +from ...schedulers import KarrasDiffusionSchedulers, FlowMatchEulerDiscreteScheduler from ...utils import ( BACKENDS_MAPPING, deprecate, @@ -41,13 +41,6 @@ ) from ..pixart_alpha.pipeline_pixart_sigma import ASPECT_RATIO_2048_BIN -tokenizer = AutoTokenizer.from_pretrained(text_encoder_dict[name]) -tokenizer.padding_side = "right" -text_encoder = ( - AutoModelForCausalLM.from_pretrained(text_encoder_dict[name], torch_dtype=torch.bfloat16) - .get_decoder() - .to(device) -) logger = logging.get_logger(__name__) # pylint: disable=invalid-name @@ -210,8 +203,8 @@ def __init__( tokenizer: AutoTokenizer, text_encoder: AutoModelForCausalLM, vae: AutoencoderKL, - transformer: PixArtTransformer2DModel, - scheduler: KarrasDiffusionSchedulers, + transformer: SanaTransformer2DModel, + scheduler: FlowMatchEulerDiscreteScheduler, ): super().__init__() From ebe8100e44fd6c1863b4b136667b25fcb8a9118f Mon Sep 17 00:00:00 2001 From: junsongc Date: Wed, 6 Nov 2024 14:30:37 +0800 Subject: [PATCH 081/141] first update for SanaTransformer; --- src/diffusers/models/attention_processor.py | 68 ++++-- .../transformers/sana_transformer_2d.py | 201 ++++++++++++++++-- 2 files changed, 240 insertions(+), 29 deletions(-) diff --git a/src/diffusers/models/attention_processor.py b/src/diffusers/models/attention_processor.py index ac703c73819c..67a84dd36d7a 100644 --- a/src/diffusers/models/attention_processor.py +++ b/src/diffusers/models/attention_processor.py @@ -5195,8 +5195,10 @@ class SanaLinearAttnProcessor2_0: Processor for implementing scaled dot-product linear attention. """ - def __init__(self): - pass + def __init__(self, pad_val=1.0, eps=1e-15): + self.pad_val = pad_val + self.eps = eps + self.kernel_func = nn.ReLU(inplace=False) def __call__( self, @@ -5248,24 +5250,55 @@ def __call__( inner_dim = key.shape[-1] head_dim = inner_dim // attn.heads - query = query.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2) + if encoder_hidden_states is None: + dtype = query.dtype - key = key.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2) - value = value.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2) + query = query.view(batch_size, attn.heads, head_dim, -1).transpose(1, 2) - if attn.norm_q is not None: - query = attn.norm_q(query) - if attn.norm_k is not None: - key = attn.norm_k(key) + key = key.view(batch_size, attn.heads, head_dim, -1).transpose(1, 2) + value = value.view(batch_size, attn.heads, head_dim, -1).transpose(1, 2) - # the output of sdp = (batch, num_heads, seq_len, head_dim) - # TODO: add support for attn.scale when we move to Torch 2.1 - hidden_states = F.scaled_dot_product_attention( - query, key, value, attn_mask=attention_mask, dropout_p=0.0, is_causal=False - ) + query = self.kernel_func(query) # B, h, h_d, N + key = self.kernel_func(key) - hidden_states = hidden_states.transpose(1, 2).reshape(batch_size, -1, attn.heads * head_dim) - hidden_states = hidden_states.to(query.dtype) + if attn.norm_q is not None: + query = attn.norm_q(query) + if attn.norm_k is not None: + key = attn.norm_k(key) + + # need torch.float + query, key, value = query.float(), key.float(), value.float() + + value = F.pad(value, (0, 0, 0, 1), mode="constant", value=self.pad_val) + vk = torch.matmul(value, key) + hidden_states = torch.matmul(vk, query).to(dtype) + + if hidden_states.dtype in [torch.float16, torch.bfloat16]: + hidden_states = hidden_states.float() + hidden_states = hidden_states[:, :, :-1] / (hidden_states[:, :, -1:] + self.eps) + + hidden_states = hidden_states.view(batch_size, attn.heads * head_dim, -1).permute(0, 2, 1) + hidden_states = hidden_states.to(dtype) + + else: + query = query.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2) + + key = key.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2) + value = value.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2) + + if attn.norm_q is not None: + query = attn.norm_q(query) + if attn.norm_k is not None: + key = attn.norm_k(key) + + # the output of sdp = (batch, num_heads, seq_len, head_dim) + # TODO: add support for attn.scale when we move to Torch 2.1 + hidden_states = F.scaled_dot_product_attention( + query, key, value, attn_mask=attention_mask, dropout_p=0.0, is_causal=False + ) + + hidden_states = hidden_states.transpose(1, 2).reshape(batch_size, -1, attn.heads * head_dim) + hidden_states = hidden_states.to(query.dtype) # linear proj hidden_states = attn.to_out[0](hidden_states) @@ -5280,6 +5313,9 @@ def __call__( hidden_states = hidden_states / attn.rescale_output_factor + if hidden_states.dtype == torch.float16: + hidden_states = hidden_states.clip(-65504, 65504) + return hidden_states diff --git a/src/diffusers/models/transformers/sana_transformer_2d.py b/src/diffusers/models/transformers/sana_transformer_2d.py index 0614a2724a7b..9fa549c8c3f8 100644 --- a/src/diffusers/models/transformers/sana_transformer_2d.py +++ b/src/diffusers/models/transformers/sana_transformer_2d.py @@ -18,17 +18,198 @@ from ...configuration_utils import ConfigMixin, register_to_config from ...utils import is_torch_version, logging -from ..attention import BasicTransformerBlock -from ..attention_processor import Attention, AttentionProcessor, AttnProcessor, FusedAttnProcessor2_0 -from ..embeddings import PatchEmbed, PixArtAlphaTextProjection +from ..attention import BasicTransformerBlock, _chunked_feed_forward +from ..attention_processor import ( + Attention, AttentionProcessor, AttnProcessor, FusedAttnProcessor2_0, SanaLinearAttnProcessor2_0 +) +from ..autoencoders.dc_ae import GLUMBConv +from ..embeddings import PatchEmbed, PixArtAlphaTextProjection, SinusoidalPositionalEmbedding from ..modeling_outputs import Transformer2DModelOutput from ..modeling_utils import ModelMixin from ..normalization import AdaLayerNormSingle +from ...utils.torch_utils import maybe_allow_in_graph logger = logging.get_logger(__name__) # pylint: disable=invalid-name +# Modified from diffusers.models.attention.BasicTransformerBlock +@maybe_allow_in_graph +class SanaLinearTransformerBlock(nn.Module): + r""" + A Transformer block following the Linear Transformer architecture, introduced in Sana + + Reference: https://arxiv.org/abs/2410.10629 + + Parameters: + dim (`int`): The number of channels in the input and output. + num_attention_heads (`int`): The number of heads to use for multi-head attention. + attention_head_dim (`int`): The number of channels in each head. + context_pre_only (`bool`): Boolean to determine if we should add some blocks associated with the + processing of `context` conditions. + """ + + def __init__( + self, + dim: int, + num_attention_heads: int, + attention_head_dim: int, + dropout=0.0, + cross_attention_dim: Optional[int] = None, + activation_fn: tuple = ("silu", "silu", None), + num_embeds_ada_norm: Optional[int] = None, + attention_bias: bool = False, + upcast_attention: bool = False, + norm_type: str = "ada_norm_single", + norm_elementwise_affine: bool = False, + norm_eps: float = 1e-5, + attention_out_bias: bool = True, + use_pe: bool = False, + expand_ratio: float = 2.5, + ff_bias: tuple =(True, True, False), + norm=(None, None, None), + ): + super().__init__() + self.dim = dim + self.num_attention_heads = num_attention_heads + self.attention_head_dim = attention_head_dim + self.dropout = dropout + self.cross_attention_dim = cross_attention_dim + self.activation_fn = activation_fn + self.attention_bias = attention_bias + self.norm_elementwise_affine = norm_elementwise_affine + + self.use_ada_layer_norm_single = norm_type == "ada_norm_single" + self.norm_type = norm_type + self.num_embeds_ada_norm = num_embeds_ada_norm + + self.use_pe = use_pe + if use_pe: + self.pos_embed = SinusoidalPositionalEmbedding(dim, max_seq_length=num_positional_embeddings) + else: + self.pos_embed = None + + self.norm1 = nn.LayerNorm(dim, elementwise_affine=False, eps=norm_eps) + + self.attn1 = Attention( + query_dim=dim, + heads=num_attention_heads, + dim_head=attention_head_dim, + dropout=dropout, + bias=attention_bias, + cross_attention_dim=None, + upcast_attention=upcast_attention, + processor=SanaLinearAttnProcessor2_0(), + ) + + # 2. Cross-Attn + if cross_attention_dim is not None: + self.norm2 = nn.LayerNorm(dim, elementwise_affine=norm_elementwise_affine, eps=norm_eps) + + self.attn2 = Attention( + query_dim=dim, + cross_attention_dim=cross_attention_dim, + heads=num_attention_heads, + dim_head=attention_head_dim, + dropout=dropout, + bias=attention_bias, + upcast_attention=upcast_attention, + out_bias=attention_out_bias, + processor=AttnProcessor(), + ) + + self.ff = GLUMBConv( + in_channels=dim, + out_channels=dim, + expand_ratio=expand_ratio, + use_bias=ff_bias, + norm=norm, + act_func=activation_fn, + ) + + # 5. Scale-shift for Sana. + self.scale_shift_table = nn.Parameter(torch.randn(6, dim) / dim ** 0.5) + + # let chunk size default to None + self._chunk_size = None + self._chunk_dim = 0 + + def set_chunk_feed_forward(self, chunk_size: Optional[int], dim: int = 0): + # Sets chunk feed-forward + self._chunk_size = chunk_size + self._chunk_dim = dim + + def forward( + self, + hidden_states: torch.Tensor, + attention_mask: Optional[torch.Tensor] = None, + encoder_hidden_states: Optional[torch.Tensor] = None, + encoder_attention_mask: Optional[torch.Tensor] = None, + timestep: Optional[torch.LongTensor] = None, + cross_attention_kwargs: Dict[str, Any] = None, + class_labels: Optional[torch.LongTensor] = None, + added_cond_kwargs: Optional[Dict[str, torch.Tensor]] = None, + ) -> torch.Tensor: + if cross_attention_kwargs is not None: + if cross_attention_kwargs.get("scale", None) is not None: + logger.warning("Passing `scale` to `cross_attention_kwargs` is deprecated. `scale` will be ignored.") + + # Notice that normalization is always applied before the real computation in the following blocks. + # 0. Self-Attention + batch_size = hidden_states.shape[0] + + shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = ( + self.scale_shift_table[None] + timestep.reshape(batch_size, 6, -1) + ).chunk(6, dim=1) + norm_hidden_states = self.norm1(hidden_states) + norm_hidden_states = norm_hidden_states * (1 + scale_msa) + shift_msa + + if self.pos_embed is not None: + norm_hidden_states = self.pos_embed(norm_hidden_states) + + attn_output = self.attn1( + norm_hidden_states, + encoder_hidden_states=None, + attention_mask=attention_mask, + **cross_attention_kwargs, + ) + attn_output = gate_msa * attn_output + + hidden_states = attn_output + hidden_states + if hidden_states.ndim == 4: + hidden_states = hidden_states.squeeze(1) + + # 3. Cross-Attention + if self.attn2 is not None: + norm_hidden_states = hidden_states + + if self.pos_embed is not None: + norm_hidden_states = self.pos_embed(norm_hidden_states) + + attn_output = self.attn2( + norm_hidden_states, + encoder_hidden_states=encoder_hidden_states, + attention_mask=encoder_attention_mask, + **cross_attention_kwargs, + ) + hidden_states = attn_output + hidden_states + + # 4. Feed-forward + if self._chunk_size is not None: + # "feed_forward_chunk_size" can be used to save memory + ff_output = _chunked_feed_forward(self.ff, norm_hidden_states, self._chunk_dim, self._chunk_size) + else: + ff_output = self.ff(norm_hidden_states) + + ff_output = gate_mlp * ff_output + + hidden_states = ff_output + hidden_states + if hidden_states.ndim == 4: + hidden_states = hidden_states.squeeze(1) + + return hidden_states + + class SanaTransformer2DModel(ModelMixin, ConfigMixin): # TODO: Change pixart name below r""" @@ -105,6 +286,7 @@ def __init__( use_additional_conditions: Optional[bool] = None, caption_channels: Optional[int] = None, attention_type: Optional[str] = "default", + use_pe: Optional[bool] = False, ): super().__init__() @@ -140,6 +322,7 @@ def __init__( if self.config.interpolation_scale is not None else max(self.config.sample_size // 64, 1) ) + self.use_pe = use_pe self.pos_embed = PatchEmbed( height=self.config.sample_size, width=self.config.sample_size, @@ -147,11 +330,12 @@ def __init__( in_channels=self.config.in_channels, embed_dim=self.inner_dim, interpolation_scale=interpolation_scale, + pos_embed_type="sincos" if use_pe else None ) self.transformer_blocks = nn.ModuleList( [ - BasicTransformerBlock( + SanaLinearTransformerBlock( self.inner_dim, self.config.num_attention_heads, self.config.attention_head_dim, @@ -248,14 +432,6 @@ def fn_recursive_attn_processor(name: str, module: torch.nn.Module, processor): for name, module in self.named_children(): fn_recursive_attn_processor(name, module, processor) - def set_default_attn_processor(self): - """ - Disables custom attention processors and sets the default attention implementation. - - Safe to just use `AttnProcessor()` as PixArt doesn't have any exotic attention processors in default model. - """ - self.set_attn_processor(AttnProcessor()) - # Copied from diffusers.models.unets.unet_2d_condition.UNet2DConditionModel.fuse_qkv_projections def fuse_qkv_projections(self): """ @@ -407,7 +583,6 @@ def custom_forward(*inputs): encoder_attention_mask, timestep, cross_attention_kwargs, - None, **ckpt_kwargs, ) else: From a34d173d6ec21176d0fc9e20e9ad45838b0fa151 Mon Sep 17 00:00:00 2001 From: junsongc Date: Wed, 6 Nov 2024 14:36:20 +0800 Subject: [PATCH 082/141] first update for SanaPipeline; --- src/diffusers/pipelines/sana/pipeline_sana.py | 14 ++------------ 1 file changed, 2 insertions(+), 12 deletions(-) diff --git a/src/diffusers/pipelines/sana/pipeline_sana.py b/src/diffusers/pipelines/sana/pipeline_sana.py index d94ecf486eb7..48be459f418b 100644 --- a/src/diffusers/pipelines/sana/pipeline_sana.py +++ b/src/diffusers/pipelines/sana/pipeline_sana.py @@ -22,7 +22,7 @@ from transformers import AutoModelForCausalLM, AutoTokenizer from ...image_processor import PixArtImageProcessor -from ...models import AutoencoderKL, SanaTransformer2DModel +from ...models import AutoencoderKL, SanaTransformer2DModel, DCAE_HF from ...schedulers import KarrasDiffusionSchedulers, FlowMatchEulerDiscreteScheduler from ...utils import ( BACKENDS_MAPPING, @@ -202,7 +202,7 @@ def __init__( self, tokenizer: AutoTokenizer, text_encoder: AutoModelForCausalLM, - vae: AutoencoderKL, + vae: DCAE_HF, transformer: SanaTransformer2DModel, scheduler: FlowMatchEulerDiscreteScheduler, ): @@ -286,16 +286,6 @@ def encode_prompt( return_tensors="pt", ) text_input_ids = text_inputs.input_ids - untruncated_ids = self.tokenizer(prompt, padding="longest", return_tensors="pt").input_ids - - if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal( - text_input_ids, untruncated_ids - ): - removed_text = self.tokenizer.batch_decode(untruncated_ids[:, max_length - 1 : -1]) - logger.warning( - "The following part of your input was truncated because T5 can only handle sequences up to" - f" {max_length} tokens: {removed_text}" - ) prompt_attention_mask = text_inputs.attention_mask prompt_attention_mask = prompt_attention_mask.to(device) From d2a681cb22cda9ca5e086ec1025e424415c44b3c Mon Sep 17 00:00:00 2001 From: junsong Date: Wed, 6 Nov 2024 00:53:04 -0800 Subject: [PATCH 083/141] first success run SanaPipeline; --- src/diffusers/__init__.py | 2 +- src/diffusers/models/__init__.py | 2 +- src/diffusers/models/transformers/__init__.py | 2 +- .../transformers/sana_transformer_2d.py | 90 +++++++++++++++---- src/diffusers/pipelines/sana/__init__.py | 2 +- src/diffusers/pipelines/sana/pipeline_sana.py | 28 +++--- 6 files changed, 90 insertions(+), 36 deletions(-) diff --git a/src/diffusers/__init__.py b/src/diffusers/__init__.py index 62b96ba0f9d4..2025540b8313 100644 --- a/src/diffusers/__init__.py +++ b/src/diffusers/__init__.py @@ -609,8 +609,8 @@ MultiAdapter, MultiControlNetModel, PixArtTransformer2DModel, - SanaTransformer2DModel, PriorTransformer, + SanaTransformer2DModel, SD3ControlNetModel, SD3MultiControlNetModel, SD3Transformer2DModel, diff --git a/src/diffusers/models/__init__.py b/src/diffusers/models/__init__.py index fe58a646a74c..0cba7ad27f0b 100644 --- a/src/diffusers/models/__init__.py +++ b/src/diffusers/models/__init__.py @@ -129,8 +129,8 @@ LuminaNextDiT2DModel, MochiTransformer3DModel, PixArtTransformer2DModel, - SanaTransformer2DModel, PriorTransformer, + SanaTransformer2DModel, SD3Transformer2DModel, StableAudioDiTModel, T5FilmDecoder, diff --git a/src/diffusers/models/transformers/__init__.py b/src/diffusers/models/transformers/__init__.py index 3e0db159265c..ce9b2424ab9d 100644 --- a/src/diffusers/models/transformers/__init__.py +++ b/src/diffusers/models/transformers/__init__.py @@ -11,6 +11,7 @@ from .lumina_nextdit2d import LuminaNextDiT2DModel from .pixart_transformer_2d import PixArtTransformer2DModel from .prior_transformer import PriorTransformer + from .sana_transformer_2d import SanaTransformer2DModel from .stable_audio_transformer import StableAudioDiTModel from .t5_film_transformer import T5FilmDecoder from .transformer_2d import Transformer2DModel @@ -20,4 +21,3 @@ from .transformer_mochi import MochiTransformer3DModel from .transformer_sd3 import SD3Transformer2DModel from .transformer_temporal import TransformerTemporalModel - from .sana_transformer_2d import SanaTransformer2DModel diff --git a/src/diffusers/models/transformers/sana_transformer_2d.py b/src/diffusers/models/transformers/sana_transformer_2d.py index 9fa549c8c3f8..cc0398bcc994 100644 --- a/src/diffusers/models/transformers/sana_transformer_2d.py +++ b/src/diffusers/models/transformers/sana_transformer_2d.py @@ -18,21 +18,73 @@ from ...configuration_utils import ConfigMixin, register_to_config from ...utils import is_torch_version, logging -from ..attention import BasicTransformerBlock, _chunked_feed_forward +from ...utils.torch_utils import maybe_allow_in_graph +from ..attention import _chunked_feed_forward from ..attention_processor import ( - Attention, AttentionProcessor, AttnProcessor, FusedAttnProcessor2_0, SanaLinearAttnProcessor2_0 + Attention, + AttentionProcessor, + AttnProcessor, + FusedAttnProcessor2_0, + SanaLinearAttnProcessor2_0, ) from ..autoencoders.dc_ae import GLUMBConv from ..embeddings import PatchEmbed, PixArtAlphaTextProjection, SinusoidalPositionalEmbedding from ..modeling_outputs import Transformer2DModelOutput from ..modeling_utils import ModelMixin from ..normalization import AdaLayerNormSingle -from ...utils.torch_utils import maybe_allow_in_graph logger = logging.get_logger(__name__) # pylint: disable=invalid-name +# Modified from diffusers.models.autoencoders.ecae.GLUMBConv +@maybe_allow_in_graph +class SanaGLUMBConv(GLUMBConv): + def __init__( + self, + in_channels: int, + out_channels: int, + kernel_size=3, + stride=1, + mid_channels=None, + expand_ratio=2.5, + use_bias=False, + norm=(None, None, None), + act_func=("silu", "silu", None), + ): + super().__init__( + in_channels=in_channels, + out_channels=out_channels, + kernel_size=kernel_size, + stride=stride, + mid_channels=mid_channels, + expand_ratio=expand_ratio, + use_bias=use_bias, + norm=norm, + act_func=act_func, + ) + + def forward(self, x: torch.Tensor, HW=None) -> torch.Tensor: + B, N, C = x.shape + if HW is None: + H = W = int(N**0.5) + else: + H, W = HW + + x = x.reshape(B, H, W, C).permute(0, 3, 1, 2) + x = self.inverted_conv(x) + x = self.depth_conv(x) + + x, gate = torch.chunk(x, 2, dim=1) + gate = self.glu_act(gate) + x = x * gate + + x = self.point_conv(x) + x = x.reshape(B, C, N).permute(0, 2, 1) + + return x + + # Modified from diffusers.models.attention.BasicTransformerBlock @maybe_allow_in_graph class SanaLinearTransformerBlock(nn.Module): @@ -65,9 +117,10 @@ def __init__( norm_eps: float = 1e-5, attention_out_bias: bool = True, use_pe: bool = False, + num_positional_embeddings: Optional[int] = None, expand_ratio: float = 2.5, ff_bias: tuple =(True, True, False), - norm=(None, None, None), + ff_norm: tuple =(None, None, None), ): super().__init__() self.dim = dim @@ -118,12 +171,12 @@ def __init__( processor=AttnProcessor(), ) - self.ff = GLUMBConv( + self.ff = SanaGLUMBConv( in_channels=dim, out_channels=dim, expand_ratio=expand_ratio, use_bias=ff_bias, - norm=norm, + norm=ff_norm, act_func=activation_fn, ) @@ -167,6 +220,8 @@ def forward( if self.pos_embed is not None: norm_hidden_states = self.pos_embed(norm_hidden_states) + cross_attention_kwargs = cross_attention_kwargs.copy() if cross_attention_kwargs is not None else {} + attn_output = self.attn1( norm_hidden_states, encoder_hidden_states=None, @@ -253,8 +308,6 @@ class SanaTransformer2DModel(ModelMixin, ConfigMixin): attention_type (str, optional, defaults to "default"): Kind of attention mechanism to be used. caption_channels (int, optional, defaults to None): Number of channels to use for projecting the caption embeddings. - use_linear_projection (bool, optional, defaults to False): - Deprecated argument. Will be removed in a future version. num_vector_embeds (bool, optional, defaults to False): Deprecated argument. Will be removed in a future version. """ @@ -265,18 +318,18 @@ class SanaTransformer2DModel(ModelMixin, ConfigMixin): @register_to_config def __init__( self, - num_attention_heads: int = 16, - attention_head_dim: int = 72, - in_channels: int = 4, - out_channels: Optional[int] = 8, + num_attention_heads: int = 32, + attention_head_dim: int = 36, + in_channels: int = 32, + out_channels: Optional[int] = 32, num_layers: int = 28, dropout: float = 0.0, norm_num_groups: int = 32, cross_attention_dim: Optional[int] = 1152, attention_bias: bool = True, - sample_size: int = 128, - patch_size: int = 2, - activation_fn: str = "gelu-approximate", + sample_size: int = 32, + patch_size: int = 1, + activation_fn: tuple = ("silu", "silu", None), num_embeds_ada_norm: Optional[int] = 1000, upcast_attention: bool = False, norm_type: str = "ada_norm_single", @@ -287,6 +340,9 @@ def __init__( caption_channels: Optional[int] = None, attention_type: Optional[str] = "default", use_pe: Optional[bool] = False, + expand_ratio=2.5, + ff_bias: tuple =(True, True, False), + ff_norm: tuple =(None, None, None), ): super().__init__() @@ -348,7 +404,9 @@ def __init__( norm_type=norm_type, norm_elementwise_affine=self.config.norm_elementwise_affine, norm_eps=self.config.norm_eps, - attention_type=self.config.attention_type, + expand_ratio=self.config.expand_ratio, + ff_bias=self.config.ff_bias, + ff_norm=self.config.ff_norm, ) for _ in range(self.config.num_layers) ] diff --git a/src/diffusers/pipelines/sana/__init__.py b/src/diffusers/pipelines/sana/__init__.py index b0130b2ab566..0cbbcb048120 100644 --- a/src/diffusers/pipelines/sana/__init__.py +++ b/src/diffusers/pipelines/sana/__init__.py @@ -33,11 +33,11 @@ from ...utils.dummy_torch_and_transformers_objects import * else: from .pipeline_sana import ( - SanaPipeline, ASPECT_RATIO_256_BIN, ASPECT_RATIO_512_BIN, ASPECT_RATIO_1024_BIN, ASPECT_RATIO_2048_BIN, + SanaPipeline, ) else: import sys diff --git a/src/diffusers/pipelines/sana/pipeline_sana.py b/src/diffusers/pipelines/sana/pipeline_sana.py index 48be459f418b..84b709b29a22 100644 --- a/src/diffusers/pipelines/sana/pipeline_sana.py +++ b/src/diffusers/pipelines/sana/pipeline_sana.py @@ -22,8 +22,8 @@ from transformers import AutoModelForCausalLM, AutoTokenizer from ...image_processor import PixArtImageProcessor -from ...models import AutoencoderKL, SanaTransformer2DModel, DCAE_HF -from ...schedulers import KarrasDiffusionSchedulers, FlowMatchEulerDiscreteScheduler +from ...models import DCAE_HF, SanaTransformer2DModel +from ...schedulers import FlowMatchEulerDiscreteScheduler from ...utils import ( BACKENDS_MAPPING, deprecate, @@ -35,7 +35,6 @@ from ...utils.torch_utils import randn_tensor from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput from ..pixart_alpha.pipeline_pixart_alpha import ( - ASPECT_RATIO_256_BIN, ASPECT_RATIO_512_BIN, ASPECT_RATIO_1024_BIN, ) @@ -212,7 +211,7 @@ def __init__( tokenizer=tokenizer, text_encoder=text_encoder, vae=vae, transformer=transformer, scheduler=scheduler ) - self.vae_scale_factor = 2 ** (len(self.vae.config.block_out_channels) - 1) + self.vae_scale_factor = 2 ** (len(self.vae.config.encoder_width_list) - 1) self.image_processor = PixArtImageProcessor(vae_scale_factor=self.vae_scale_factor) # Copied from diffusers.pipelines.pixart_alpha.pipeline_pixart_alpha.PixArtAlphaPipeline.encode_prompt with 120->300 @@ -293,10 +292,10 @@ def encode_prompt( prompt_embeds = self.text_encoder(text_input_ids.to(device), attention_mask=prompt_attention_mask) prompt_embeds = prompt_embeds[0] - if self.text_encoder is not None: - dtype = self.text_encoder.dtype - elif self.transformer is not None: + if self.transformer is not None: dtype = self.transformer.dtype + elif self.text_encoder is not None: + dtype = self.text_encoder.dtype else: dtype = None @@ -593,8 +592,6 @@ def prepare_latents(self, batch_size, num_channels_latents, height, width, dtype else: latents = latents.to(device) - # scale the initial noise by the standard deviation required by the scheduler - latents = latents * self.scheduler.init_noise_sigma return latents @torch.no_grad() @@ -711,14 +708,12 @@ def __call__( height = height or self.transformer.config.sample_size * self.vae_scale_factor width = width or self.transformer.config.sample_size * self.vae_scale_factor if use_resolution_binning: - if self.transformer.config.sample_size == 256: + if self.transformer.config.sample_size == 64: aspect_ratio_bin = ASPECT_RATIO_2048_BIN - elif self.transformer.config.sample_size == 128: + elif self.transformer.config.sample_size == 32: aspect_ratio_bin = ASPECT_RATIO_1024_BIN - elif self.transformer.config.sample_size == 64: + elif self.transformer.config.sample_size == 16: aspect_ratio_bin = ASPECT_RATIO_512_BIN - elif self.transformer.config.sample_size == 32: - aspect_ratio_bin = ASPECT_RATIO_256_BIN else: raise ValueError("Invalid sample size") orig_height, orig_width = height, width @@ -804,7 +799,6 @@ def __call__( with self.progress_bar(total=num_inference_steps) as progress_bar: for i, t in enumerate(timesteps): latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents - latent_model_input = self.scheduler.scale_model_input(latent_model_input, t) current_timestep = t if not torch.is_tensor(current_timestep): @@ -853,7 +847,9 @@ def __call__( callback(step_idx, t, latents) if not output_type == "latent": - image = self.vae.decode(latents / self.vae.config.scaling_factor, return_dict=False)[0] + # image = self.vae.decode(latents / self.vae.config.scaling_factor, return_dict=False)[0] + # Temporary for DCAE_HF(the not ready version) + image = self.vae.decode(latents / self.vae.config.scaling_factor) if use_resolution_binning: image = self.image_processor.resize_and_crop_tensor(image, orig_width, orig_height) else: From cb2e566bbd9d9d31ce0a1b6448a01bcc0a12098b Mon Sep 17 00:00:00 2001 From: junsong Date: Wed, 6 Nov 2024 11:48:31 -0800 Subject: [PATCH 084/141] model output finally match with original model with the same intput; --- sana.py | 199 +++++++++++++++++- src/diffusers/models/attention_processor.py | 68 ++---- .../transformers/sana_transformer_2d.py | 89 ++++++-- src/diffusers/pipelines/sana/pipeline_sana.py | 5 + 4 files changed, 291 insertions(+), 70 deletions(-) diff --git a/sana.py b/sana.py index db33ef1915fe..6314281d00a1 100644 --- a/sana.py +++ b/sana.py @@ -1,14 +1,201 @@ -from diffusers import DCAE, DCAE_HF -from diffusers import SanaPipeline +import torch +from app.sana_pipeline import SanaPipeline -# vae = DCAE() -dc_ae = DCAE_HF.from_pretrained(f"mit-han-lab/dc-ae-f32c32-sana-1.0") -print(dc_ae) +from diffusers import SanaTransformer2DModel -# pipe = Sana() +import torch +from app.sana_pipeline import ( + SanaPipeline, classify_height_width_bin, prepare_prompt_ar, DPMS, resize_and_crop_tensor, + vae_decode, guidance_type_select +) +from torchvision.utils import save_image +class SanaPipelineDiffuser(SanaPipeline): + def __init__(self, config: str | None = "configs/sana_config/1024ms/Sana_1600M_img1024.yaml"): + super().__init__(config) + self.model = SanaTransformer2DModel.from_pretrained( + "output/Sana_1600M_1024px_diffusers", + subfolder="transformer", + torch_dtype=torch.float16, + use_safetensors=True, + ).to(device) + @torch.inference_mode() + def forward( + self, + prompt=None, + height=1024, + width=1024, + negative_prompt="", + num_inference_steps=20, + guidance_scale=5, + pag_guidance_scale=1., + num_images_per_prompt=1, + generator=torch.Generator().manual_seed(42), + latent=None, + ): + self.ori_height, self.ori_width = height, width + self.height, self.width = classify_height_width_bin(height, width, ratios=self.base_ratios) + self.latent_size_h, self.latent_size_w = ( + self.height // self.config.vae.vae_downsample_rate, + self.width // self.config.vae.vae_downsample_rate, + ) + self.guidance_type = guidance_type_select(self.guidance_type, pag_guidance_scale, self.config.model.attn_type) + # 1. pre-compute negative embedding + if negative_prompt != "": + null_caption_token = self.tokenizer( + negative_prompt, + max_length=self.max_sequence_length, + padding="max_length", + truncation=True, + return_tensors="pt", + ).to(self.device) + self.null_caption_embs = self.text_encoder(null_caption_token.input_ids, null_caption_token.attention_mask)[ + 0 + ] + if prompt is None: + prompt = [""] + prompts = prompt if isinstance(prompt, list) else [prompt] + samples = [] + + for prompt in prompts: + # data prepare + prompts, hw, ar = ( + [], + torch.tensor([[self.image_size, self.image_size]], dtype=torch.float, device=self.device).repeat( + num_images_per_prompt, 1 + ), + torch.tensor([[1.0]], device=self.device).repeat(num_images_per_prompt, 1), + ) + for _ in range(num_images_per_prompt): + prompts.append(prepare_prompt_ar(prompt, self.base_ratios, device=self.device, show=False)[0].strip()) + + # prepare text feature + if not self.config.text_encoder.chi_prompt: + max_length_all = self.config.text_encoder.model_max_length + prompts_all = prompts + else: + chi_prompt = "\n".join(self.config.text_encoder.chi_prompt) + prompts_all = [chi_prompt + prompt for prompt in prompts] + num_chi_prompt_tokens = len(self.tokenizer.encode(chi_prompt)) + max_length_all = ( + num_chi_prompt_tokens + self.config.text_encoder.model_max_length - 2 + ) # magic number 2: [bos], [_] + + caption_token = self.tokenizer( + prompts_all, max_length=max_length_all, padding="max_length", truncation=True, return_tensors="pt" + ).to(self.device) + select_index = [0] + list(range(-self.config.text_encoder.model_max_length + 1, 0)) + caption_embs = self.text_encoder(caption_token.input_ids, caption_token.attention_mask)[0][:, None][ + :, :, select_index + ].to(dtype) + print(1111111111, select_index) + emb_masks = caption_token.attention_mask[:, select_index] + null_y = self.null_caption_embs.repeat(len(prompts), 1, 1)[:, None].to(dtype) + + # start sampling + with torch.no_grad(): + n = len(prompts) + if latent is None: + z = torch.randn( + n, + self.config.vae.vae_latent_dim, + self.latent_size_h, + self.latent_size_w, + generator=generator, + device=self.device, + dtype=self.weight_dtype, + ) + else: + z = latent.to(self.weight_dtype).to(device) + print(z.mean(), z.std()) + model_kwargs = dict(data_info={"img_hw": hw, "aspect_ratio": ar}, mask=emb_masks) + scheduler = DPMS( + self.model.forward, + condition=caption_embs, + uncondition=null_y, + guidance_type=self.guidance_type, + cfg_scale=guidance_scale, + pag_scale=pag_guidance_scale, + pag_applied_layers=self.config.model.pag_applied_layers, + model_type="flow", + model_kwargs=model_kwargs, + schedule="FLOW", + ) + scheduler.register_progress_bar(self.progress_fn) + sample = scheduler.sample( + z, + steps=num_inference_steps, + order=2, + skip_type="time_uniform_flow", + method="multistep", + flow_shift=self.flow_shift, + ) + + sample = sample.to(self.weight_dtype) + sample = vae_decode(self.config.vae.vae_type, self.vae, sample) + sample = resize_and_crop_tensor(sample, self.ori_width, self.ori_height) + samples.append(sample) + + return sample + + return samples + + +if __name__ == "__main__": + import argparse + + parser = argparse.ArgumentParser() + + parser.add_argument("--selfmodel", action="store_true", help="save all the pipelien elemets in one.") + + args = parser.parse_args() + + device = "cuda" if torch.cuda.is_available() else "cpu" + dtype = torch.float16 + prompt = 'a cyberpunk cat with a neon sign that says "Sana"' + generator = torch.Generator(device=device).manual_seed(42) + + latent = torch.randn( + 1, + 32, + 32, + 32, + generator=generator, + device=device, + ) + # diffusers Sana Model + pipe_diffuser = SanaPipelineDiffuser() + + image = pipe_diffuser( + prompt=prompt, + height=1024, + width=1024, + guidance_scale=5.0, + pag_guidance_scale=1.0, + num_inference_steps=18, + generator=generator, + latent=latent, + ) + save_image(image, 'sana_diffusers.png', nrow=1, normalize=True, value_range=(-1, 1)) + + # self implementation + # sana = SanaPipeline("configs/sana_config/1024ms/Sana_1600M_img1024.yaml") + # sana.from_pretrained("hf://Efficient-Large-Model/Sana_1600M_1024px/checkpoints/Sana_1600M_1024px.pth") + + # image = sana( + # prompt=prompt, + # height=1024, + # width=1024, + # guidance_scale=5.0, + # pag_guidance_scale=1.0, + # num_inference_steps=18, + # generator=generator, + # latent=latent, + # ) + + # save_image(image, 'sana_self.png', nrow=1, normalize=True, value_range=(-1, 1)) diff --git a/src/diffusers/models/attention_processor.py b/src/diffusers/models/attention_processor.py index 67a84dd36d7a..6ba738f20595 100644 --- a/src/diffusers/models/attention_processor.py +++ b/src/diffusers/models/attention_processor.py @@ -5228,15 +5228,6 @@ def __call__( hidden_states.shape if encoder_hidden_states is None else encoder_hidden_states.shape ) - if attention_mask is not None: - attention_mask = attn.prepare_attention_mask(attention_mask, sequence_length, batch_size) - # scaled_dot_product_attention expects attention_mask shape to be - # (batch, heads, source_length, target_length) - attention_mask = attention_mask.view(batch_size, attn.heads, -1, attention_mask.shape[-1]) - - if attn.group_norm is not None: - hidden_states = attn.group_norm(hidden_states.transpose(1, 2)).transpose(1, 2) - query = attn.to_q(hidden_states) if encoder_hidden_states is None: @@ -5250,55 +5241,28 @@ def __call__( inner_dim = key.shape[-1] head_dim = inner_dim // attn.heads - if encoder_hidden_states is None: - dtype = query.dtype - - query = query.view(batch_size, attn.heads, head_dim, -1).transpose(1, 2) - - key = key.view(batch_size, attn.heads, head_dim, -1).transpose(1, 2) - value = value.view(batch_size, attn.heads, head_dim, -1).transpose(1, 2) - - query = self.kernel_func(query) # B, h, h_d, N - key = self.kernel_func(key) - - if attn.norm_q is not None: - query = attn.norm_q(query) - if attn.norm_k is not None: - key = attn.norm_k(key) - - # need torch.float - query, key, value = query.float(), key.float(), value.float() - - value = F.pad(value, (0, 0, 0, 1), mode="constant", value=self.pad_val) - vk = torch.matmul(value, key) - hidden_states = torch.matmul(vk, query).to(dtype) - - if hidden_states.dtype in [torch.float16, torch.bfloat16]: - hidden_states = hidden_states.float() - hidden_states = hidden_states[:, :, :-1] / (hidden_states[:, :, -1:] + self.eps) + dtype = query.dtype - hidden_states = hidden_states.view(batch_size, attn.heads * head_dim, -1).permute(0, 2, 1) - hidden_states = hidden_states.to(dtype) + query = query.transpose(-1, -2).reshape(batch_size, attn.heads, head_dim, -1) + key = key.transpose(-1, -2).reshape(batch_size, attn.heads, head_dim, -1).transpose(-1, -2) + value = value.transpose(-1, -2).reshape(batch_size, attn.heads, head_dim, -1) - else: - query = query.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2) + query = self.kernel_func(query) # B, h, h_d, N + key = self.kernel_func(key) - key = key.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2) - value = value.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2) + # need torch.float + query, key, value = query.float(), key.float(), value.float() - if attn.norm_q is not None: - query = attn.norm_q(query) - if attn.norm_k is not None: - key = attn.norm_k(key) + value = F.pad(value, (0, 0, 0, 1), mode="constant", value=self.pad_val) + vk = torch.matmul(value, key) + hidden_states = torch.matmul(vk, query) - # the output of sdp = (batch, num_heads, seq_len, head_dim) - # TODO: add support for attn.scale when we move to Torch 2.1 - hidden_states = F.scaled_dot_product_attention( - query, key, value, attn_mask=attention_mask, dropout_p=0.0, is_causal=False - ) + if hidden_states.dtype in [torch.float16, torch.bfloat16]: + hidden_states = hidden_states.float() + hidden_states = hidden_states[:, :, :-1] / (hidden_states[:, :, -1:] + self.eps) - hidden_states = hidden_states.transpose(1, 2).reshape(batch_size, -1, attn.heads * head_dim) - hidden_states = hidden_states.to(query.dtype) + hidden_states = hidden_states.view(batch_size, attn.heads * head_dim, -1).permute(0, 2, 1) + hidden_states = hidden_states.to(dtype) # linear proj hidden_states = attn.to_out[0](hidden_states) diff --git a/src/diffusers/models/transformers/sana_transformer_2d.py b/src/diffusers/models/transformers/sana_transformer_2d.py index cc0398bcc994..5eb201b7c4ca 100644 --- a/src/diffusers/models/transformers/sana_transformer_2d.py +++ b/src/diffusers/models/transformers/sana_transformer_2d.py @@ -23,7 +23,7 @@ from ..attention_processor import ( Attention, AttentionProcessor, - AttnProcessor, + AttnProcessor2_0, FusedAttnProcessor2_0, SanaLinearAttnProcessor2_0, ) @@ -31,12 +31,19 @@ from ..embeddings import PatchEmbed, PixArtAlphaTextProjection, SinusoidalPositionalEmbedding from ..modeling_outputs import Transformer2DModelOutput from ..modeling_utils import ModelMixin -from ..normalization import AdaLayerNormSingle +from ..normalization import AdaLayerNormSingle, RMSNorm logger = logging.get_logger(__name__) # pylint: disable=invalid-name +@maybe_allow_in_graph +class RMSNormScaled(RMSNorm): + def __init__(self, dim, eps: float, elementwise_affine: bool = True, scale_factor: float = 1.0): + super().__init__(dim, eps, elementwise_affine) + self.weight = nn.Parameter(torch.ones(dim) * scale_factor) + + # Modified from diffusers.models.autoencoders.ecae.GLUMBConv @maybe_allow_in_graph class SanaGLUMBConv(GLUMBConv): @@ -107,6 +114,8 @@ def __init__( num_attention_heads: int, attention_head_dim: int, dropout=0.0, + num_cross_attention_heads: Optional[int] = None, + cross_attention_head_dim: Optional[int] = None, cross_attention_dim: Optional[int] = None, activation_fn: tuple = ("silu", "silu", None), num_embeds_ada_norm: Optional[int] = None, @@ -114,7 +123,7 @@ def __init__( upcast_attention: bool = False, norm_type: str = "ada_norm_single", norm_elementwise_affine: bool = False, - norm_eps: float = 1e-5, + norm_eps: float = 1e-6, attention_out_bias: bool = True, use_pe: bool = False, num_positional_embeddings: Optional[int] = None, @@ -162,13 +171,13 @@ def __init__( self.attn2 = Attention( query_dim=dim, cross_attention_dim=cross_attention_dim, - heads=num_attention_heads, - dim_head=attention_head_dim, + heads=num_cross_attention_heads, + dim_head=cross_attention_head_dim, dropout=dropout, - bias=attention_bias, + bias=True, upcast_attention=upcast_attention, out_bias=attention_out_bias, - processor=AttnProcessor(), + processor=AttnProcessor2_0(), ) self.ff = SanaGLUMBConv( @@ -250,13 +259,18 @@ def forward( hidden_states = attn_output + hidden_states # 4. Feed-forward + if self.norm_type == "ada_norm_single": + norm_hidden_states = self.norm2(hidden_states) + norm_hidden_states = norm_hidden_states * (1 + scale_mlp) + shift_mlp + if self._chunk_size is not None: # "feed_forward_chunk_size" can be used to save memory ff_output = _chunked_feed_forward(self.ff, norm_hidden_states, self._chunk_dim, self._chunk_size) else: ff_output = self.ff(norm_hidden_states) - ff_output = gate_mlp * ff_output + if self.norm_type == "ada_norm_single": + ff_output = gate_mlp * ff_output hidden_states = ff_output + hidden_states if hidden_states.ndim == 4: @@ -325,6 +339,8 @@ def __init__( num_layers: int = 28, dropout: float = 0.0, norm_num_groups: int = 32, + num_cross_attention_heads: Optional[int] = 20, + cross_attention_head_dim: Optional[int] = 112, cross_attention_dim: Optional[int] = 1152, attention_bias: bool = True, sample_size: int = 32, @@ -338,6 +354,8 @@ def __init__( interpolation_scale: Optional[int] = None, use_additional_conditions: Optional[bool] = None, caption_channels: Optional[int] = None, + use_caption_norm: Optional[bool] = True, + caption_norm_scale_factor: Optional[float] = 0.1, attention_type: Optional[str] = "default", use_pe: Optional[bool] = False, expand_ratio=2.5, @@ -378,7 +396,6 @@ def __init__( if self.config.interpolation_scale is not None else max(self.config.sample_size // 64, 1) ) - self.use_pe = use_pe self.pos_embed = PatchEmbed( height=self.config.sample_size, width=self.config.sample_size, @@ -386,7 +403,7 @@ def __init__( in_channels=self.config.in_channels, embed_dim=self.inner_dim, interpolation_scale=interpolation_scale, - pos_embed_type="sincos" if use_pe else None + pos_embed_type="sincos" if self.config.use_pe else None ) self.transformer_blocks = nn.ModuleList( @@ -396,6 +413,8 @@ def __init__( self.config.num_attention_heads, self.config.attention_head_dim, dropout=self.config.dropout, + num_cross_attention_heads=self.config.num_cross_attention_heads, + cross_attention_head_dim=self.config.cross_attention_head_dim, cross_attention_dim=self.config.cross_attention_dim, activation_fn=self.config.activation_fn, num_embeds_ada_norm=self.config.num_embeds_ada_norm, @@ -404,6 +423,7 @@ def __init__( norm_type=norm_type, norm_elementwise_affine=self.config.norm_elementwise_affine, norm_eps=self.config.norm_eps, + use_pe=self.config.use_pe, expand_ratio=self.config.expand_ratio, ff_bias=self.config.ff_bias, ff_norm=self.config.ff_norm, @@ -425,6 +445,9 @@ def __init__( self.caption_projection = PixArtAlphaTextProjection( in_features=self.config.caption_channels, hidden_size=self.inner_dim ) + self.caption_norm = None + if self.config.use_caption_norm: + self.caption_norm = RMSNormScaled(self.inner_dim, eps=1e-5, scale_factor=caption_norm_scale_factor) def _set_gradient_checkpointing(self, module, value=False): if hasattr(module, "gradient_checkpointing"): @@ -533,13 +556,14 @@ def unfuse_qkv_projections(self): def forward( self, hidden_states: torch.Tensor, - encoder_hidden_states: Optional[torch.Tensor] = None, timestep: Optional[torch.LongTensor] = None, + encoder_hidden_states: Optional[torch.Tensor] = None, + encoder_attention_mask: Optional[torch.Tensor] = None, added_cond_kwargs: Dict[str, torch.Tensor] = None, cross_attention_kwargs: Dict[str, Any] = None, attention_mask: Optional[torch.Tensor] = None, - encoder_attention_mask: Optional[torch.Tensor] = None, return_dict: bool = True, + **kwargs, ): """ The [`PixArtTransformer2DModel`] forward method. @@ -618,6 +642,8 @@ def forward( if self.caption_projection is not None: encoder_hidden_states = self.caption_projection(encoder_hidden_states) encoder_hidden_states = encoder_hidden_states.view(batch_size, -1, hidden_states.shape[-1]) + if self.caption_norm is not None: + encoder_hidden_states = self.caption_norm(encoder_hidden_states) # 2. Blocks for block in self.transformer_blocks: @@ -677,3 +703,42 @@ def custom_forward(*inputs): return (output,) return Transformer2DModelOutput(sample=output) + + +if __name__ == "__main__": + import torch + + device = "cuda" if torch.cuda.is_available() else "cpu" + dtype = torch.float16 + + transformer = SanaTransformer2DModel.from_pretrained( + "/home/junsongc/junsongc/code/diffusion/Sana/output/Sana_1600M_1024px_diffusers", + subfolder="transformer", + torch_dtype=torch.float16, + use_safetensors=True, + ).to(device) + + torch.manual_seed(0) + torch.set_grad_enabled(False) + + latent_model_input = torch.randn(2, 32, 32, 32).to(device).to(dtype) + prompt_embeds = torch.randn(2, 300, 2304).to(device).to(dtype) + prompt_attention_mask = torch.ones((2, 300)).to(device) + current_timestep = torch.tensor([1000, 1000]).to(device) + added_cond_kwargs={} + + print(latent_model_input.mean(), latent_model_input.std()) + print(prompt_embeds.mean(), prompt_embeds.std()) + + # predict noise model_output + noise_pred = transformer( + latent_model_input, + encoder_hidden_states=prompt_embeds, + encoder_attention_mask=prompt_attention_mask, + timestep=current_timestep, + added_cond_kwargs=added_cond_kwargs, + return_dict=False, + )[0] + + print(noise_pred.shape, noise_pred.mean(), noise_pred.std()) + diff --git a/src/diffusers/pipelines/sana/pipeline_sana.py b/src/diffusers/pipelines/sana/pipeline_sana.py index 84b709b29a22..2ecb1b395903 100644 --- a/src/diffusers/pipelines/sana/pipeline_sana.py +++ b/src/diffusers/pipelines/sana/pipeline_sana.py @@ -816,6 +816,11 @@ def __call__( current_timestep = current_timestep.expand(latent_model_input.shape[0]) # predict noise model_output + print(latent_model_input.shape) + print(prompt_embeds.shape) + print(prompt_attention_mask.shape) + print(current_timestep.shape) + print(added_cond_kwargs) noise_pred = self.transformer( latent_model_input, encoder_hidden_states=prompt_embeds, From c238717dfe1afba435a7cb5b3eb1888ba2d83467 Mon Sep 17 00:00:00 2001 From: junsong Date: Wed, 6 Nov 2024 22:21:31 -0800 Subject: [PATCH 085/141] code update; --- .../transformers/sana_transformer_2d.py | 39 ------------------- src/diffusers/pipelines/sana/pipeline_sana.py | 5 --- 2 files changed, 44 deletions(-) diff --git a/src/diffusers/models/transformers/sana_transformer_2d.py b/src/diffusers/models/transformers/sana_transformer_2d.py index 5eb201b7c4ca..2ba68d5eba33 100644 --- a/src/diffusers/models/transformers/sana_transformer_2d.py +++ b/src/diffusers/models/transformers/sana_transformer_2d.py @@ -703,42 +703,3 @@ def custom_forward(*inputs): return (output,) return Transformer2DModelOutput(sample=output) - - -if __name__ == "__main__": - import torch - - device = "cuda" if torch.cuda.is_available() else "cpu" - dtype = torch.float16 - - transformer = SanaTransformer2DModel.from_pretrained( - "/home/junsongc/junsongc/code/diffusion/Sana/output/Sana_1600M_1024px_diffusers", - subfolder="transformer", - torch_dtype=torch.float16, - use_safetensors=True, - ).to(device) - - torch.manual_seed(0) - torch.set_grad_enabled(False) - - latent_model_input = torch.randn(2, 32, 32, 32).to(device).to(dtype) - prompt_embeds = torch.randn(2, 300, 2304).to(device).to(dtype) - prompt_attention_mask = torch.ones((2, 300)).to(device) - current_timestep = torch.tensor([1000, 1000]).to(device) - added_cond_kwargs={} - - print(latent_model_input.mean(), latent_model_input.std()) - print(prompt_embeds.mean(), prompt_embeds.std()) - - # predict noise model_output - noise_pred = transformer( - latent_model_input, - encoder_hidden_states=prompt_embeds, - encoder_attention_mask=prompt_attention_mask, - timestep=current_timestep, - added_cond_kwargs=added_cond_kwargs, - return_dict=False, - )[0] - - print(noise_pred.shape, noise_pred.mean(), noise_pred.std()) - diff --git a/src/diffusers/pipelines/sana/pipeline_sana.py b/src/diffusers/pipelines/sana/pipeline_sana.py index 2ecb1b395903..84b709b29a22 100644 --- a/src/diffusers/pipelines/sana/pipeline_sana.py +++ b/src/diffusers/pipelines/sana/pipeline_sana.py @@ -816,11 +816,6 @@ def __call__( current_timestep = current_timestep.expand(latent_model_input.shape[0]) # predict noise model_output - print(latent_model_input.shape) - print(prompt_embeds.shape) - print(prompt_attention_mask.shape) - print(current_timestep.shape) - print(added_cond_kwargs) noise_pred = self.transformer( latent_model_input, encoder_hidden_states=prompt_embeds, From 406abb4dd3b1ac638c9697a0cb2dad351617062f Mon Sep 17 00:00:00 2001 From: junsong Date: Thu, 7 Nov 2024 00:50:01 -0800 Subject: [PATCH 086/141] code update; --- src/diffusers/pipelines/sana/pipeline_sana.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/diffusers/pipelines/sana/pipeline_sana.py b/src/diffusers/pipelines/sana/pipeline_sana.py index 84b709b29a22..d82893ad7221 100644 --- a/src/diffusers/pipelines/sana/pipeline_sana.py +++ b/src/diffusers/pipelines/sana/pipeline_sana.py @@ -849,7 +849,7 @@ def __call__( if not output_type == "latent": # image = self.vae.decode(latents / self.vae.config.scaling_factor, return_dict=False)[0] # Temporary for DCAE_HF(the not ready version) - image = self.vae.decode(latents / self.vae.config.scaling_factor) + image = self.vae.decode(latents.to(self.vae.dtype) / self.vae.config.scaling_factor) if use_resolution_binning: image = self.image_processor.resize_and_crop_tensor(image, orig_width, orig_height) else: From cfc844e96a32a22b97f655225881d9d5a43e0964 Mon Sep 17 00:00:00 2001 From: junsong Date: Mon, 11 Nov 2024 05:29:56 -0800 Subject: [PATCH 087/141] add a flow dpm-solver scripts --- .../scheduling_dpmsolver_multistep_flow.py | 1175 +++++++++++++++++ 1 file changed, 1175 insertions(+) create mode 100644 src/diffusers/schedulers/scheduling_dpmsolver_multistep_flow.py diff --git a/src/diffusers/schedulers/scheduling_dpmsolver_multistep_flow.py b/src/diffusers/schedulers/scheduling_dpmsolver_multistep_flow.py new file mode 100644 index 000000000000..be639bcb5da5 --- /dev/null +++ b/src/diffusers/schedulers/scheduling_dpmsolver_multistep_flow.py @@ -0,0 +1,1175 @@ +# Copyright 2024 TSAIL Team and The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# DISCLAIMER: This file is strongly influenced by https://github.com/LuChengTHU/dpm-solver + +import math +from typing import List, Optional, Tuple, Union + +import numpy as np +import torch + +from ..configuration_utils import ConfigMixin, register_to_config +from ..utils import deprecate, is_scipy_available +from ..utils.torch_utils import randn_tensor +from .scheduling_utils import KarrasDiffusionSchedulers, SchedulerMixin, SchedulerOutput + + +if is_scipy_available(): + import scipy.stats + + +# Copied from diffusers.schedulers.scheduling_ddpm.betas_for_alpha_bar +def betas_for_alpha_bar( + num_diffusion_timesteps, + max_beta=0.999, + alpha_transform_type="cosine", +): + """ + Create a beta schedule that discretizes the given alpha_t_bar function, which defines the cumulative product of + (1-beta) over time from t = [0,1]. + + Contains a function alpha_bar that takes an argument t and transforms it to the cumulative product of (1-beta) up + to that part of the diffusion process. + + + Args: + num_diffusion_timesteps (`int`): the number of betas to produce. + max_beta (`float`): the maximum beta to use; use values lower than 1 to + prevent singularities. + alpha_transform_type (`str`, *optional*, default to `cosine`): the type of noise schedule for alpha_bar. + Choose from `cosine` or `exp` + + Returns: + betas (`np.ndarray`): the betas used by the scheduler to step the model outputs + """ + if alpha_transform_type == "cosine": + + def alpha_bar_fn(t): + return math.cos((t + 0.008) / 1.008 * math.pi / 2) ** 2 + + elif alpha_transform_type == "exp": + + def alpha_bar_fn(t): + return math.exp(t * -12.0) + + else: + raise ValueError(f"Unsupported alpha_transform_type: {alpha_transform_type}") + + betas = [] + for i in range(num_diffusion_timesteps): + t1 = i / num_diffusion_timesteps + t2 = (i + 1) / num_diffusion_timesteps + betas.append(min(1 - alpha_bar_fn(t2) / alpha_bar_fn(t1), max_beta)) + return torch.tensor(betas, dtype=torch.float32) + + +# Copied from diffusers.schedulers.scheduling_ddim.rescale_zero_terminal_snr +def rescale_zero_terminal_snr(betas): + """ + Rescales betas to have zero terminal SNR Based on https://arxiv.org/pdf/2305.08891.pdf (Algorithm 1) + + + Args: + betas (`torch.Tensor`): + the betas that the scheduler is being initialized with. + + Returns: + `torch.Tensor`: rescaled betas with zero terminal SNR + """ + # Convert betas to alphas_bar_sqrt + alphas = 1.0 - betas + alphas_cumprod = torch.cumprod(alphas, dim=0) + alphas_bar_sqrt = alphas_cumprod.sqrt() + + # Store old values. + alphas_bar_sqrt_0 = alphas_bar_sqrt[0].clone() + alphas_bar_sqrt_T = alphas_bar_sqrt[-1].clone() + + # Shift so the last timestep is zero. + alphas_bar_sqrt -= alphas_bar_sqrt_T + + # Scale so the first timestep is back to the old value. + alphas_bar_sqrt *= alphas_bar_sqrt_0 / (alphas_bar_sqrt_0 - alphas_bar_sqrt_T) + + # Convert alphas_bar_sqrt to betas + alphas_bar = alphas_bar_sqrt**2 # Revert sqrt + alphas = alphas_bar[1:] / alphas_bar[:-1] # Revert cumprod + alphas = torch.cat([alphas_bar[0:1], alphas]) + betas = 1 - alphas + + return betas + + +class DPMSolverMultistepScheduler(SchedulerMixin, ConfigMixin): + """ + `DPMSolverMultistepScheduler` is a fast dedicated high-order solver for diffusion ODEs. + + This model inherits from [`SchedulerMixin`] and [`ConfigMixin`]. Check the superclass documentation for the generic + methods the library implements for all schedulers such as loading and saving. + + Args: + num_train_timesteps (`int`, defaults to 1000): + The number of diffusion steps to train the model. + beta_start (`float`, defaults to 0.0001): + The starting `beta` value of inference. + beta_end (`float`, defaults to 0.02): + The final `beta` value. + beta_schedule (`str`, defaults to `"linear"`): + The beta schedule, a mapping from a beta range to a sequence of betas for stepping the model. Choose from + `linear`, `scaled_linear`, or `squaredcos_cap_v2`. + trained_betas (`np.ndarray`, *optional*): + Pass an array of betas directly to the constructor to bypass `beta_start` and `beta_end`. + solver_order (`int`, defaults to 2): + The DPMSolver order which can be `1` or `2` or `3`. It is recommended to use `solver_order=2` for guided + sampling, and `solver_order=3` for unconditional sampling. + prediction_type (`str`, defaults to `epsilon`, *optional*): + Prediction type of the scheduler function; can be `epsilon` (predicts the noise of the diffusion process), + `sample` (directly predicts the noisy sample`) or `v_prediction` (see section 2.4 of [Imagen + Video](https://imagen.research.google/video/paper.pdf) paper). + thresholding (`bool`, defaults to `False`): + Whether to use the "dynamic thresholding" method. This is unsuitable for latent-space diffusion models such + as Stable Diffusion. + dynamic_thresholding_ratio (`float`, defaults to 0.995): + The ratio for the dynamic thresholding method. Valid only when `thresholding=True`. + sample_max_value (`float`, defaults to 1.0): + The threshold value for dynamic thresholding. Valid only when `thresholding=True` and + `algorithm_type="dpmsolver++"`. + algorithm_type (`str`, defaults to `dpmsolver++`): + Algorithm type for the solver; can be `dpmsolver`, `dpmsolver++`, `sde-dpmsolver` or `sde-dpmsolver++`. The + `dpmsolver` type implements the algorithms in the [DPMSolver](https://huggingface.co/papers/2206.00927) + paper, and the `dpmsolver++` type implements the algorithms in the + [DPMSolver++](https://huggingface.co/papers/2211.01095) paper. It is recommended to use `dpmsolver++` or + `sde-dpmsolver++` with `solver_order=2` for guided sampling like in Stable Diffusion. + solver_type (`str`, defaults to `midpoint`): + Solver type for the second-order solver; can be `midpoint` or `heun`. The solver type slightly affects the + sample quality, especially for a small number of steps. It is recommended to use `midpoint` solvers. + lower_order_final (`bool`, defaults to `True`): + Whether to use lower-order solvers in the final steps. Only valid for < 15 inference steps. This can + stabilize the sampling of DPMSolver for steps < 15, especially for steps <= 10. + euler_at_final (`bool`, defaults to `False`): + Whether to use Euler's method in the final step. It is a trade-off between numerical stability and detail + richness. This can stabilize the sampling of the SDE variant of DPMSolver for small number of inference + steps, but sometimes may result in blurring. + use_karras_sigmas (`bool`, *optional*, defaults to `False`): + Whether to use Karras sigmas for step sizes in the noise schedule during the sampling process. If `True`, + the sigmas are determined according to a sequence of noise levels {σi}. + use_exponential_sigmas (`bool`, *optional*, defaults to `False`): + Whether to use exponential sigmas for step sizes in the noise schedule during the sampling process. + use_beta_sigmas (`bool`, *optional*, defaults to `False`): + Whether to use beta sigmas for step sizes in the noise schedule during the sampling process. Refer to [Beta + Sampling is All You Need](https://huggingface.co/papers/2407.12173) for more information. + use_lu_lambdas (`bool`, *optional*, defaults to `False`): + Whether to use the uniform-logSNR for step sizes proposed by Lu's DPM-Solver in the noise schedule during + the sampling process. If `True`, the sigmas and time steps are determined according to a sequence of + `lambda(t)`. + final_sigmas_type (`str`, defaults to `"zero"`): + The final `sigma` value for the noise schedule during the sampling process. If `"sigma_min"`, the final + sigma is the same as the last sigma in the training schedule. If `zero`, the final sigma is set to 0. + lambda_min_clipped (`float`, defaults to `-inf`): + Clipping threshold for the minimum value of `lambda(t)` for numerical stability. This is critical for the + cosine (`squaredcos_cap_v2`) noise schedule. + variance_type (`str`, *optional*): + Set to "learned" or "learned_range" for diffusion models that predict variance. If set, the model's output + contains the predicted Gaussian variance. + timestep_spacing (`str`, defaults to `"linspace"`): + The way the timesteps should be scaled. Refer to Table 2 of the [Common Diffusion Noise Schedules and + Sample Steps are Flawed](https://huggingface.co/papers/2305.08891) for more information. + steps_offset (`int`, defaults to 0): + An offset added to the inference steps, as required by some model families. + rescale_betas_zero_snr (`bool`, defaults to `False`): + Whether to rescale the betas to have zero terminal SNR. This enables the model to generate very bright and + dark samples instead of limiting it to samples with medium brightness. Loosely related to + [`--offset_noise`](https://github.com/huggingface/diffusers/blob/74fd735eb073eb1d774b1ab4154a0876eb82f055/examples/dreambooth/train_dreambooth.py#L506). + """ + + _compatibles = [e.name for e in KarrasDiffusionSchedulers] + order = 1 + + @register_to_config + def __init__( + self, + num_train_timesteps: int = 1000, + beta_start: float = 0.0001, + beta_end: float = 0.02, + beta_schedule: str = "linear", + trained_betas: Optional[Union[np.ndarray, List[float]]] = None, + solver_order: int = 2, + prediction_type: str = "epsilon", + thresholding: bool = False, + dynamic_thresholding_ratio: float = 0.995, + sample_max_value: float = 1.0, + algorithm_type: str = "dpmsolver++", + solver_type: str = "midpoint", + lower_order_final: bool = True, + euler_at_final: bool = False, + use_karras_sigmas: Optional[bool] = False, + use_exponential_sigmas: Optional[bool] = False, + use_beta_sigmas: Optional[bool] = False, + use_lu_lambdas: Optional[bool] = False, + use_flow_sigmas: Optional[bool] = False, + flow_shift: Optional[float] = 1.0, + final_sigmas_type: Optional[str] = "zero", # "zero", "sigma_min" + lambda_min_clipped: float = -float("inf"), + variance_type: Optional[str] = None, + timestep_spacing: str = "linspace", + steps_offset: int = 0, + rescale_betas_zero_snr: bool = False, + ): + if self.config.use_beta_sigmas and not is_scipy_available(): + raise ImportError("Make sure to install scipy if you want to use beta sigmas.") + if sum([self.config.use_beta_sigmas, self.config.use_exponential_sigmas, self.config.use_karras_sigmas]) > 1: + raise ValueError( + "Only one of `config.use_beta_sigmas`, `config.use_exponential_sigmas`, `config.use_karras_sigmas` can be used." + ) + if algorithm_type in ["dpmsolver", "sde-dpmsolver"]: + deprecation_message = f"algorithm_type {algorithm_type} is deprecated and will be removed in a future version. Choose from `dpmsolver++` or `sde-dpmsolver++` instead" + deprecate("algorithm_types dpmsolver and sde-dpmsolver", "1.0.0", deprecation_message) + + if trained_betas is not None: + self.betas = torch.tensor(trained_betas, dtype=torch.float32) + elif beta_schedule == "linear": + self.betas = torch.linspace(beta_start, beta_end, num_train_timesteps, dtype=torch.float32) + elif beta_schedule == "scaled_linear": + # this schedule is very specific to the latent diffusion model. + self.betas = torch.linspace(beta_start**0.5, beta_end**0.5, num_train_timesteps, dtype=torch.float32) ** 2 + elif beta_schedule == "squaredcos_cap_v2": + # Glide cosine schedule + self.betas = betas_for_alpha_bar(num_train_timesteps) + else: + raise NotImplementedError(f"{beta_schedule} is not implemented for {self.__class__}") + + if rescale_betas_zero_snr: + self.betas = rescale_zero_terminal_snr(self.betas) + + self.alphas = 1.0 - self.betas + self.alphas_cumprod = torch.cumprod(self.alphas, dim=0) + + if rescale_betas_zero_snr: + # Close to 0 without being 0 so first sigma is not inf + # FP16 smallest positive subnormal works well here + self.alphas_cumprod[-1] = 2**-24 + + # Currently we only support VP-type noise schedule + self.alpha_t = torch.sqrt(self.alphas_cumprod) + self.sigma_t = torch.sqrt(1 - self.alphas_cumprod) + self.lambda_t = torch.log(self.alpha_t) - torch.log(self.sigma_t) + self.sigmas = ((1 - self.alphas_cumprod) / self.alphas_cumprod) ** 0.5 + + # standard deviation of the initial noise distribution + self.init_noise_sigma = 1.0 + + # settings for DPM-Solver + if algorithm_type not in ["dpmsolver", "dpmsolver++", "sde-dpmsolver", "sde-dpmsolver++"]: + if algorithm_type == "deis": + self.register_to_config(algorithm_type="dpmsolver++") + else: + raise NotImplementedError(f"{algorithm_type} is not implemented for {self.__class__}") + + if solver_type not in ["midpoint", "heun"]: + if solver_type in ["logrho", "bh1", "bh2"]: + self.register_to_config(solver_type="midpoint") + else: + raise NotImplementedError(f"{solver_type} is not implemented for {self.__class__}") + + if algorithm_type not in ["dpmsolver++", "sde-dpmsolver++"] and final_sigmas_type == "zero": + raise ValueError( + f"`final_sigmas_type` {final_sigmas_type} is not supported for `algorithm_type` {algorithm_type}. Please choose `sigma_min` instead." + ) + + # setable values + self.num_inference_steps = None + timesteps = np.linspace(0, num_train_timesteps - 1, num_train_timesteps, dtype=np.float32)[::-1].copy() + self.timesteps = torch.from_numpy(timesteps) + self.model_outputs = [None] * solver_order + self.lower_order_nums = 0 + self._step_index = None + self._begin_index = None + self.sigmas = self.sigmas.to("cpu") # to avoid too much CPU/GPU communication + + @property + def step_index(self): + """ + The index counter for current timestep. It will increase 1 after each scheduler step. + """ + return self._step_index + + @property + def begin_index(self): + """ + The index for the first timestep. It should be set from pipeline with `set_begin_index` method. + """ + return self._begin_index + + def set_begin_index(self, begin_index: int = 0): + """ + Sets the begin index for the scheduler. This function should be run from pipeline before the inference. + + Args: + begin_index (`int`): + The begin index for the scheduler. + """ + self._begin_index = begin_index + + def set_timesteps( + self, + num_inference_steps: int = None, + device: Union[str, torch.device] = None, + timesteps: Optional[List[int]] = None, + ): + """ + Sets the discrete timesteps used for the diffusion chain (to be run before inference). + + Args: + num_inference_steps (`int`): + The number of diffusion steps used when generating samples with a pre-trained model. + device (`str` or `torch.device`, *optional*): + The device to which the timesteps should be moved to. If `None`, the timesteps are not moved. + timesteps (`List[int]`, *optional*): + Custom timesteps used to support arbitrary timesteps schedule. If `None`, timesteps will be generated + based on the `timestep_spacing` attribute. If `timesteps` is passed, `num_inference_steps` and `sigmas` + must be `None`, and `timestep_spacing` attribute will be ignored. + """ + if num_inference_steps is None and timesteps is None: + raise ValueError("Must pass exactly one of `num_inference_steps` or `timesteps`.") + if num_inference_steps is not None and timesteps is not None: + raise ValueError("Can only pass one of `num_inference_steps` or `custom_timesteps`.") + if timesteps is not None and self.config.use_karras_sigmas: + raise ValueError("Cannot use `timesteps` with `config.use_karras_sigmas = True`") + if timesteps is not None and self.config.use_lu_lambdas: + raise ValueError("Cannot use `timesteps` with `config.use_lu_lambdas = True`") + if timesteps is not None and self.config.use_exponential_sigmas: + raise ValueError("Cannot set `timesteps` with `config.use_exponential_sigmas = True`.") + if timesteps is not None and self.config.use_beta_sigmas: + raise ValueError("Cannot set `timesteps` with `config.use_beta_sigmas = True`.") + + if timesteps is not None: + timesteps = np.array(timesteps).astype(np.int64) + else: + # Clipping the minimum of all lambda(t) for numerical stability. + # This is critical for cosine (squaredcos_cap_v2) noise schedule. + clipped_idx = torch.searchsorted(torch.flip(self.lambda_t, [0]), self.config.lambda_min_clipped) + last_timestep = ((self.config.num_train_timesteps - clipped_idx).numpy()).item() + + # "linspace", "leading", "trailing" corresponds to annotation of Table 2. of https://arxiv.org/abs/2305.08891 + if self.config.timestep_spacing == "linspace": + timesteps = ( + np.linspace(0, last_timestep - 1, num_inference_steps + 1) + .round()[::-1][:-1] + .copy() + .astype(np.int64) + ) + elif self.config.timestep_spacing == "leading": + step_ratio = last_timestep // (num_inference_steps + 1) + # creates integer timesteps by multiplying by ratio + # casting to int to avoid issues when num_inference_step is power of 3 + timesteps = ( + (np.arange(0, num_inference_steps + 1) * step_ratio).round()[::-1][:-1].copy().astype(np.int64) + ) + timesteps += self.config.steps_offset + elif self.config.timestep_spacing == "trailing": + step_ratio = self.config.num_train_timesteps / num_inference_steps + # creates integer timesteps by multiplying by ratio + # casting to int to avoid issues when num_inference_step is power of 3 + timesteps = np.arange(last_timestep, 0, -step_ratio).round().copy().astype(np.int64) + timesteps -= 1 + else: + raise ValueError( + f"{self.config.timestep_spacing} is not supported. Please make sure to choose one of 'linspace', 'leading' or 'trailing'." + ) + + sigmas = np.array(((1 - self.alphas_cumprod) / self.alphas_cumprod) ** 0.5) + log_sigmas = np.log(sigmas) + + if self.config.use_karras_sigmas: + sigmas = np.flip(sigmas).copy() + sigmas = self._convert_to_karras(in_sigmas=sigmas, num_inference_steps=num_inference_steps) + timesteps = np.array([self._sigma_to_t(sigma, log_sigmas) for sigma in sigmas]).round() + elif self.config.use_lu_lambdas: + lambdas = np.flip(log_sigmas.copy()) + lambdas = self._convert_to_lu(in_lambdas=lambdas, num_inference_steps=num_inference_steps) + sigmas = np.exp(lambdas) + timesteps = np.array([self._sigma_to_t(sigma, log_sigmas) for sigma in sigmas]).round() + elif self.config.use_exponential_sigmas: + sigmas = self._convert_to_exponential(in_sigmas=sigmas, num_inference_steps=self.num_inference_steps) + timesteps = np.array([self._sigma_to_t(sigma, log_sigmas) for sigma in sigmas]) + elif self.config.use_beta_sigmas: + sigmas = self._convert_to_beta(in_sigmas=sigmas, num_inference_steps=self.num_inference_steps) + timesteps = np.array([self._sigma_to_t(sigma, log_sigmas) for sigma in sigmas]) + elif self.config.use_flow_sigmas: + sigmas = self._convert_to_flow(in_sigmas=sigmas, num_inference_steps=self.num_inference_steps, shift=self.config.timestep_shift) + timesteps = sigmas + else: + sigmas = np.interp(timesteps, np.arange(0, len(sigmas)), sigmas) + + if self.config.final_sigmas_type == "sigma_min": + sigma_last = ((1 - self.alphas_cumprod[0]) / self.alphas_cumprod[0]) ** 0.5 + elif self.config.final_sigmas_type == "zero": + sigma_last = 0 + else: + raise ValueError( + f"`final_sigmas_type` must be one of 'zero', or 'sigma_min', but got {self.config.final_sigmas_type}" + ) + + sigmas = np.concatenate([sigmas, [sigma_last]]).astype(np.float32) + + self.sigmas = torch.from_numpy(sigmas) + self.timesteps = torch.from_numpy(timesteps).to(device=device, dtype=torch.int64) + + self.num_inference_steps = len(timesteps) + + self.model_outputs = [ + None, + ] * self.config.solver_order + self.lower_order_nums = 0 + + # add an index counter for schedulers that allow duplicated timesteps + self._step_index = None + self._begin_index = None + self.sigmas = self.sigmas.to("cpu") # to avoid too much CPU/GPU communication + + # Copied from diffusers.schedulers.scheduling_ddpm.DDPMScheduler._threshold_sample + def _threshold_sample(self, sample: torch.Tensor) -> torch.Tensor: + """ + "Dynamic thresholding: At each sampling step we set s to a certain percentile absolute pixel value in xt0 (the + prediction of x_0 at timestep t), and if s > 1, then we threshold xt0 to the range [-s, s] and then divide by + s. Dynamic thresholding pushes saturated pixels (those near -1 and 1) inwards, thereby actively preventing + pixels from saturation at each step. We find that dynamic thresholding results in significantly better + photorealism as well as better image-text alignment, especially when using very large guidance weights." + + https://arxiv.org/abs/2205.11487 + """ + dtype = sample.dtype + batch_size, channels, *remaining_dims = sample.shape + + if dtype not in (torch.float32, torch.float64): + sample = sample.float() # upcast for quantile calculation, and clamp not implemented for cpu half + + # Flatten sample for doing quantile calculation along each image + sample = sample.reshape(batch_size, channels * np.prod(remaining_dims)) + + abs_sample = sample.abs() # "a certain percentile absolute pixel value" + + s = torch.quantile(abs_sample, self.config.dynamic_thresholding_ratio, dim=1) + s = torch.clamp( + s, min=1, max=self.config.sample_max_value + ) # When clamped to min=1, equivalent to standard clipping to [-1, 1] + s = s.unsqueeze(1) # (batch_size, 1) because clamp will broadcast along dim=0 + sample = torch.clamp(sample, -s, s) / s # "we threshold xt0 to the range [-s, s] and then divide by s" + + sample = sample.reshape(batch_size, channels, *remaining_dims) + sample = sample.to(dtype) + + return sample + + # Copied from diffusers.schedulers.scheduling_euler_discrete.EulerDiscreteScheduler._sigma_to_t + def _sigma_to_t(self, sigma, log_sigmas): + # get log sigma + log_sigma = np.log(np.maximum(sigma, 1e-10)) + + # get distribution + dists = log_sigma - log_sigmas[:, np.newaxis] + + # get sigmas range + low_idx = np.cumsum((dists >= 0), axis=0).argmax(axis=0).clip(max=log_sigmas.shape[0] - 2) + high_idx = low_idx + 1 + + low = log_sigmas[low_idx] + high = log_sigmas[high_idx] + + # interpolate sigmas + w = (low - log_sigma) / (low - high) + w = np.clip(w, 0, 1) + + # transform interpolation to time range + t = (1 - w) * low_idx + w * high_idx + t = t.reshape(sigma.shape) + return t + + def _sigma_to_alpha_sigma_t(self, sigma): + if self.config.prediction_type == "flow_prediction": + alpha_t = 1 - sigma + sigma_t = sigma + else: + alpha_t = 1 / ((sigma**2 + 1) ** 0.5) + sigma_t = sigma * alpha_t + + return alpha_t, sigma_t + # Copied from diffusers.schedulers.scheduling_euler_discrete.EulerDiscreteScheduler._convert_to_karras + def _convert_to_karras(self, in_sigmas: torch.Tensor, num_inference_steps) -> torch.Tensor: + """Constructs the noise schedule of Karras et al. (2022).""" + + # Hack to make sure that other schedulers which copy this function don't break + # TODO: Add this logic to the other schedulers + if hasattr(self.config, "sigma_min"): + sigma_min = self.config.sigma_min + else: + sigma_min = None + + if hasattr(self.config, "sigma_max"): + sigma_max = self.config.sigma_max + else: + sigma_max = None + + sigma_min = sigma_min if sigma_min is not None else in_sigmas[-1].item() + sigma_max = sigma_max if sigma_max is not None else in_sigmas[0].item() + + rho = 7.0 # 7.0 is the value used in the paper + ramp = np.linspace(0, 1, num_inference_steps) + min_inv_rho = sigma_min ** (1 / rho) + max_inv_rho = sigma_max ** (1 / rho) + sigmas = (max_inv_rho + ramp * (min_inv_rho - max_inv_rho)) ** rho + return sigmas + + def _convert_to_lu(self, in_lambdas: torch.Tensor, num_inference_steps) -> torch.Tensor: + """Constructs the noise schedule of Lu et al. (2022).""" + + lambda_min: float = in_lambdas[-1].item() + lambda_max: float = in_lambdas[0].item() + + rho = 1.0 # 1.0 is the value used in the paper + ramp = np.linspace(0, 1, num_inference_steps) + min_inv_rho = lambda_min ** (1 / rho) + max_inv_rho = lambda_max ** (1 / rho) + lambdas = (max_inv_rho + ramp * (min_inv_rho - max_inv_rho)) ** rho + return lambdas + + # Copied from diffusers.schedulers.scheduling_euler_discrete.EulerDiscreteScheduler._convert_to_exponential + def _convert_to_exponential(self, in_sigmas: torch.Tensor, num_inference_steps: int) -> torch.Tensor: + """Constructs an exponential noise schedule.""" + + # Hack to make sure that other schedulers which copy this function don't break + # TODO: Add this logic to the other schedulers + if hasattr(self.config, "sigma_min"): + sigma_min = self.config.sigma_min + else: + sigma_min = None + + if hasattr(self.config, "sigma_max"): + sigma_max = self.config.sigma_max + else: + sigma_max = None + + sigma_min = sigma_min if sigma_min is not None else in_sigmas[-1].item() + sigma_max = sigma_max if sigma_max is not None else in_sigmas[0].item() + + sigmas = torch.linspace(math.log(sigma_max), math.log(sigma_min), num_inference_steps).exp() + return sigmas + + # Copied from diffusers.schedulers.scheduling_euler_discrete.EulerDiscreteScheduler._convert_to_beta + def _convert_to_beta( + self, in_sigmas: torch.Tensor, num_inference_steps: int, alpha: float = 0.6, beta: float = 0.6 + ) -> torch.Tensor: + """From "Beta Sampling is All You Need" [arXiv:2407.12173] (Lee et. al, 2024)""" + + # Hack to make sure that other schedulers which copy this function don't break + # TODO: Add this logic to the other schedulers + if hasattr(self.config, "sigma_min"): + sigma_min = self.config.sigma_min + else: + sigma_min = None + + if hasattr(self.config, "sigma_max"): + sigma_max = self.config.sigma_max + else: + sigma_max = None + + sigma_min = sigma_min if sigma_min is not None else in_sigmas[-1].item() + sigma_max = sigma_max if sigma_max is not None else in_sigmas[0].item() + + sigmas = torch.Tensor( + [ + sigma_min + (ppf * (sigma_max - sigma_min)) + for ppf in [ + scipy.stats.beta.ppf(timestep, alpha, beta) + for timestep in 1 - np.linspace(0, 1, num_inference_steps) + ] + ] + ) + return sigmas + + def _convert_to_flow(self, in_sigmas: torch.Tensor, num_inference_steps, shift: float = 1.0) -> torch.Tensor: + if hasattr(self.config, "sigma_min"): + sigma_min = self.config.sigma_min + else: + sigma_min = None + + if hasattr(self.config, "sigma_max"): + sigma_max = self.config.sigma_max + else: + sigma_max = None + + sigma_min = sigma_min if sigma_min is not None else in_sigmas[-1].item() + sigma_max = sigma_max if sigma_max is not None else in_sigmas[0].item() + + N = num_inference_steps + + betas = torch.linspace(sigma_min, sigma_max, N + 1).to(in_sigmas.device) + sigmas = 1.0 - betas + sigmas = (shift * sigmas / (1 + (shift - 1) * sigmas)).flip(dims=[0]) + return sigmas + + def convert_model_output( + self, + model_output: torch.Tensor, + *args, + sample: torch.Tensor = None, + **kwargs, + ) -> torch.Tensor: + """ + Convert the model output to the corresponding type the DPMSolver/DPMSolver++ algorithm needs. DPM-Solver is + designed to discretize an integral of the noise prediction model, and DPM-Solver++ is designed to discretize an + integral of the data prediction model. + + + + The algorithm and model type are decoupled. You can use either DPMSolver or DPMSolver++ for both noise + prediction and data prediction models. + + + + Args: + model_output (`torch.Tensor`): + The direct output from the learned diffusion model. + sample (`torch.Tensor`): + A current instance of a sample created by the diffusion process. + + Returns: + `torch.Tensor`: + The converted model output. + """ + timestep = args[0] if len(args) > 0 else kwargs.pop("timestep", None) + if sample is None: + if len(args) > 1: + sample = args[1] + else: + raise ValueError("missing `sample` as a required keyward argument") + if timestep is not None: + deprecate( + "timesteps", + "1.0.0", + "Passing `timesteps` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`", + ) + + # DPM-Solver++ needs to solve an integral of the data prediction model. + if self.config.algorithm_type in ["dpmsolver++", "sde-dpmsolver++"]: + if self.config.prediction_type == "epsilon": + # DPM-Solver and DPM-Solver++ only need the "mean" output. + if self.config.variance_type in ["learned", "learned_range"]: + model_output = model_output[:, :3] + sigma = self.sigmas[self.step_index] + alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma) + x0_pred = (sample - sigma_t * model_output) / alpha_t + elif self.config.prediction_type == "sample": + x0_pred = model_output + elif self.config.prediction_type == "v_prediction": + sigma = self.sigmas[self.step_index] + alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma) + x0_pred = alpha_t * sample - sigma_t * model_output + elif self.config.prediction_type == "flow_prediction": + sigma_t = self.sigmas[self.step_index] + # _, sigma_t = self._sigma_to_alpha_sigma_t(sigma) + sigma_t = sigma + # x0_pred = (sample - sigma_t * model_output) / alpha_t + x0_pred = sample - sigma_t * model_output + else: + raise ValueError( + f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`," + " `v_prediction`, or `flow_prediction` for the DPMSolverMultistepScheduler." + ) + + if self.config.thresholding: + x0_pred = self._threshold_sample(x0_pred) + + return x0_pred + + # DPM-Solver needs to solve an integral of the noise prediction model. + elif self.config.algorithm_type in ["dpmsolver", "sde-dpmsolver"]: + if self.config.prediction_type == "epsilon": + # DPM-Solver and DPM-Solver++ only need the "mean" output. + if self.config.variance_type in ["learned", "learned_range"]: + epsilon = model_output[:, :3] + else: + epsilon = model_output + elif self.config.prediction_type == "sample": + sigma = self.sigmas[self.step_index] + alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma) + epsilon = (sample - alpha_t * model_output) / sigma_t + elif self.config.prediction_type == "v_prediction": + sigma = self.sigmas[self.step_index] + alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma) + epsilon = alpha_t * model_output + sigma_t * sample + else: + raise ValueError( + f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`, or" + " `v_prediction` for the DPMSolverMultistepScheduler." + ) + + if self.config.thresholding: + sigma = self.sigmas[self.step_index] + alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma) + x0_pred = (sample - sigma_t * epsilon) / alpha_t + x0_pred = self._threshold_sample(x0_pred) + epsilon = (sample - alpha_t * x0_pred) / sigma_t + + return epsilon + + def dpm_solver_first_order_update( + self, + model_output: torch.Tensor, + *args, + sample: torch.Tensor = None, + noise: Optional[torch.Tensor] = None, + **kwargs, + ) -> torch.Tensor: + """ + One step for the first-order DPMSolver (equivalent to DDIM). + + Args: + model_output (`torch.Tensor`): + The direct output from the learned diffusion model. + sample (`torch.Tensor`): + A current instance of a sample created by the diffusion process. + + Returns: + `torch.Tensor`: + The sample tensor at the previous timestep. + """ + timestep = args[0] if len(args) > 0 else kwargs.pop("timestep", None) + prev_timestep = args[1] if len(args) > 1 else kwargs.pop("prev_timestep", None) + if sample is None: + if len(args) > 2: + sample = args[2] + else: + raise ValueError(" missing `sample` as a required keyward argument") + if timestep is not None: + deprecate( + "timesteps", + "1.0.0", + "Passing `timesteps` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`", + ) + + if prev_timestep is not None: + deprecate( + "prev_timestep", + "1.0.0", + "Passing `prev_timestep` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`", + ) + + sigma_t, sigma_s = self.sigmas[self.step_index + 1], self.sigmas[self.step_index] + alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma_t) + alpha_s, sigma_s = self._sigma_to_alpha_sigma_t(sigma_s) + lambda_t = torch.log(alpha_t) - torch.log(sigma_t) + lambda_s = torch.log(alpha_s) - torch.log(sigma_s) + + h = lambda_t - lambda_s + if self.config.algorithm_type == "dpmsolver++": + x_t = (sigma_t / sigma_s) * sample - (alpha_t * (torch.exp(-h) - 1.0)) * model_output + elif self.config.algorithm_type == "dpmsolver": + x_t = (alpha_t / alpha_s) * sample - (sigma_t * (torch.exp(h) - 1.0)) * model_output + elif self.config.algorithm_type == "sde-dpmsolver++": + assert noise is not None + x_t = ( + (sigma_t / sigma_s * torch.exp(-h)) * sample + + (alpha_t * (1 - torch.exp(-2.0 * h))) * model_output + + sigma_t * torch.sqrt(1.0 - torch.exp(-2 * h)) * noise + ) + elif self.config.algorithm_type == "sde-dpmsolver": + assert noise is not None + x_t = ( + (alpha_t / alpha_s) * sample + - 2.0 * (sigma_t * (torch.exp(h) - 1.0)) * model_output + + sigma_t * torch.sqrt(torch.exp(2 * h) - 1.0) * noise + ) + return x_t + + def multistep_dpm_solver_second_order_update( + self, + model_output_list: List[torch.Tensor], + *args, + sample: torch.Tensor = None, + noise: Optional[torch.Tensor] = None, + **kwargs, + ) -> torch.Tensor: + """ + One step for the second-order multistep DPMSolver. + + Args: + model_output_list (`List[torch.Tensor]`): + The direct outputs from learned diffusion model at current and latter timesteps. + sample (`torch.Tensor`): + A current instance of a sample created by the diffusion process. + + Returns: + `torch.Tensor`: + The sample tensor at the previous timestep. + """ + timestep_list = args[0] if len(args) > 0 else kwargs.pop("timestep_list", None) + prev_timestep = args[1] if len(args) > 1 else kwargs.pop("prev_timestep", None) + if sample is None: + if len(args) > 2: + sample = args[2] + else: + raise ValueError(" missing `sample` as a required keyward argument") + if timestep_list is not None: + deprecate( + "timestep_list", + "1.0.0", + "Passing `timestep_list` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`", + ) + + if prev_timestep is not None: + deprecate( + "prev_timestep", + "1.0.0", + "Passing `prev_timestep` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`", + ) + + sigma_t, sigma_s0, sigma_s1 = ( + self.sigmas[self.step_index + 1], + self.sigmas[self.step_index], + self.sigmas[self.step_index - 1], + ) + + alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma_t) + alpha_s0, sigma_s0 = self._sigma_to_alpha_sigma_t(sigma_s0) + alpha_s1, sigma_s1 = self._sigma_to_alpha_sigma_t(sigma_s1) + + lambda_t = torch.log(alpha_t) - torch.log(sigma_t) + lambda_s0 = torch.log(alpha_s0) - torch.log(sigma_s0) + lambda_s1 = torch.log(alpha_s1) - torch.log(sigma_s1) + + m0, m1 = model_output_list[-1], model_output_list[-2] + + h, h_0 = lambda_t - lambda_s0, lambda_s0 - lambda_s1 + r0 = h_0 / h + D0, D1 = m0, (1.0 / r0) * (m0 - m1) + if self.config.algorithm_type == "dpmsolver++": + # See https://arxiv.org/abs/2211.01095 for detailed derivations + if self.config.solver_type == "midpoint": + x_t = ( + (sigma_t / sigma_s0) * sample + - (alpha_t * (torch.exp(-h) - 1.0)) * D0 + - 0.5 * (alpha_t * (torch.exp(-h) - 1.0)) * D1 + ) + elif self.config.solver_type == "heun": + x_t = ( + (sigma_t / sigma_s0) * sample + - (alpha_t * (torch.exp(-h) - 1.0)) * D0 + + (alpha_t * ((torch.exp(-h) - 1.0) / h + 1.0)) * D1 + ) + elif self.config.algorithm_type == "dpmsolver": + # See https://arxiv.org/abs/2206.00927 for detailed derivations + if self.config.solver_type == "midpoint": + x_t = ( + (alpha_t / alpha_s0) * sample + - (sigma_t * (torch.exp(h) - 1.0)) * D0 + - 0.5 * (sigma_t * (torch.exp(h) - 1.0)) * D1 + ) + elif self.config.solver_type == "heun": + x_t = ( + (alpha_t / alpha_s0) * sample + - (sigma_t * (torch.exp(h) - 1.0)) * D0 + - (sigma_t * ((torch.exp(h) - 1.0) / h - 1.0)) * D1 + ) + elif self.config.algorithm_type == "sde-dpmsolver++": + assert noise is not None + if self.config.solver_type == "midpoint": + x_t = ( + (sigma_t / sigma_s0 * torch.exp(-h)) * sample + + (alpha_t * (1 - torch.exp(-2.0 * h))) * D0 + + 0.5 * (alpha_t * (1 - torch.exp(-2.0 * h))) * D1 + + sigma_t * torch.sqrt(1.0 - torch.exp(-2 * h)) * noise + ) + elif self.config.solver_type == "heun": + x_t = ( + (sigma_t / sigma_s0 * torch.exp(-h)) * sample + + (alpha_t * (1 - torch.exp(-2.0 * h))) * D0 + + (alpha_t * ((1.0 - torch.exp(-2.0 * h)) / (-2.0 * h) + 1.0)) * D1 + + sigma_t * torch.sqrt(1.0 - torch.exp(-2 * h)) * noise + ) + elif self.config.algorithm_type == "sde-dpmsolver": + assert noise is not None + if self.config.solver_type == "midpoint": + x_t = ( + (alpha_t / alpha_s0) * sample + - 2.0 * (sigma_t * (torch.exp(h) - 1.0)) * D0 + - (sigma_t * (torch.exp(h) - 1.0)) * D1 + + sigma_t * torch.sqrt(torch.exp(2 * h) - 1.0) * noise + ) + elif self.config.solver_type == "heun": + x_t = ( + (alpha_t / alpha_s0) * sample + - 2.0 * (sigma_t * (torch.exp(h) - 1.0)) * D0 + - 2.0 * (sigma_t * ((torch.exp(h) - 1.0) / h - 1.0)) * D1 + + sigma_t * torch.sqrt(torch.exp(2 * h) - 1.0) * noise + ) + return x_t + + def multistep_dpm_solver_third_order_update( + self, + model_output_list: List[torch.Tensor], + *args, + sample: torch.Tensor = None, + **kwargs, + ) -> torch.Tensor: + """ + One step for the third-order multistep DPMSolver. + + Args: + model_output_list (`List[torch.Tensor]`): + The direct outputs from learned diffusion model at current and latter timesteps. + sample (`torch.Tensor`): + A current instance of a sample created by diffusion process. + + Returns: + `torch.Tensor`: + The sample tensor at the previous timestep. + """ + + timestep_list = args[0] if len(args) > 0 else kwargs.pop("timestep_list", None) + prev_timestep = args[1] if len(args) > 1 else kwargs.pop("prev_timestep", None) + if sample is None: + if len(args) > 2: + sample = args[2] + else: + raise ValueError(" missing`sample` as a required keyward argument") + if timestep_list is not None: + deprecate( + "timestep_list", + "1.0.0", + "Passing `timestep_list` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`", + ) + + if prev_timestep is not None: + deprecate( + "prev_timestep", + "1.0.0", + "Passing `prev_timestep` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`", + ) + + sigma_t, sigma_s0, sigma_s1, sigma_s2 = ( + self.sigmas[self.step_index + 1], + self.sigmas[self.step_index], + self.sigmas[self.step_index - 1], + self.sigmas[self.step_index - 2], + ) + + alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma_t) + alpha_s0, sigma_s0 = self._sigma_to_alpha_sigma_t(sigma_s0) + alpha_s1, sigma_s1 = self._sigma_to_alpha_sigma_t(sigma_s1) + alpha_s2, sigma_s2 = self._sigma_to_alpha_sigma_t(sigma_s2) + + lambda_t = torch.log(alpha_t) - torch.log(sigma_t) + lambda_s0 = torch.log(alpha_s0) - torch.log(sigma_s0) + lambda_s1 = torch.log(alpha_s1) - torch.log(sigma_s1) + lambda_s2 = torch.log(alpha_s2) - torch.log(sigma_s2) + + m0, m1, m2 = model_output_list[-1], model_output_list[-2], model_output_list[-3] + + h, h_0, h_1 = lambda_t - lambda_s0, lambda_s0 - lambda_s1, lambda_s1 - lambda_s2 + r0, r1 = h_0 / h, h_1 / h + D0 = m0 + D1_0, D1_1 = (1.0 / r0) * (m0 - m1), (1.0 / r1) * (m1 - m2) + D1 = D1_0 + (r0 / (r0 + r1)) * (D1_0 - D1_1) + D2 = (1.0 / (r0 + r1)) * (D1_0 - D1_1) + if self.config.algorithm_type == "dpmsolver++": + # See https://arxiv.org/abs/2206.00927 for detailed derivations + x_t = ( + (sigma_t / sigma_s0) * sample + - (alpha_t * (torch.exp(-h) - 1.0)) * D0 + + (alpha_t * ((torch.exp(-h) - 1.0) / h + 1.0)) * D1 + - (alpha_t * ((torch.exp(-h) - 1.0 + h) / h**2 - 0.5)) * D2 + ) + elif self.config.algorithm_type == "dpmsolver": + # See https://arxiv.org/abs/2206.00927 for detailed derivations + x_t = ( + (alpha_t / alpha_s0) * sample + - (sigma_t * (torch.exp(h) - 1.0)) * D0 + - (sigma_t * ((torch.exp(h) - 1.0) / h - 1.0)) * D1 + - (sigma_t * ((torch.exp(h) - 1.0 - h) / h**2 - 0.5)) * D2 + ) + return x_t + + def index_for_timestep(self, timestep, schedule_timesteps=None): + if schedule_timesteps is None: + schedule_timesteps = self.timesteps + + index_candidates = (schedule_timesteps == timestep).nonzero() + + if len(index_candidates) == 0: + step_index = len(self.timesteps) - 1 + # The sigma index that is taken for the **very** first `step` + # is always the second index (or the last index if there is only 1) + # This way we can ensure we don't accidentally skip a sigma in + # case we start in the middle of the denoising schedule (e.g. for image-to-image) + elif len(index_candidates) > 1: + step_index = index_candidates[1].item() + else: + step_index = index_candidates[0].item() + + return step_index + + def _init_step_index(self, timestep): + """ + Initialize the step_index counter for the scheduler. + """ + + if self.begin_index is None: + if isinstance(timestep, torch.Tensor): + timestep = timestep.to(self.timesteps.device) + self._step_index = self.index_for_timestep(timestep) + else: + self._step_index = self._begin_index + + def step( + self, + model_output: torch.Tensor, + timestep: Union[int, torch.Tensor], + sample: torch.Tensor, + generator=None, + variance_noise: Optional[torch.Tensor] = None, + return_dict: bool = True, + ) -> Union[SchedulerOutput, Tuple]: + """ + Predict the sample from the previous timestep by reversing the SDE. This function propagates the sample with + the multistep DPMSolver. + + Args: + model_output (`torch.Tensor`): + The direct output from learned diffusion model. + timestep (`int`): + The current discrete timestep in the diffusion chain. + sample (`torch.Tensor`): + A current instance of a sample created by the diffusion process. + generator (`torch.Generator`, *optional*): + A random number generator. + variance_noise (`torch.Tensor`): + Alternative to generating noise with `generator` by directly providing the noise for the variance + itself. Useful for methods such as [`LEdits++`]. + return_dict (`bool`): + Whether or not to return a [`~schedulers.scheduling_utils.SchedulerOutput`] or `tuple`. + + Returns: + [`~schedulers.scheduling_utils.SchedulerOutput`] or `tuple`: + If return_dict is `True`, [`~schedulers.scheduling_utils.SchedulerOutput`] is returned, otherwise a + tuple is returned where the first element is the sample tensor. + + """ + if self.num_inference_steps is None: + raise ValueError( + "Number of inference steps is 'None', you need to run 'set_timesteps' after creating the scheduler" + ) + + if self.step_index is None: + self._init_step_index(timestep) + + # Improve numerical stability for small number of steps + lower_order_final = (self.step_index == len(self.timesteps) - 1) and ( + self.config.euler_at_final + or (self.config.lower_order_final and len(self.timesteps) < 15) + or self.config.final_sigmas_type == "zero" + ) + lower_order_second = ( + (self.step_index == len(self.timesteps) - 2) and self.config.lower_order_final and len(self.timesteps) < 15 + ) + + model_output = self.convert_model_output(model_output, sample=sample) + for i in range(self.config.solver_order - 1): + self.model_outputs[i] = self.model_outputs[i + 1] + self.model_outputs[-1] = model_output + + # Upcast to avoid precision issues when computing prev_sample + sample = sample.to(torch.float32) + if self.config.algorithm_type in ["sde-dpmsolver", "sde-dpmsolver++"] and variance_noise is None: + noise = randn_tensor( + model_output.shape, generator=generator, device=model_output.device, dtype=torch.float32 + ) + elif self.config.algorithm_type in ["sde-dpmsolver", "sde-dpmsolver++"]: + noise = variance_noise.to(device=model_output.device, dtype=torch.float32) + else: + noise = None + + if self.config.solver_order == 1 or self.lower_order_nums < 1 or lower_order_final: + prev_sample = self.dpm_solver_first_order_update(model_output, sample=sample, noise=noise) + elif self.config.solver_order == 2 or self.lower_order_nums < 2 or lower_order_second: + prev_sample = self.multistep_dpm_solver_second_order_update(self.model_outputs, sample=sample, noise=noise) + else: + prev_sample = self.multistep_dpm_solver_third_order_update(self.model_outputs, sample=sample) + + if self.lower_order_nums < self.config.solver_order: + self.lower_order_nums += 1 + + # Cast sample back to expected dtype + prev_sample = prev_sample.to(model_output.dtype) + + # upon completion increase step index by one + self._step_index += 1 + + if not return_dict: + return (prev_sample,) + + return SchedulerOutput(prev_sample=prev_sample) + + def scale_model_input(self, sample: torch.Tensor, *args, **kwargs) -> torch.Tensor: + """ + Ensures interchangeability with schedulers that need to scale the denoising model input depending on the + current timestep. + + Args: + sample (`torch.Tensor`): + The input sample. + + Returns: + `torch.Tensor`: + A scaled input sample. + """ + return sample + + def add_noise( + self, + original_samples: torch.Tensor, + noise: torch.Tensor, + timesteps: torch.IntTensor, + ) -> torch.Tensor: + # Make sure sigmas and timesteps have the same device and dtype as original_samples + sigmas = self.sigmas.to(device=original_samples.device, dtype=original_samples.dtype) + if original_samples.device.type == "mps" and torch.is_floating_point(timesteps): + # mps does not support float64 + schedule_timesteps = self.timesteps.to(original_samples.device, dtype=torch.float32) + timesteps = timesteps.to(original_samples.device, dtype=torch.float32) + else: + schedule_timesteps = self.timesteps.to(original_samples.device) + timesteps = timesteps.to(original_samples.device) + + # begin_index is None when the scheduler is used for training or pipeline does not implement set_begin_index + if self.begin_index is None: + step_indices = [self.index_for_timestep(t, schedule_timesteps) for t in timesteps] + elif self.step_index is not None: + # add_noise is called after first denoising step (for inpainting) + step_indices = [self.step_index] * timesteps.shape[0] + else: + # add noise is called before first denoising step to create initial latent(img2img) + step_indices = [self.begin_index] * timesteps.shape[0] + + sigma = sigmas[step_indices].flatten() + while len(sigma.shape) < len(original_samples.shape): + sigma = sigma.unsqueeze(-1) + + alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma) + noisy_samples = alpha_t * original_samples + sigma_t * noise + return noisy_samples + + def __len__(self): + return self.config.num_train_timesteps From b4e8e6375e45cc11a4e70d6689a18aec0c03d332 Mon Sep 17 00:00:00 2001 From: junsong Date: Tue, 12 Nov 2024 03:20:17 -0800 Subject: [PATCH 088/141] =?UTF-8?q?=F0=9F=8E=89[important=20update]=201.?= =?UTF-8?q?=20Integrate=20flow-dpm-sovler=20into=20diffusers;=202.=20final?= =?UTF-8?q?ly=20run=20successfully=20on=20both=20`FlowMatchEulerDiscreteSc?= =?UTF-8?q?heduler`=20and=20`FlowDPMSolverMultistepScheduler`;?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- sana.py | 206 ++----- src/diffusers/__init__.py | 2 + src/diffusers/pipelines/sana/pipeline_sana.py | 4 +- src/diffusers/schedulers/__init__.py | 2 + .../scheduling_dpmsolver_multistep.py | 22 +- .../scheduling_dpmsolver_multistep_flow.py | 529 +++--------------- 6 files changed, 140 insertions(+), 625 deletions(-) diff --git a/sana.py b/sana.py index 6314281d00a1..b7583207a8f2 100644 --- a/sana.py +++ b/sana.py @@ -1,149 +1,23 @@ import torch -from app.sana_pipeline import SanaPipeline - -from diffusers import SanaTransformer2DModel - -import torch -from app.sana_pipeline import ( - SanaPipeline, classify_height_width_bin, prepare_prompt_ar, DPMS, resize_and_crop_tensor, - vae_decode, guidance_type_select +from diffusers import ( + SanaTransformer2DModel, PixArtSigmaPipeline, SanaPipeline, + FlowDPMSolverMultistepScheduler, DPMSolverMultistepScheduler ) + from torchvision.utils import save_image -class SanaPipelineDiffuser(SanaPipeline): - def __init__(self, config: str | None = "configs/sana_config/1024ms/Sana_1600M_img1024.yaml"): - super().__init__(config) - self.model = SanaTransformer2DModel.from_pretrained( - "output/Sana_1600M_1024px_diffusers", - subfolder="transformer", - torch_dtype=torch.float16, - use_safetensors=True, - ).to(device) - - @torch.inference_mode() - def forward( - self, - prompt=None, - height=1024, - width=1024, - negative_prompt="", - num_inference_steps=20, - guidance_scale=5, - pag_guidance_scale=1., - num_images_per_prompt=1, - generator=torch.Generator().manual_seed(42), - latent=None, - ): - self.ori_height, self.ori_width = height, width - self.height, self.width = classify_height_width_bin(height, width, ratios=self.base_ratios) - self.latent_size_h, self.latent_size_w = ( - self.height // self.config.vae.vae_downsample_rate, - self.width // self.config.vae.vae_downsample_rate, - ) - self.guidance_type = guidance_type_select(self.guidance_type, pag_guidance_scale, self.config.model.attn_type) - - # 1. pre-compute negative embedding - if negative_prompt != "": - null_caption_token = self.tokenizer( - negative_prompt, - max_length=self.max_sequence_length, - padding="max_length", - truncation=True, - return_tensors="pt", - ).to(self.device) - self.null_caption_embs = self.text_encoder(null_caption_token.input_ids, null_caption_token.attention_mask)[ - 0 - ] - - if prompt is None: - prompt = [""] - prompts = prompt if isinstance(prompt, list) else [prompt] - samples = [] - - for prompt in prompts: - # data prepare - prompts, hw, ar = ( - [], - torch.tensor([[self.image_size, self.image_size]], dtype=torch.float, device=self.device).repeat( - num_images_per_prompt, 1 - ), - torch.tensor([[1.0]], device=self.device).repeat(num_images_per_prompt, 1), - ) - for _ in range(num_images_per_prompt): - prompts.append(prepare_prompt_ar(prompt, self.base_ratios, device=self.device, show=False)[0].strip()) - - # prepare text feature - if not self.config.text_encoder.chi_prompt: - max_length_all = self.config.text_encoder.model_max_length - prompts_all = prompts - else: - chi_prompt = "\n".join(self.config.text_encoder.chi_prompt) - prompts_all = [chi_prompt + prompt for prompt in prompts] - num_chi_prompt_tokens = len(self.tokenizer.encode(chi_prompt)) - max_length_all = ( - num_chi_prompt_tokens + self.config.text_encoder.model_max_length - 2 - ) # magic number 2: [bos], [_] - - caption_token = self.tokenizer( - prompts_all, max_length=max_length_all, padding="max_length", truncation=True, return_tensors="pt" - ).to(self.device) - select_index = [0] + list(range(-self.config.text_encoder.model_max_length + 1, 0)) - caption_embs = self.text_encoder(caption_token.input_ids, caption_token.attention_mask)[0][:, None][ - :, :, select_index - ].to(dtype) - print(1111111111, select_index) - emb_masks = caption_token.attention_mask[:, select_index] - null_y = self.null_caption_embs.repeat(len(prompts), 1, 1)[:, None].to(dtype) - - # start sampling - with torch.no_grad(): - n = len(prompts) - if latent is None: - z = torch.randn( - n, - self.config.vae.vae_latent_dim, - self.latent_size_h, - self.latent_size_w, - generator=generator, - device=self.device, - dtype=self.weight_dtype, - ) - else: - z = latent.to(self.weight_dtype).to(device) - print(z.mean(), z.std()) - model_kwargs = dict(data_info={"img_hw": hw, "aspect_ratio": ar}, mask=emb_masks) - scheduler = DPMS( - self.model.forward, - condition=caption_embs, - uncondition=null_y, - guidance_type=self.guidance_type, - cfg_scale=guidance_scale, - pag_scale=pag_guidance_scale, - pag_applied_layers=self.config.model.pag_applied_layers, - model_type="flow", - model_kwargs=model_kwargs, - schedule="FLOW", - ) - scheduler.register_progress_bar(self.progress_fn) - sample = scheduler.sample( - z, - steps=num_inference_steps, - order=2, - skip_type="time_uniform_flow", - method="multistep", - flow_shift=self.flow_shift, - ) - - sample = sample.to(self.weight_dtype) - sample = vae_decode(self.config.vae.vae_type, self.vae, sample) - sample = resize_and_crop_tensor(sample, self.ori_width, self.ori_height) - samples.append(sample) - - return sample - - return samples + +def run_pixart_sigam(): + pipe = PixArtSigmaPipeline.from_pretrained( + "PixArt-alpha/PixArt-Sigma-XL-2-1024-MS", + torch_dtype=torch.float16, + use_safetensors=True + ).to(device) + + + image = pipe("a dog").images[0] if __name__ == "__main__": @@ -151,8 +25,6 @@ def forward( parser = argparse.ArgumentParser() - parser.add_argument("--selfmodel", action="store_true", help="save all the pipelien elemets in one.") - args = parser.parse_args() device = "cuda" if torch.cuda.is_available() else "cpu" @@ -160,42 +32,38 @@ def forward( prompt = 'a cyberpunk cat with a neon sign that says "Sana"' generator = torch.Generator(device=device).manual_seed(42) - latent = torch.randn( + latents = torch.randn( 1, 32, 32, 32, generator=generator, device=device, - ) + ).to(dtype) # diffusers Sana Model - pipe_diffuser = SanaPipelineDiffuser() - - image = pipe_diffuser( + pipe = SanaPipeline.from_pretrained( + "/home/junsongc/junsongc/code/diffusion/Sana/output/Sana_1600M_1024px_diffusers_flowshift3_full", + torch_dtype=dtype, + use_safetensors=True, + ).to(device) + + scheduler = FlowDPMSolverMultistepScheduler(flow_shift=3.0) + # scheduler = DPMSolverMultistepScheduler(use_flow_sigmas=True, prediction_type='flow_prediction', flow_shift=3.0) + pipe.scheduler = scheduler + + pipe.text_encoder.to(torch.bfloat16) + pipe.vae.to(torch.float32) + image = pipe( prompt=prompt, height=1024, width=1024, guidance_scale=5.0, - pag_guidance_scale=1.0, - num_inference_steps=18, + num_inference_steps=20, generator=generator, - latent=latent, - ) - save_image(image, 'sana_diffusers.png', nrow=1, normalize=True, value_range=(-1, 1)) - - # self implementation - # sana = SanaPipeline("configs/sana_config/1024ms/Sana_1600M_img1024.yaml") - # sana.from_pretrained("hf://Efficient-Large-Model/Sana_1600M_1024px/checkpoints/Sana_1600M_1024px.pth") - - # image = sana( - # prompt=prompt, - # height=1024, - # width=1024, - # guidance_scale=5.0, - # pag_guidance_scale=1.0, - # num_inference_steps=18, - # generator=generator, - # latent=latent, - # ) - - # save_image(image, 'sana_self.png', nrow=1, normalize=True, value_range=(-1, 1)) + latents=latents, + )[0] + image[0].save('sana_diffusers_flowdpmsolver4.png') + + + # run pixart + # run_pixart_sigam() diff --git a/src/diffusers/__init__.py b/src/diffusers/__init__.py index 2025540b8313..3f40cbc8fa0d 100644 --- a/src/diffusers/__init__.py +++ b/src/diffusers/__init__.py @@ -181,6 +181,7 @@ "DEISMultistepScheduler", "DPMSolverMultistepInverseScheduler", "DPMSolverMultistepScheduler", + "FlowDPMSolverMultistepScheduler", "DPMSolverSinglestepScheduler", "EDMDPMSolverMultistepScheduler", "EDMEulerScheduler", @@ -681,6 +682,7 @@ EDMEulerScheduler, EulerAncestralDiscreteScheduler, EulerDiscreteScheduler, + FlowDPMSolverMultistepScheduler, FlowMatchEulerDiscreteScheduler, FlowMatchHeunDiscreteScheduler, HeunDiscreteScheduler, diff --git a/src/diffusers/pipelines/sana/pipeline_sana.py b/src/diffusers/pipelines/sana/pipeline_sana.py index d82893ad7221..995d4ab92f07 100644 --- a/src/diffusers/pipelines/sana/pipeline_sana.py +++ b/src/diffusers/pipelines/sana/pipeline_sana.py @@ -23,7 +23,7 @@ from ...image_processor import PixArtImageProcessor from ...models import DCAE_HF, SanaTransformer2DModel -from ...schedulers import FlowMatchEulerDiscreteScheduler +from ...schedulers import FlowDPMSolverMultistepScheduler from ...utils import ( BACKENDS_MAPPING, deprecate, @@ -203,7 +203,7 @@ def __init__( text_encoder: AutoModelForCausalLM, vae: DCAE_HF, transformer: SanaTransformer2DModel, - scheduler: FlowMatchEulerDiscreteScheduler, + scheduler: FlowDPMSolverMultistepScheduler, ): super().__init__() diff --git a/src/diffusers/schedulers/__init__.py b/src/diffusers/schedulers/__init__.py index bb9088538653..eb77969f6f49 100644 --- a/src/diffusers/schedulers/__init__.py +++ b/src/diffusers/schedulers/__init__.py @@ -54,6 +54,7 @@ _import_structure["scheduling_dpmsolver_multistep"] = ["DPMSolverMultistepScheduler"] _import_structure["scheduling_dpmsolver_multistep_inverse"] = ["DPMSolverMultistepInverseScheduler"] _import_structure["scheduling_dpmsolver_singlestep"] = ["DPMSolverSinglestepScheduler"] + _import_structure["scheduling_dpmsolver_multistep_flow"] = ["FlowDPMSolverMultistepScheduler"] _import_structure["scheduling_edm_dpmsolver_multistep"] = ["EDMDPMSolverMultistepScheduler"] _import_structure["scheduling_edm_euler"] = ["EDMEulerScheduler"] _import_structure["scheduling_euler_ancestral_discrete"] = ["EulerAncestralDiscreteScheduler"] @@ -152,6 +153,7 @@ from .scheduling_deis_multistep import DEISMultistepScheduler from .scheduling_dpm_cogvideox import CogVideoXDPMScheduler from .scheduling_dpmsolver_multistep import DPMSolverMultistepScheduler + from .scheduling_dpmsolver_multistep_flow import FlowDPMSolverMultistepScheduler from .scheduling_dpmsolver_multistep_inverse import DPMSolverMultistepInverseScheduler from .scheduling_dpmsolver_singlestep import DPMSolverSinglestepScheduler from .scheduling_edm_dpmsolver_multistep import EDMDPMSolverMultistepScheduler diff --git a/src/diffusers/schedulers/scheduling_dpmsolver_multistep.py b/src/diffusers/schedulers/scheduling_dpmsolver_multistep.py index e7704f2ced19..910f519a4e68 100644 --- a/src/diffusers/schedulers/scheduling_dpmsolver_multistep.py +++ b/src/diffusers/schedulers/scheduling_dpmsolver_multistep.py @@ -218,6 +218,8 @@ def __init__( use_exponential_sigmas: Optional[bool] = False, use_beta_sigmas: Optional[bool] = False, use_lu_lambdas: Optional[bool] = False, + use_flow_sigmas: Optional[bool] = False, + flow_shift: Optional[float] = 1.0, final_sigmas_type: Optional[str] = "zero", # "zero", "sigma_min" lambda_min_clipped: float = -float("inf"), variance_type: Optional[str] = None, @@ -407,6 +409,11 @@ def set_timesteps( sigmas = np.flip(sigmas).copy() sigmas = self._convert_to_beta(in_sigmas=sigmas, num_inference_steps=num_inference_steps) timesteps = np.array([self._sigma_to_t(sigma, log_sigmas) for sigma in sigmas]) + elif self.config.use_flow_sigmas: + alphas = np.linspace(1, 1 / self.config.num_train_timesteps, num_inference_steps + 1) + sigmas = 1.0 - alphas + sigmas = np.flip(self.config.flow_shift * sigmas / (1 + (self.config.flow_shift - 1) * sigmas))[:-1] + timesteps = (sigmas * self.config.num_train_timesteps).copy() else: sigmas = np.interp(timesteps, np.arange(0, len(sigmas)), sigmas) @@ -495,8 +502,12 @@ def _sigma_to_t(self, sigma, log_sigmas): return t def _sigma_to_alpha_sigma_t(self, sigma): - alpha_t = 1 / ((sigma**2 + 1) ** 0.5) - sigma_t = sigma * alpha_t + if self.config.use_flow_sigmas: + alpha_t = 1 - sigma + sigma_t = sigma + else: + alpha_t = 1 / ((sigma**2 + 1) ** 0.5) + sigma_t = sigma * alpha_t return alpha_t, sigma_t @@ -650,10 +661,13 @@ def convert_model_output( sigma = self.sigmas[self.step_index] alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma) x0_pred = alpha_t * sample - sigma_t * model_output + elif self.config.prediction_type == "flow_prediction": + sigma_t = self.sigmas[self.step_index] + x0_pred = sample - sigma_t * model_output else: raise ValueError( - f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`, or" - " `v_prediction` for the DPMSolverMultistepScheduler." + f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`," + " `v_prediction`, or `flow_prediction` for the DPMSolverMultistepScheduler." ) if self.config.thresholding: diff --git a/src/diffusers/schedulers/scheduling_dpmsolver_multistep_flow.py b/src/diffusers/schedulers/scheduling_dpmsolver_multistep_flow.py index be639bcb5da5..4f407586a5be 100644 --- a/src/diffusers/schedulers/scheduling_dpmsolver_multistep_flow.py +++ b/src/diffusers/schedulers/scheduling_dpmsolver_multistep_flow.py @@ -27,120 +27,35 @@ if is_scipy_available(): - import scipy.stats + pass -# Copied from diffusers.schedulers.scheduling_ddpm.betas_for_alpha_bar -def betas_for_alpha_bar( - num_diffusion_timesteps, - max_beta=0.999, - alpha_transform_type="cosine", -): +class FlowDPMSolverMultistepScheduler(SchedulerMixin, ConfigMixin): """ - Create a beta schedule that discretizes the given alpha_t_bar function, which defines the cumulative product of - (1-beta) over time from t = [0,1]. - - Contains a function alpha_bar that takes an argument t and transforms it to the cumulative product of (1-beta) up - to that part of the diffusion process. - - - Args: - num_diffusion_timesteps (`int`): the number of betas to produce. - max_beta (`float`): the maximum beta to use; use values lower than 1 to - prevent singularities. - alpha_transform_type (`str`, *optional*, default to `cosine`): the type of noise schedule for alpha_bar. - Choose from `cosine` or `exp` - - Returns: - betas (`np.ndarray`): the betas used by the scheduler to step the model outputs - """ - if alpha_transform_type == "cosine": - - def alpha_bar_fn(t): - return math.cos((t + 0.008) / 1.008 * math.pi / 2) ** 2 - - elif alpha_transform_type == "exp": - - def alpha_bar_fn(t): - return math.exp(t * -12.0) - - else: - raise ValueError(f"Unsupported alpha_transform_type: {alpha_transform_type}") - - betas = [] - for i in range(num_diffusion_timesteps): - t1 = i / num_diffusion_timesteps - t2 = (i + 1) / num_diffusion_timesteps - betas.append(min(1 - alpha_bar_fn(t2) / alpha_bar_fn(t1), max_beta)) - return torch.tensor(betas, dtype=torch.float32) - - -# Copied from diffusers.schedulers.scheduling_ddim.rescale_zero_terminal_snr -def rescale_zero_terminal_snr(betas): - """ - Rescales betas to have zero terminal SNR Based on https://arxiv.org/pdf/2305.08891.pdf (Algorithm 1) - - - Args: - betas (`torch.Tensor`): - the betas that the scheduler is being initialized with. - - Returns: - `torch.Tensor`: rescaled betas with zero terminal SNR - """ - # Convert betas to alphas_bar_sqrt - alphas = 1.0 - betas - alphas_cumprod = torch.cumprod(alphas, dim=0) - alphas_bar_sqrt = alphas_cumprod.sqrt() - - # Store old values. - alphas_bar_sqrt_0 = alphas_bar_sqrt[0].clone() - alphas_bar_sqrt_T = alphas_bar_sqrt[-1].clone() - - # Shift so the last timestep is zero. - alphas_bar_sqrt -= alphas_bar_sqrt_T - - # Scale so the first timestep is back to the old value. - alphas_bar_sqrt *= alphas_bar_sqrt_0 / (alphas_bar_sqrt_0 - alphas_bar_sqrt_T) - - # Convert alphas_bar_sqrt to betas - alphas_bar = alphas_bar_sqrt**2 # Revert sqrt - alphas = alphas_bar[1:] / alphas_bar[:-1] # Revert cumprod - alphas = torch.cat([alphas_bar[0:1], alphas]) - betas = 1 - alphas - - return betas - - -class DPMSolverMultistepScheduler(SchedulerMixin, ConfigMixin): - """ - `DPMSolverMultistepScheduler` is a fast dedicated high-order solver for diffusion ODEs. + `FlowDPMSolverMultistepScheduler` is a fast dedicated high-order solver for diffusion ODEs. This model inherits from [`SchedulerMixin`] and [`ConfigMixin`]. Check the superclass documentation for the generic methods the library implements for all schedulers such as loading and saving. Args: num_train_timesteps (`int`, defaults to 1000): - The number of diffusion steps to train the model. - beta_start (`float`, defaults to 0.0001): - The starting `beta` value of inference. - beta_end (`float`, defaults to 0.02): - The final `beta` value. - beta_schedule (`str`, defaults to `"linear"`): - The beta schedule, a mapping from a beta range to a sequence of betas for stepping the model. Choose from - `linear`, `scaled_linear`, or `squaredcos_cap_v2`. - trained_betas (`np.ndarray`, *optional*): - Pass an array of betas directly to the constructor to bypass `beta_start` and `beta_end`. + The number of diffusion steps to train the model. This determines the resolution of the diffusion process. solver_order (`int`, defaults to 2): - The DPMSolver order which can be `1` or `2` or `3`. It is recommended to use `solver_order=2` for guided - sampling, and `solver_order=3` for unconditional sampling. - prediction_type (`str`, defaults to `epsilon`, *optional*): - Prediction type of the scheduler function; can be `epsilon` (predicts the noise of the diffusion process), - `sample` (directly predicts the noisy sample`) or `v_prediction` (see section 2.4 of [Imagen - Video](https://imagen.research.google/video/paper.pdf) paper). + The DPMSolver order which can be `1`, `2`, or `3`. It is recommended to use `solver_order=2` for guided + sampling, and `solver_order=3` for unconditional sampling. This affects the number of model outputs stored + and used in multistep updates. + prediction_type (`str`, defaults to "flow_prediction"): + Prediction type of the scheduler function; must be `flow_prediction` for this scheduler, which predicts + the flow of the diffusion process. + flow_shift (`float`, *optional*, defaults to 1.0): + A factor used to adjust the sigmas in the noise schedule. It modifies the step sizes during the sampling + process. + use_dynamic_shifting (`bool`, defaults to `False`): + Whether to apply dynamic shifting to the timesteps based on image resolution. If `True`, the shifting is + applied on the fly. thresholding (`bool`, defaults to `False`): - Whether to use the "dynamic thresholding" method. This is unsuitable for latent-space diffusion models such - as Stable Diffusion. + Whether to use the "dynamic thresholding" method. This method adjusts the predicted sample to prevent + saturation and improve photorealism. dynamic_thresholding_ratio (`float`, defaults to 0.995): The ratio for the dynamic thresholding method. Valid only when `thresholding=True`. sample_max_value (`float`, defaults to 1.0): @@ -162,19 +77,7 @@ class DPMSolverMultistepScheduler(SchedulerMixin, ConfigMixin): Whether to use Euler's method in the final step. It is a trade-off between numerical stability and detail richness. This can stabilize the sampling of the SDE variant of DPMSolver for small number of inference steps, but sometimes may result in blurring. - use_karras_sigmas (`bool`, *optional*, defaults to `False`): - Whether to use Karras sigmas for step sizes in the noise schedule during the sampling process. If `True`, - the sigmas are determined according to a sequence of noise levels {σi}. - use_exponential_sigmas (`bool`, *optional*, defaults to `False`): - Whether to use exponential sigmas for step sizes in the noise schedule during the sampling process. - use_beta_sigmas (`bool`, *optional*, defaults to `False`): - Whether to use beta sigmas for step sizes in the noise schedule during the sampling process. Refer to [Beta - Sampling is All You Need](https://huggingface.co/papers/2407.12173) for more information. - use_lu_lambdas (`bool`, *optional*, defaults to `False`): - Whether to use the uniform-logSNR for step sizes proposed by Lu's DPM-Solver in the noise schedule during - the sampling process. If `True`, the sigmas and time steps are determined according to a sequence of - `lambda(t)`. - final_sigmas_type (`str`, defaults to `"zero"`): + final_sigmas_type (`str`, *optional*, defaults to "zero"): The final `sigma` value for the noise schedule during the sampling process. If `"sigma_min"`, the final sigma is the same as the last sigma in the training schedule. If `zero`, the final sigma is set to 0. lambda_min_clipped (`float`, defaults to `-inf`): @@ -183,15 +86,6 @@ class DPMSolverMultistepScheduler(SchedulerMixin, ConfigMixin): variance_type (`str`, *optional*): Set to "learned" or "learned_range" for diffusion models that predict variance. If set, the model's output contains the predicted Gaussian variance. - timestep_spacing (`str`, defaults to `"linspace"`): - The way the timesteps should be scaled. Refer to Table 2 of the [Common Diffusion Noise Schedules and - Sample Steps are Flawed](https://huggingface.co/papers/2305.08891) for more information. - steps_offset (`int`, defaults to 0): - An offset added to the inference steps, as required by some model families. - rescale_betas_zero_snr (`bool`, defaults to `False`): - Whether to rescale the betas to have zero terminal SNR. This enables the model to generate very bright and - dark samples instead of limiting it to samples with medium brightness. Loosely related to - [`--offset_noise`](https://github.com/huggingface/diffusers/blob/74fd735eb073eb1d774b1ab4154a0876eb82f055/examples/dreambooth/train_dreambooth.py#L506). """ _compatibles = [e.name for e in KarrasDiffusionSchedulers] @@ -201,12 +95,10 @@ class DPMSolverMultistepScheduler(SchedulerMixin, ConfigMixin): def __init__( self, num_train_timesteps: int = 1000, - beta_start: float = 0.0001, - beta_end: float = 0.02, - beta_schedule: str = "linear", - trained_betas: Optional[Union[np.ndarray, List[float]]] = None, solver_order: int = 2, - prediction_type: str = "epsilon", + prediction_type: str = "flow_prediction", + flow_shift: Optional[float] = 1.0, + use_dynamic_shifting=False, thresholding: bool = False, dynamic_thresholding_ratio: float = 0.995, sample_max_value: float = 1.0, @@ -214,62 +106,15 @@ def __init__( solver_type: str = "midpoint", lower_order_final: bool = True, euler_at_final: bool = False, - use_karras_sigmas: Optional[bool] = False, - use_exponential_sigmas: Optional[bool] = False, - use_beta_sigmas: Optional[bool] = False, - use_lu_lambdas: Optional[bool] = False, - use_flow_sigmas: Optional[bool] = False, - flow_shift: Optional[float] = 1.0, final_sigmas_type: Optional[str] = "zero", # "zero", "sigma_min" lambda_min_clipped: float = -float("inf"), variance_type: Optional[str] = None, - timestep_spacing: str = "linspace", - steps_offset: int = 0, - rescale_betas_zero_snr: bool = False, + invert_sigmas: bool = False, ): - if self.config.use_beta_sigmas and not is_scipy_available(): - raise ImportError("Make sure to install scipy if you want to use beta sigmas.") - if sum([self.config.use_beta_sigmas, self.config.use_exponential_sigmas, self.config.use_karras_sigmas]) > 1: - raise ValueError( - "Only one of `config.use_beta_sigmas`, `config.use_exponential_sigmas`, `config.use_karras_sigmas` can be used." - ) if algorithm_type in ["dpmsolver", "sde-dpmsolver"]: deprecation_message = f"algorithm_type {algorithm_type} is deprecated and will be removed in a future version. Choose from `dpmsolver++` or `sde-dpmsolver++` instead" deprecate("algorithm_types dpmsolver and sde-dpmsolver", "1.0.0", deprecation_message) - if trained_betas is not None: - self.betas = torch.tensor(trained_betas, dtype=torch.float32) - elif beta_schedule == "linear": - self.betas = torch.linspace(beta_start, beta_end, num_train_timesteps, dtype=torch.float32) - elif beta_schedule == "scaled_linear": - # this schedule is very specific to the latent diffusion model. - self.betas = torch.linspace(beta_start**0.5, beta_end**0.5, num_train_timesteps, dtype=torch.float32) ** 2 - elif beta_schedule == "squaredcos_cap_v2": - # Glide cosine schedule - self.betas = betas_for_alpha_bar(num_train_timesteps) - else: - raise NotImplementedError(f"{beta_schedule} is not implemented for {self.__class__}") - - if rescale_betas_zero_snr: - self.betas = rescale_zero_terminal_snr(self.betas) - - self.alphas = 1.0 - self.betas - self.alphas_cumprod = torch.cumprod(self.alphas, dim=0) - - if rescale_betas_zero_snr: - # Close to 0 without being 0 so first sigma is not inf - # FP16 smallest positive subnormal works well here - self.alphas_cumprod[-1] = 2**-24 - - # Currently we only support VP-type noise schedule - self.alpha_t = torch.sqrt(self.alphas_cumprod) - self.sigma_t = torch.sqrt(1 - self.alphas_cumprod) - self.lambda_t = torch.log(self.alpha_t) - torch.log(self.sigma_t) - self.sigmas = ((1 - self.alphas_cumprod) / self.alphas_cumprod) ** 0.5 - - # standard deviation of the initial noise distribution - self.init_noise_sigma = 1.0 - # settings for DPM-Solver if algorithm_type not in ["dpmsolver", "dpmsolver++", "sde-dpmsolver", "sde-dpmsolver++"]: if algorithm_type == "deis": @@ -290,13 +135,25 @@ def __init__( # setable values self.num_inference_steps = None - timesteps = np.linspace(0, num_train_timesteps - 1, num_train_timesteps, dtype=np.float32)[::-1].copy() - self.timesteps = torch.from_numpy(timesteps) + alphas = np.linspace(1, 1 / num_train_timesteps, num_train_timesteps)[::-1].copy() + sigmas = 1.0 - alphas + sigmas = torch.from_numpy(sigmas).to(dtype=torch.float32) + + if not use_dynamic_shifting: + # when use_dynamic_shifting is True, we apply the timestep shifting on the fly based on the image resolution + sigmas = flow_shift * sigmas / (1 + (flow_shift - 1) * sigmas) + + self.sigmas = sigmas + self.timesteps = sigmas * num_train_timesteps + self.model_outputs = [None] * solver_order self.lower_order_nums = 0 self._step_index = None self._begin_index = None + self.sigmas = self.sigmas.to("cpu") # to avoid too much CPU/GPU communication + self.sigma_min = self.sigmas[-1].item() + self.sigma_max = self.sigmas[0].item() @property def step_index(self): @@ -312,6 +169,7 @@ def begin_index(self): """ return self._begin_index + # Copied from diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler.set_begin_index def set_begin_index(self, begin_index: int = 0): """ Sets the begin index for the scheduler. This function should be run from pipeline before the inference. @@ -322,96 +180,34 @@ def set_begin_index(self, begin_index: int = 0): """ self._begin_index = begin_index + # Modified from diffusers.schedulers.scheduling_flow_match_euler_discrete.FlowMatchEulerDiscreteScheduler.set_timesteps def set_timesteps( self, num_inference_steps: int = None, device: Union[str, torch.device] = None, - timesteps: Optional[List[int]] = None, + sigmas: Optional[List[float]] = None, + mu: Optional[float] = None, ): """ Sets the discrete timesteps used for the diffusion chain (to be run before inference). Args: num_inference_steps (`int`): - The number of diffusion steps used when generating samples with a pre-trained model. + Total number of the spacing of the time steps. device (`str` or `torch.device`, *optional*): The device to which the timesteps should be moved to. If `None`, the timesteps are not moved. - timesteps (`List[int]`, *optional*): - Custom timesteps used to support arbitrary timesteps schedule. If `None`, timesteps will be generated - based on the `timestep_spacing` attribute. If `timesteps` is passed, `num_inference_steps` and `sigmas` - must be `None`, and `timestep_spacing` attribute will be ignored. """ - if num_inference_steps is None and timesteps is None: - raise ValueError("Must pass exactly one of `num_inference_steps` or `timesteps`.") - if num_inference_steps is not None and timesteps is not None: - raise ValueError("Can only pass one of `num_inference_steps` or `custom_timesteps`.") - if timesteps is not None and self.config.use_karras_sigmas: - raise ValueError("Cannot use `timesteps` with `config.use_karras_sigmas = True`") - if timesteps is not None and self.config.use_lu_lambdas: - raise ValueError("Cannot use `timesteps` with `config.use_lu_lambdas = True`") - if timesteps is not None and self.config.use_exponential_sigmas: - raise ValueError("Cannot set `timesteps` with `config.use_exponential_sigmas = True`.") - if timesteps is not None and self.config.use_beta_sigmas: - raise ValueError("Cannot set `timesteps` with `config.use_beta_sigmas = True`.") - - if timesteps is not None: - timesteps = np.array(timesteps).astype(np.int64) - else: - # Clipping the minimum of all lambda(t) for numerical stability. - # This is critical for cosine (squaredcos_cap_v2) noise schedule. - clipped_idx = torch.searchsorted(torch.flip(self.lambda_t, [0]), self.config.lambda_min_clipped) - last_timestep = ((self.config.num_train_timesteps - clipped_idx).numpy()).item() - - # "linspace", "leading", "trailing" corresponds to annotation of Table 2. of https://arxiv.org/abs/2305.08891 - if self.config.timestep_spacing == "linspace": - timesteps = ( - np.linspace(0, last_timestep - 1, num_inference_steps + 1) - .round()[::-1][:-1] - .copy() - .astype(np.int64) - ) - elif self.config.timestep_spacing == "leading": - step_ratio = last_timestep // (num_inference_steps + 1) - # creates integer timesteps by multiplying by ratio - # casting to int to avoid issues when num_inference_step is power of 3 - timesteps = ( - (np.arange(0, num_inference_steps + 1) * step_ratio).round()[::-1][:-1].copy().astype(np.int64) - ) - timesteps += self.config.steps_offset - elif self.config.timestep_spacing == "trailing": - step_ratio = self.config.num_train_timesteps / num_inference_steps - # creates integer timesteps by multiplying by ratio - # casting to int to avoid issues when num_inference_step is power of 3 - timesteps = np.arange(last_timestep, 0, -step_ratio).round().copy().astype(np.int64) - timesteps -= 1 - else: - raise ValueError( - f"{self.config.timestep_spacing} is not supported. Please make sure to choose one of 'linspace', 'leading' or 'trailing'." - ) - sigmas = np.array(((1 - self.alphas_cumprod) / self.alphas_cumprod) ** 0.5) - log_sigmas = np.log(sigmas) - - if self.config.use_karras_sigmas: - sigmas = np.flip(sigmas).copy() - sigmas = self._convert_to_karras(in_sigmas=sigmas, num_inference_steps=num_inference_steps) - timesteps = np.array([self._sigma_to_t(sigma, log_sigmas) for sigma in sigmas]).round() - elif self.config.use_lu_lambdas: - lambdas = np.flip(log_sigmas.copy()) - lambdas = self._convert_to_lu(in_lambdas=lambdas, num_inference_steps=num_inference_steps) - sigmas = np.exp(lambdas) - timesteps = np.array([self._sigma_to_t(sigma, log_sigmas) for sigma in sigmas]).round() - elif self.config.use_exponential_sigmas: - sigmas = self._convert_to_exponential(in_sigmas=sigmas, num_inference_steps=self.num_inference_steps) - timesteps = np.array([self._sigma_to_t(sigma, log_sigmas) for sigma in sigmas]) - elif self.config.use_beta_sigmas: - sigmas = self._convert_to_beta(in_sigmas=sigmas, num_inference_steps=self.num_inference_steps) - timesteps = np.array([self._sigma_to_t(sigma, log_sigmas) for sigma in sigmas]) - elif self.config.use_flow_sigmas: - sigmas = self._convert_to_flow(in_sigmas=sigmas, num_inference_steps=self.num_inference_steps, shift=self.config.timestep_shift) - timesteps = sigmas + if self.config.use_dynamic_shifting and mu is None: + raise ValueError(" you have a pass a value for `mu` when `use_dynamic_shifting` is set to be `True`") + + if sigmas is None: + sigmas = np.linspace(self.sigma_max, self.sigma_min, num_inference_steps + 1).copy()[:-1] + + if self.config.use_dynamic_shifting: + sigmas = self.time_shift(mu, 1.0, sigmas) else: - sigmas = np.interp(timesteps, np.arange(0, len(sigmas)), sigmas) + sigmas = self.config.flow_shift * sigmas / (1 + (self.config.flow_shift - 1) * sigmas) if self.config.final_sigmas_type == "sigma_min": sigma_last = ((1 - self.alphas_cumprod[0]) / self.alphas_cumprod[0]) ** 0.5 @@ -422,6 +218,7 @@ def set_timesteps( f"`final_sigmas_type` must be one of 'zero', or 'sigma_min', but got {self.config.final_sigmas_type}" ) + timesteps = sigmas * self.config.num_train_timesteps sigmas = np.concatenate([sigmas, [sigma_last]]).astype(np.float32) self.sigmas = torch.from_numpy(sigmas) @@ -429,12 +226,6 @@ def set_timesteps( self.num_inference_steps = len(timesteps) - self.model_outputs = [ - None, - ] * self.config.solver_order - self.lower_order_nums = 0 - - # add an index counter for schedulers that allow duplicated timesteps self._step_index = None self._begin_index = None self.sigmas = self.sigmas.to("cpu") # to avoid too much CPU/GPU communication @@ -473,153 +264,18 @@ def _threshold_sample(self, sample: torch.Tensor) -> torch.Tensor: return sample - # Copied from diffusers.schedulers.scheduling_euler_discrete.EulerDiscreteScheduler._sigma_to_t - def _sigma_to_t(self, sigma, log_sigmas): - # get log sigma - log_sigma = np.log(np.maximum(sigma, 1e-10)) - - # get distribution - dists = log_sigma - log_sigmas[:, np.newaxis] - - # get sigmas range - low_idx = np.cumsum((dists >= 0), axis=0).argmax(axis=0).clip(max=log_sigmas.shape[0] - 2) - high_idx = low_idx + 1 - - low = log_sigmas[low_idx] - high = log_sigmas[high_idx] - - # interpolate sigmas - w = (low - log_sigma) / (low - high) - w = np.clip(w, 0, 1) - - # transform interpolation to time range - t = (1 - w) * low_idx + w * high_idx - t = t.reshape(sigma.shape) - return t + # Copied from diffusers.schedulers.scheduling_flow_match_euler_discrete.FlowMatchEulerDiscreteScheduler._sigma_to_t + def _sigma_to_t(self, sigma): + return sigma * self.config.num_train_timesteps def _sigma_to_alpha_sigma_t(self, sigma): - if self.config.prediction_type == "flow_prediction": - alpha_t = 1 - sigma - sigma_t = sigma - else: - alpha_t = 1 / ((sigma**2 + 1) ** 0.5) - sigma_t = sigma * alpha_t - - return alpha_t, sigma_t - # Copied from diffusers.schedulers.scheduling_euler_discrete.EulerDiscreteScheduler._convert_to_karras - def _convert_to_karras(self, in_sigmas: torch.Tensor, num_inference_steps) -> torch.Tensor: - """Constructs the noise schedule of Karras et al. (2022).""" - - # Hack to make sure that other schedulers which copy this function don't break - # TODO: Add this logic to the other schedulers - if hasattr(self.config, "sigma_min"): - sigma_min = self.config.sigma_min - else: - sigma_min = None - - if hasattr(self.config, "sigma_max"): - sigma_max = self.config.sigma_max - else: - sigma_max = None - - sigma_min = sigma_min if sigma_min is not None else in_sigmas[-1].item() - sigma_max = sigma_max if sigma_max is not None else in_sigmas[0].item() - - rho = 7.0 # 7.0 is the value used in the paper - ramp = np.linspace(0, 1, num_inference_steps) - min_inv_rho = sigma_min ** (1 / rho) - max_inv_rho = sigma_max ** (1 / rho) - sigmas = (max_inv_rho + ramp * (min_inv_rho - max_inv_rho)) ** rho - return sigmas - - def _convert_to_lu(self, in_lambdas: torch.Tensor, num_inference_steps) -> torch.Tensor: - """Constructs the noise schedule of Lu et al. (2022).""" - - lambda_min: float = in_lambdas[-1].item() - lambda_max: float = in_lambdas[0].item() - - rho = 1.0 # 1.0 is the value used in the paper - ramp = np.linspace(0, 1, num_inference_steps) - min_inv_rho = lambda_min ** (1 / rho) - max_inv_rho = lambda_max ** (1 / rho) - lambdas = (max_inv_rho + ramp * (min_inv_rho - max_inv_rho)) ** rho - return lambdas - - # Copied from diffusers.schedulers.scheduling_euler_discrete.EulerDiscreteScheduler._convert_to_exponential - def _convert_to_exponential(self, in_sigmas: torch.Tensor, num_inference_steps: int) -> torch.Tensor: - """Constructs an exponential noise schedule.""" - - # Hack to make sure that other schedulers which copy this function don't break - # TODO: Add this logic to the other schedulers - if hasattr(self.config, "sigma_min"): - sigma_min = self.config.sigma_min - else: - sigma_min = None - - if hasattr(self.config, "sigma_max"): - sigma_max = self.config.sigma_max - else: - sigma_max = None + return 1 - sigma, sigma - sigma_min = sigma_min if sigma_min is not None else in_sigmas[-1].item() - sigma_max = sigma_max if sigma_max is not None else in_sigmas[0].item() - - sigmas = torch.linspace(math.log(sigma_max), math.log(sigma_min), num_inference_steps).exp() - return sigmas - - # Copied from diffusers.schedulers.scheduling_euler_discrete.EulerDiscreteScheduler._convert_to_beta - def _convert_to_beta( - self, in_sigmas: torch.Tensor, num_inference_steps: int, alpha: float = 0.6, beta: float = 0.6 - ) -> torch.Tensor: - """From "Beta Sampling is All You Need" [arXiv:2407.12173] (Lee et. al, 2024)""" - - # Hack to make sure that other schedulers which copy this function don't break - # TODO: Add this logic to the other schedulers - if hasattr(self.config, "sigma_min"): - sigma_min = self.config.sigma_min - else: - sigma_min = None - - if hasattr(self.config, "sigma_max"): - sigma_max = self.config.sigma_max - else: - sigma_max = None - - sigma_min = sigma_min if sigma_min is not None else in_sigmas[-1].item() - sigma_max = sigma_max if sigma_max is not None else in_sigmas[0].item() - - sigmas = torch.Tensor( - [ - sigma_min + (ppf * (sigma_max - sigma_min)) - for ppf in [ - scipy.stats.beta.ppf(timestep, alpha, beta) - for timestep in 1 - np.linspace(0, 1, num_inference_steps) - ] - ] - ) - return sigmas - - def _convert_to_flow(self, in_sigmas: torch.Tensor, num_inference_steps, shift: float = 1.0) -> torch.Tensor: - if hasattr(self.config, "sigma_min"): - sigma_min = self.config.sigma_min - else: - sigma_min = None - - if hasattr(self.config, "sigma_max"): - sigma_max = self.config.sigma_max - else: - sigma_max = None - - sigma_min = sigma_min if sigma_min is not None else in_sigmas[-1].item() - sigma_max = sigma_max if sigma_max is not None else in_sigmas[0].item() - - N = num_inference_steps - - betas = torch.linspace(sigma_min, sigma_max, N + 1).to(in_sigmas.device) - sigmas = 1.0 - betas - sigmas = (shift * sigmas / (1 + (shift - 1) * sigmas)).flip(dims=[0]) - return sigmas + # Copied from diffusers.schedulers.scheduling_flow_match_euler_discrete.set_timesteps + def time_shift(self, mu: float, sigma: float, t: torch.Tensor): + return math.exp(mu) / (math.exp(mu) + (1 / t - 1) ** sigma) + # Copied from diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler.convert_model_output def convert_model_output( self, model_output: torch.Tensor, @@ -664,29 +320,13 @@ def convert_model_output( # DPM-Solver++ needs to solve an integral of the data prediction model. if self.config.algorithm_type in ["dpmsolver++", "sde-dpmsolver++"]: - if self.config.prediction_type == "epsilon": - # DPM-Solver and DPM-Solver++ only need the "mean" output. - if self.config.variance_type in ["learned", "learned_range"]: - model_output = model_output[:, :3] - sigma = self.sigmas[self.step_index] - alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma) - x0_pred = (sample - sigma_t * model_output) / alpha_t - elif self.config.prediction_type == "sample": - x0_pred = model_output - elif self.config.prediction_type == "v_prediction": - sigma = self.sigmas[self.step_index] - alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma) - x0_pred = alpha_t * sample - sigma_t * model_output - elif self.config.prediction_type == "flow_prediction": + if self.config.prediction_type == "flow_prediction": sigma_t = self.sigmas[self.step_index] - # _, sigma_t = self._sigma_to_alpha_sigma_t(sigma) - sigma_t = sigma - # x0_pred = (sample - sigma_t * model_output) / alpha_t x0_pred = sample - sigma_t * model_output else: raise ValueError( f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`," - " `v_prediction`, or `flow_prediction` for the DPMSolverMultistepScheduler." + " `v_prediction`, or `flow_prediction` for the FlowDPMSolverMultistepScheduler." ) if self.config.thresholding: @@ -696,35 +336,24 @@ def convert_model_output( # DPM-Solver needs to solve an integral of the noise prediction model. elif self.config.algorithm_type in ["dpmsolver", "sde-dpmsolver"]: - if self.config.prediction_type == "epsilon": - # DPM-Solver and DPM-Solver++ only need the "mean" output. - if self.config.variance_type in ["learned", "learned_range"]: - epsilon = model_output[:, :3] - else: - epsilon = model_output - elif self.config.prediction_type == "sample": - sigma = self.sigmas[self.step_index] - alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma) - epsilon = (sample - alpha_t * model_output) / sigma_t - elif self.config.prediction_type == "v_prediction": - sigma = self.sigmas[self.step_index] - alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma) - epsilon = alpha_t * model_output + sigma_t * sample + if self.config.prediction_type == "flow_prediction": + sigma_t = self.sigmas[self.step_index] + epsilon = sample - (1 - sigma_t) * model_output else: raise ValueError( - f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`, or" - " `v_prediction` for the DPMSolverMultistepScheduler." + f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`," + " `v_prediction` or `flow_prediction` for the FlowDPMSolverMultistepScheduler." ) if self.config.thresholding: - sigma = self.sigmas[self.step_index] - alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma) - x0_pred = (sample - sigma_t * epsilon) / alpha_t + sigma_t = self.sigmas[self.step_index] + x0_pred = sample - sigma_t * model_output x0_pred = self._threshold_sample(x0_pred) - epsilon = (sample - alpha_t * x0_pred) / sigma_t + epsilon = model_output + x0_pred return epsilon + # Copied from diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler.dpm_solver_first_order_update def dpm_solver_first_order_update( self, model_output: torch.Tensor, @@ -794,6 +423,7 @@ def dpm_solver_first_order_update( ) return x_t + # Copied from diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler.multistep_dpm_solver_second_order_update def multistep_dpm_solver_second_order_update( self, model_output_list: List[torch.Tensor], @@ -917,6 +547,7 @@ def multistep_dpm_solver_second_order_update( ) return x_t + # Copied from diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler.multistep_dpm_solver_third_order_update def multistep_dpm_solver_third_order_update( self, model_output_list: List[torch.Tensor], @@ -1006,20 +637,15 @@ def index_for_timestep(self, timestep, schedule_timesteps=None): if schedule_timesteps is None: schedule_timesteps = self.timesteps - index_candidates = (schedule_timesteps == timestep).nonzero() + indices = (schedule_timesteps == timestep).nonzero() - if len(index_candidates) == 0: - step_index = len(self.timesteps) - 1 # The sigma index that is taken for the **very** first `step` # is always the second index (or the last index if there is only 1) # This way we can ensure we don't accidentally skip a sigma in # case we start in the middle of the denoising schedule (e.g. for image-to-image) - elif len(index_candidates) > 1: - step_index = index_candidates[1].item() - else: - step_index = index_candidates[0].item() + pos = 1 if len(indices) > 1 else 0 - return step_index + return indices[pos].item() def _init_step_index(self, timestep): """ @@ -1033,6 +659,7 @@ def _init_step_index(self, timestep): else: self._step_index = self._begin_index + # Modified from diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler.step def step( self, model_output: torch.Tensor, @@ -1122,6 +749,7 @@ def step( return SchedulerOutput(prev_sample=prev_sample) + # Copied from diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler.scale_model_input def scale_model_input(self, sample: torch.Tensor, *args, **kwargs) -> torch.Tensor: """ Ensures interchangeability with schedulers that need to scale the denoising model input depending on the @@ -1137,6 +765,7 @@ def scale_model_input(self, sample: torch.Tensor, *args, **kwargs) -> torch.Tens """ return sample + # Copied from diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler.scale_model_input def add_noise( self, original_samples: torch.Tensor, From 9b2b76a91c5599d5922811fc3455bf118e5e83ab Mon Sep 17 00:00:00 2001 From: junsong Date: Fri, 15 Nov 2024 04:06:42 -0800 Subject: [PATCH 089/141] =?UTF-8?q?=F0=9F=8E=89=F0=9F=94=A7[important=20up?= =?UTF-8?q?date=20&=20fix=20huge=20bugs!!]=201.=20add=20SanaPAGPipeline=20?= =?UTF-8?q?&=20several=20related=20Sana=20linear=20attention=20operators;?= =?UTF-8?q?=202.=20`SanaTransformer2DModel`=20not=20supports=20multi-resol?= =?UTF-8?q?ution=20input;=202.=20fix=20the=20multi-scale=20HW=20bugs=20in?= =?UTF-8?q?=20SanaPipeline=20and=20SanaPAGPipeline;=203.=20fix=20the=20flo?= =?UTF-8?q?w-dpm-solver=20set=5Ftimestep()=20init=20`model=5Foutput`=20and?= =?UTF-8?q?=20`lower=5Forder=5Fnums`=20bugs;?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/diffusers/__init__.py | 2 + src/diffusers/models/attention_processor.py | 219 +++++ .../transformers/sana_transformer_2d.py | 23 +- src/diffusers/pipelines/__init__.py | 2 + src/diffusers/pipelines/pag/__init__.py | 2 + .../pipelines/pag/pipeline_pag_sana.py | 873 ++++++++++++++++++ src/diffusers/pipelines/sana/pipeline_sana.py | 52 +- .../scheduling_dpmsolver_multistep_flow.py | 5 + 8 files changed, 1127 insertions(+), 51 deletions(-) create mode 100644 src/diffusers/pipelines/pag/pipeline_pag_sana.py diff --git a/src/diffusers/__init__.py b/src/diffusers/__init__.py index 3f40cbc8fa0d..8235cf18db0f 100644 --- a/src/diffusers/__init__.py +++ b/src/diffusers/__init__.py @@ -332,6 +332,7 @@ "PixArtSigmaPipeline", "ReduxImageEncoder", "SanaPipeline", + "SanaPAGPipeline", "SemanticStableDiffusionPipeline", "ShapEImg2ImgPipeline", "ShapEPipeline", @@ -809,6 +810,7 @@ PixArtSigmaPipeline, ReduxImageEncoder, SanaPipeline, + SanaPAGPipeline, SemanticStableDiffusionPipeline, ShapEImg2ImgPipeline, ShapEPipeline, diff --git a/src/diffusers/models/attention_processor.py b/src/diffusers/models/attention_processor.py index 6ba738f20595..075f6b98d829 100644 --- a/src/diffusers/models/attention_processor.py +++ b/src/diffusers/models/attention_processor.py @@ -5283,6 +5283,224 @@ def __call__( return hidden_states +class PAGCFGSanaLinearAttnProcessor2_0: + r""" + Processor for implementing scaled dot-product linear attention. + """ + + def __init__(self, pad_val=1.0, eps=1e-15): + self.pad_val = pad_val + self.eps = eps + self.kernel_func = nn.ReLU(inplace=False) + + def __call__( + self, + attn: Attention, + hidden_states: torch.Tensor, + encoder_hidden_states: Optional[torch.Tensor] = None, + attention_mask: Optional[torch.Tensor] = None, + temb: Optional[torch.Tensor] = None, + *args, + **kwargs, + ) -> torch.Tensor: + if len(args) > 0 or kwargs.get("scale", None) is not None: + deprecation_message = "The `scale` argument is deprecated and will be ignored. Please remove it, as passing it will raise an error in the future. `scale` should directly be passed while calling the underlying pipeline component i.e., via `cross_attention_kwargs`." + deprecate("scale", "1.0.0", deprecation_message) + + residual = hidden_states + if attn.spatial_norm is not None: + hidden_states = attn.spatial_norm(hidden_states, temb) + + input_ndim = hidden_states.ndim + + if input_ndim == 4: + batch_size, channel, height, width = hidden_states.shape + hidden_states = hidden_states.view(batch_size, channel, height * width).transpose(1, 2) + + # chunk + hidden_states_uncond, hidden_states_org, hidden_states_ptb = hidden_states.chunk(3) + hidden_states_org = torch.cat([hidden_states_uncond, hidden_states_org]) + + # original path + batch_size, sequence_length, _ = ( + hidden_states_org.shape if encoder_hidden_states is None else encoder_hidden_states.shape + ) + + query = attn.to_q(hidden_states_org) + key = attn.to_k(hidden_states_org) + value = attn.to_v(hidden_states_org) + + inner_dim = key.shape[-1] + head_dim = inner_dim // attn.heads + + dtype = query.dtype + + query = query.transpose(-1, -2).reshape(batch_size, attn.heads, head_dim, -1) + key = key.transpose(-1, -2).reshape(batch_size, attn.heads, head_dim, -1).transpose(-1, -2) + value = value.transpose(-1, -2).reshape(batch_size, attn.heads, head_dim, -1) + + query = self.kernel_func(query) # B, h, h_d, N + key = self.kernel_func(key) + + # need torch.float + query, key, value = query.float(), key.float(), value.float() + + value = F.pad(value, (0, 0, 0, 1), mode="constant", value=self.pad_val) + vk = torch.matmul(value, key) + hidden_states_org = torch.matmul(vk, query) + + if hidden_states_org.dtype in [torch.float16, torch.bfloat16]: + hidden_states_org = hidden_states_org.float() + hidden_states_org = hidden_states_org[:, :, :-1] / (hidden_states_org[:, :, -1:] + self.eps) + + hidden_states_org = hidden_states_org.view(batch_size, attn.heads * head_dim, -1).permute(0, 2, 1) + hidden_states_org = hidden_states_org.to(dtype) + + # linear proj + hidden_states_org = attn.to_out[0](hidden_states_org) + # dropout + hidden_states_org = attn.to_out[1](hidden_states_org) + + if input_ndim == 4: + hidden_states_org = hidden_states_org.transpose(-1, -2).reshape(batch_size, channel, height, width) + + # perturbed path (identity attention) + batch_size, sequence_length, _ = hidden_states_ptb.shape + + value = attn.to_v(hidden_states_ptb) + hidden_states_ptb = value + hidden_states_ptb = hidden_states_ptb.to(dtype) + + # linear proj + hidden_states_ptb = attn.to_out[0](hidden_states_ptb) + # dropout + hidden_states_ptb = attn.to_out[1](hidden_states_ptb) + + if input_ndim == 4: + hidden_states_ptb = hidden_states_ptb.transpose(-1, -2).reshape(batch_size, channel, height, width) + + # cat + hidden_states = torch.cat([hidden_states_org, hidden_states_ptb]) + + if attn.residual_connection: + hidden_states = hidden_states + residual + + hidden_states = hidden_states / attn.rescale_output_factor + + if hidden_states.dtype == torch.float16: + hidden_states = hidden_states.clip(-65504, 65504) + + return hidden_states + + +class PAGIdentitySanaLinearAttnProcessor2_0: + r""" + Processor for implementing scaled dot-product linear attention. + """ + + def __init__(self, pad_val=1.0, eps=1e-15): + self.pad_val = pad_val + self.eps = eps + self.kernel_func = nn.ReLU(inplace=False) + + def __call__( + self, + attn: Attention, + hidden_states: torch.Tensor, + encoder_hidden_states: Optional[torch.Tensor] = None, + attention_mask: Optional[torch.Tensor] = None, + temb: Optional[torch.Tensor] = None, + *args, + **kwargs, + ) -> torch.Tensor: + if len(args) > 0 or kwargs.get("scale", None) is not None: + deprecation_message = "The `scale` argument is deprecated and will be ignored. Please remove it, as passing it will raise an error in the future. `scale` should directly be passed while calling the underlying pipeline component i.e., via `cross_attention_kwargs`." + deprecate("scale", "1.0.0", deprecation_message) + + residual = hidden_states + if attn.spatial_norm is not None: + hidden_states = attn.spatial_norm(hidden_states, temb) + + input_ndim = hidden_states.ndim + + if input_ndim == 4: + batch_size, channel, height, width = hidden_states.shape + hidden_states = hidden_states.view(batch_size, channel, height * width).transpose(1, 2) + + # chunk + hidden_states_org, hidden_states_ptb = hidden_states.chunk(2) + + # original path + batch_size, sequence_length, _ = ( + hidden_states_org.shape if encoder_hidden_states is None else encoder_hidden_states.shape + ) + + query = attn.to_q(hidden_states_org) + key = attn.to_k(hidden_states_org) + value = attn.to_v(hidden_states_org) + + inner_dim = key.shape[-1] + head_dim = inner_dim // attn.heads + + dtype = query.dtype + + query = query.transpose(-1, -2).reshape(batch_size, attn.heads, head_dim, -1) + key = key.transpose(-1, -2).reshape(batch_size, attn.heads, head_dim, -1).transpose(-1, -2) + value = value.transpose(-1, -2).reshape(batch_size, attn.heads, head_dim, -1) + + query = self.kernel_func(query) # B, h, h_d, N + key = self.kernel_func(key) + + # need torch.float + query, key, value = query.float(), key.float(), value.float() + + value = F.pad(value, (0, 0, 0, 1), mode="constant", value=self.pad_val) + vk = torch.matmul(value, key) + hidden_states_org = torch.matmul(vk, query) + + if hidden_states_org.dtype in [torch.float16, torch.bfloat16]: + hidden_states_org = hidden_states_org.float() + hidden_states_org = hidden_states_org[:, :, :-1] / (hidden_states_org[:, :, -1:] + self.eps) + + hidden_states_org = hidden_states_org.view(batch_size, attn.heads * head_dim, -1).permute(0, 2, 1) + hidden_states_org = hidden_states_org.to(dtype) + + # linear proj + hidden_states_org = attn.to_out[0](hidden_states_org) + # dropout + hidden_states_org = attn.to_out[1](hidden_states_org) + + if input_ndim == 4: + hidden_states_org = hidden_states_org.transpose(-1, -2).reshape(batch_size, channel, height, width) + + # perturbed path (identity attention) + batch_size, sequence_length, _ = hidden_states_ptb.shape + + hidden_states_ptb = attn.to_v(hidden_states_ptb) + hidden_states_ptb = hidden_states_ptb.to(dtype) + + # linear proj + hidden_states_ptb = attn.to_out[0](hidden_states_ptb) + # dropout + hidden_states_ptb = attn.to_out[1](hidden_states_ptb) + + if input_ndim == 4: + hidden_states_ptb = hidden_states_ptb.transpose(-1, -2).reshape(batch_size, channel, height, width) + + # cat + hidden_states = torch.cat([hidden_states_org, hidden_states_ptb]) + + if attn.residual_connection: + hidden_states = hidden_states + residual + + hidden_states = hidden_states / attn.rescale_output_factor + + if hidden_states.dtype == torch.float16: + hidden_states = hidden_states.clip(-65504, 65504) + + return hidden_states + + ADDED_KV_ATTENTION_PROCESSORS = ( AttnAddedKVProcessor, SlicedAttnAddedKVProcessor, @@ -5344,4 +5562,5 @@ def __call__( LoRAXFormersAttnProcessor, LoRAAttnAddedKVProcessor, SanaLinearAttnProcessor2_0, + PAGCFGSanaLinearAttnProcessor2_0, ] diff --git a/src/diffusers/models/transformers/sana_transformer_2d.py b/src/diffusers/models/transformers/sana_transformer_2d.py index 2ba68d5eba33..a13280277f54 100644 --- a/src/diffusers/models/transformers/sana_transformer_2d.py +++ b/src/diffusers/models/transformers/sana_transformer_2d.py @@ -19,7 +19,6 @@ from ...configuration_utils import ConfigMixin, register_to_config from ...utils import is_torch_version, logging from ...utils.torch_utils import maybe_allow_in_graph -from ..attention import _chunked_feed_forward from ..attention_processor import ( Attention, AttentionProcessor, @@ -37,6 +36,21 @@ logger = logging.get_logger(__name__) # pylint: disable=invalid-name +def _chunked_feed_forward(ff: nn.Module, hidden_states: torch.Tensor, chunk_dim: int, chunk_size: int, HW: tuple=None): + # "feed_forward_chunk_size" can be used to save memory + if hidden_states.shape[chunk_dim] % chunk_size != 0: + raise ValueError( + f"`hidden_states` dimension to be chunked: {hidden_states.shape[chunk_dim]} has to be divisible by chunk size: {chunk_size}. Make sure to set an appropriate `chunk_size` when calling `unet.enable_forward_chunking`." + ) + + num_chunks = hidden_states.shape[chunk_dim] // chunk_size + ff_output = torch.cat( + [ff(hid_slice, HW) for hid_slice in hidden_states.chunk(num_chunks, dim=chunk_dim)], + dim=chunk_dim, + ) + return ff_output + + @maybe_allow_in_graph class RMSNormScaled(RMSNorm): def __init__(self, dim, eps: float, elementwise_affine: bool = True, scale_factor: float = 1.0): @@ -211,6 +225,7 @@ def forward( cross_attention_kwargs: Dict[str, Any] = None, class_labels: Optional[torch.LongTensor] = None, added_cond_kwargs: Optional[Dict[str, torch.Tensor]] = None, + HW: Optional[tuple[int]] = None, ) -> torch.Tensor: if cross_attention_kwargs is not None: if cross_attention_kwargs.get("scale", None) is not None: @@ -265,9 +280,9 @@ def forward( if self._chunk_size is not None: # "feed_forward_chunk_size" can be used to save memory - ff_output = _chunked_feed_forward(self.ff, norm_hidden_states, self._chunk_dim, self._chunk_size) + ff_output = _chunked_feed_forward(self.ff, norm_hidden_states, self._chunk_dim, self._chunk_size, HW=HW) else: - ff_output = self.ff(norm_hidden_states) + ff_output = self.ff(norm_hidden_states, HW=HW) if self.norm_type == "ada_norm_single": ff_output = gate_mlp * ff_output @@ -667,6 +682,7 @@ def custom_forward(*inputs): encoder_attention_mask, timestep, cross_attention_kwargs, + HW=(height, width), **ckpt_kwargs, ) else: @@ -678,6 +694,7 @@ def custom_forward(*inputs): timestep=timestep, cross_attention_kwargs=cross_attention_kwargs, class_labels=None, + HW=(height, width), ) # 3. Output diff --git a/src/diffusers/pipelines/__init__.py b/src/diffusers/pipelines/__init__.py index 165638d4eb8f..bbdfeed1ad15 100644 --- a/src/diffusers/pipelines/__init__.py +++ b/src/diffusers/pipelines/__init__.py @@ -181,6 +181,7 @@ "StableDiffusionXLControlNetPAGPipeline", "StableDiffusionXLPAGImg2ImgPipeline", "PixArtSigmaPAGPipeline", + "SanaPAGPipeline", ] ) _import_structure["controlnet_xs"].extend( @@ -592,6 +593,7 @@ KolorsPAGPipeline, PixArtSigmaPAGPipeline, StableDiffusion3PAGImg2ImgPipeline, + SanaPAGPipeline, StableDiffusion3PAGPipeline, StableDiffusionControlNetPAGInpaintPipeline, StableDiffusionControlNetPAGPipeline, diff --git a/src/diffusers/pipelines/pag/__init__.py b/src/diffusers/pipelines/pag/__init__.py index dfd823b0db27..0514b34c0356 100644 --- a/src/diffusers/pipelines/pag/__init__.py +++ b/src/diffusers/pipelines/pag/__init__.py @@ -29,6 +29,7 @@ _import_structure["pipeline_pag_hunyuandit"] = ["HunyuanDiTPAGPipeline"] _import_structure["pipeline_pag_kolors"] = ["KolorsPAGPipeline"] _import_structure["pipeline_pag_pixart_sigma"] = ["PixArtSigmaPAGPipeline"] + _import_structure["pipeline_pag_sana"] = ["SanaPAGPipeline"] _import_structure["pipeline_pag_sd"] = ["StableDiffusionPAGPipeline"] _import_structure["pipeline_pag_sd_3"] = ["StableDiffusion3PAGPipeline"] _import_structure["pipeline_pag_sd_3_img2img"] = ["StableDiffusion3PAGImg2ImgPipeline"] @@ -53,6 +54,7 @@ from .pipeline_pag_hunyuandit import HunyuanDiTPAGPipeline from .pipeline_pag_kolors import KolorsPAGPipeline from .pipeline_pag_pixart_sigma import PixArtSigmaPAGPipeline + from .pipeline_pag_sana import SanaPAGPipeline from .pipeline_pag_sd import StableDiffusionPAGPipeline from .pipeline_pag_sd_3 import StableDiffusion3PAGPipeline from .pipeline_pag_sd_3_img2img import StableDiffusion3PAGImg2ImgPipeline diff --git a/src/diffusers/pipelines/pag/pipeline_pag_sana.py b/src/diffusers/pipelines/pag/pipeline_pag_sana.py new file mode 100644 index 000000000000..774c63c429e5 --- /dev/null +++ b/src/diffusers/pipelines/pag/pipeline_pag_sana.py @@ -0,0 +1,873 @@ +# Copyright 2024 PixArt-Sigma Authors and The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import html +import inspect +import re +import urllib.parse as ul +from typing import Callable, List, Optional, Tuple, Union + +import torch +from transformers import AutoModelForCausalLM, AutoTokenizer + +from ...image_processor import PixArtImageProcessor +from ...models import DCAE_HF, SanaTransformer2DModel +from ...models.attention_processor import PAGCFGSanaLinearAttnProcessor2_0, PAGIdentitySanaLinearAttnProcessor2_0 +from ...schedulers import FlowDPMSolverMultistepScheduler +from ...utils import ( + BACKENDS_MAPPING, + deprecate, + is_bs4_available, + is_ftfy_available, + logging, + replace_example_docstring, +) +from ...utils.torch_utils import randn_tensor +from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput +from ..pixart_alpha.pipeline_pixart_alpha import ( + ASPECT_RATIO_256_BIN, + ASPECT_RATIO_512_BIN, + ASPECT_RATIO_1024_BIN, +) +from ..pixart_alpha.pipeline_pixart_sigma import ASPECT_RATIO_2048_BIN +from .pag_utils import PAGMixin + + +logger = logging.get_logger(__name__) # pylint: disable=invalid-name + +if is_bs4_available(): + from bs4 import BeautifulSoup + +if is_ftfy_available(): + import ftfy + + +EXAMPLE_DOC_STRING = """ + Examples: + ```py + >>> import torch + >>> from diffusers import AutoPipelineForText2Image + + >>> pipe = AutoPipelineForText2Image.from_pretrained( + ... "PixArt-alpha/PixArt-Sigma-XL-2-1024-MS", + ... torch_dtype=torch.float16, + ... pag_applied_layers=["blocks.14"], + ... enable_pag=True, + ... ) + >>> pipe = pipe.to("cuda") + + >>> prompt = "A small cactus with a happy face in the Sahara desert" + >>> image = pipe(prompt, pag_scale=4.0, guidance_scale=1.0).images[0] + ``` +""" + + +# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.retrieve_timesteps +def retrieve_timesteps( + scheduler, + num_inference_steps: Optional[int] = None, + device: Optional[Union[str, torch.device]] = None, + timesteps: Optional[List[int]] = None, + sigmas: Optional[List[float]] = None, + **kwargs, +): + r""" + Calls the scheduler's `set_timesteps` method and retrieves timesteps from the scheduler after the call. Handles + custom timesteps. Any kwargs will be supplied to `scheduler.set_timesteps`. + + Args: + scheduler (`SchedulerMixin`): + The scheduler to get timesteps from. + num_inference_steps (`int`): + The number of diffusion steps used when generating samples with a pre-trained model. If used, `timesteps` + must be `None`. + device (`str` or `torch.device`, *optional*): + The device to which the timesteps should be moved to. If `None`, the timesteps are not moved. + timesteps (`List[int]`, *optional*): + Custom timesteps used to override the timestep spacing strategy of the scheduler. If `timesteps` is passed, + `num_inference_steps` and `sigmas` must be `None`. + sigmas (`List[float]`, *optional*): + Custom sigmas used to override the timestep spacing strategy of the scheduler. If `sigmas` is passed, + `num_inference_steps` and `timesteps` must be `None`. + + Returns: + `Tuple[torch.Tensor, int]`: A tuple where the first element is the timestep schedule from the scheduler and the + second element is the number of inference steps. + """ + if timesteps is not None and sigmas is not None: + raise ValueError("Only one of `timesteps` or `sigmas` can be passed. Please choose one to set custom values") + if timesteps is not None: + accepts_timesteps = "timesteps" in set(inspect.signature(scheduler.set_timesteps).parameters.keys()) + if not accepts_timesteps: + raise ValueError( + f"The current scheduler class {scheduler.__class__}'s `set_timesteps` does not support custom" + f" timestep schedules. Please check whether you are using the correct scheduler." + ) + scheduler.set_timesteps(timesteps=timesteps, device=device, **kwargs) + timesteps = scheduler.timesteps + num_inference_steps = len(timesteps) + elif sigmas is not None: + accept_sigmas = "sigmas" in set(inspect.signature(scheduler.set_timesteps).parameters.keys()) + if not accept_sigmas: + raise ValueError( + f"The current scheduler class {scheduler.__class__}'s `set_timesteps` does not support custom" + f" sigmas schedules. Please check whether you are using the correct scheduler." + ) + scheduler.set_timesteps(sigmas=sigmas, device=device, **kwargs) + timesteps = scheduler.timesteps + num_inference_steps = len(timesteps) + else: + scheduler.set_timesteps(num_inference_steps, device=device, **kwargs) + timesteps = scheduler.timesteps + return timesteps, num_inference_steps + + +class SanaPAGPipeline(DiffusionPipeline, PAGMixin): + r""" + [PAG pipeline](https://huggingface.co/docs/diffusers/main/en/using-diffusers/pag) for text-to-image generation + using PixArt-Sigma. + """ + + bad_punct_regex = re.compile( + r"[" + + "#®•©™&@·º½¾¿¡§~" + + r"\)" + + r"\(" + + r"\]" + + r"\[" + + r"\}" + + r"\{" + + r"\|" + + "\\" + + r"\/" + + r"\*" + + r"]{1,}" + ) # noqa + + _optional_components = ["tokenizer", "text_encoder"] + model_cpu_offload_seq = "text_encoder->transformer->vae" + + def __init__( + self, + tokenizer: AutoTokenizer, + text_encoder: AutoModelForCausalLM, + vae: DCAE_HF, + transformer: SanaTransformer2DModel, + scheduler: FlowDPMSolverMultistepScheduler, + pag_applied_layers: Union[str, List[str]] = "blocks.1", # 1st transformer block + ): + super().__init__() + + self.register_modules( + tokenizer=tokenizer, text_encoder=text_encoder, vae=vae, transformer=transformer, scheduler=scheduler + ) + + self.vae_scale_factor = 2 ** (len(self.vae.config.encoder_width_list) - 1) + self.image_processor = PixArtImageProcessor(vae_scale_factor=self.vae_scale_factor) + + self.set_pag_applied_layers( + pag_applied_layers, pag_attn_processors=(PAGCFGSanaLinearAttnProcessor2_0(), PAGIdentitySanaLinearAttnProcessor2_0()) + ) + + # Copied from diffusers.pipelines.pixart_alpha.pipeline_pixart_alpha.PixArtAlphaPipeline.encode_prompt with 120->300 + def encode_prompt( + self, + prompt: Union[str, List[str]], + do_classifier_free_guidance: bool = True, + negative_prompt: str = "", + num_images_per_prompt: int = 1, + device: Optional[torch.device] = None, + prompt_embeds: Optional[torch.Tensor] = None, + negative_prompt_embeds: Optional[torch.Tensor] = None, + prompt_attention_mask: Optional[torch.Tensor] = None, + negative_prompt_attention_mask: Optional[torch.Tensor] = None, + clean_caption: bool = False, + max_sequence_length: int = 300, + **kwargs, + ): + r""" + Encodes the prompt into text encoder hidden states. + + Args: + prompt (`str` or `List[str]`, *optional*): + prompt to be encoded + negative_prompt (`str` or `List[str]`, *optional*): + The prompt not to guide the image generation. If not defined, one has to pass `negative_prompt_embeds` + instead. Ignored when not using guidance (i.e., ignored if `guidance_scale` is less than `1`). For + PixArt-Alpha, this should be "". + do_classifier_free_guidance (`bool`, *optional*, defaults to `True`): + whether to use classifier free guidance or not + num_images_per_prompt (`int`, *optional*, defaults to 1): + number of images that should be generated per prompt + device: (`torch.device`, *optional*): + torch device to place the resulting embeddings on + prompt_embeds (`torch.Tensor`, *optional*): + Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not + provided, text embeddings will be generated from `prompt` input argument. + negative_prompt_embeds (`torch.Tensor`, *optional*): + Pre-generated negative text embeddings. For PixArt-Alpha, it's should be the embeddings of the "" + string. + clean_caption (`bool`, defaults to `False`): + If `True`, the function will preprocess and clean the provided caption before encoding. + max_sequence_length (`int`, defaults to 300): Maximum sequence length to use for the prompt. + """ + + if "mask_feature" in kwargs: + deprecation_message = "The use of `mask_feature` is deprecated. It is no longer used in any computation and that doesn't affect the end results. It will be removed in a future version." + deprecate("mask_feature", "1.0.0", deprecation_message, standard_warn=False) + + if device is None: + device = self._execution_device + + if prompt is not None and isinstance(prompt, str): + batch_size = 1 + elif prompt is not None and isinstance(prompt, list): + batch_size = len(prompt) + else: + batch_size = prompt_embeds.shape[0] + + # See Section 3.1. of the paper. + max_length = max_sequence_length + + if prompt_embeds is None: + prompt = self._text_preprocessing(prompt, clean_caption=clean_caption) + text_inputs = self.tokenizer( + prompt, + padding="max_length", + max_length=max_length, + truncation=True, + add_special_tokens=True, + return_tensors="pt", + ) + text_input_ids = text_inputs.input_ids + untruncated_ids = self.tokenizer(prompt, padding="longest", return_tensors="pt").input_ids + + if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal( + text_input_ids, untruncated_ids + ): + removed_text = self.tokenizer.batch_decode(untruncated_ids[:, max_length - 1 : -1]) + logger.warning( + "The following part of your input was truncated because T5 can only handle sequences up to" + f" {max_length} tokens: {removed_text}" + ) + + prompt_attention_mask = text_inputs.attention_mask + prompt_attention_mask = prompt_attention_mask.to(device) + + prompt_embeds = self.text_encoder(text_input_ids.to(device), attention_mask=prompt_attention_mask) + prompt_embeds = prompt_embeds[0] + + if self.transformer is not None: + dtype = self.transformer.dtype + elif self.text_encoder is not None: + dtype = self.text_encoder.dtype + else: + dtype = None + + prompt_embeds = prompt_embeds.to(dtype=dtype, device=device) + + bs_embed, seq_len, _ = prompt_embeds.shape + # duplicate text embeddings and attention mask for each generation per prompt, using mps friendly method + prompt_embeds = prompt_embeds.repeat(1, num_images_per_prompt, 1) + prompt_embeds = prompt_embeds.view(bs_embed * num_images_per_prompt, seq_len, -1) + prompt_attention_mask = prompt_attention_mask.view(bs_embed, -1) + prompt_attention_mask = prompt_attention_mask.repeat(num_images_per_prompt, 1) + + # get unconditional embeddings for classifier free guidance + if do_classifier_free_guidance and negative_prompt_embeds is None: + uncond_tokens = [negative_prompt] * batch_size if isinstance(negative_prompt, str) else negative_prompt + uncond_tokens = self._text_preprocessing(uncond_tokens, clean_caption=clean_caption) + max_length = prompt_embeds.shape[1] + uncond_input = self.tokenizer( + uncond_tokens, + padding="max_length", + max_length=max_length, + truncation=True, + return_attention_mask=True, + add_special_tokens=True, + return_tensors="pt", + ) + negative_prompt_attention_mask = uncond_input.attention_mask + negative_prompt_attention_mask = negative_prompt_attention_mask.to(device) + + negative_prompt_embeds = self.text_encoder( + uncond_input.input_ids.to(device), attention_mask=negative_prompt_attention_mask + ) + negative_prompt_embeds = negative_prompt_embeds[0] + + if do_classifier_free_guidance: + # duplicate unconditional embeddings for each generation per prompt, using mps friendly method + seq_len = negative_prompt_embeds.shape[1] + + negative_prompt_embeds = negative_prompt_embeds.to(dtype=dtype, device=device) + + negative_prompt_embeds = negative_prompt_embeds.repeat(1, num_images_per_prompt, 1) + negative_prompt_embeds = negative_prompt_embeds.view(batch_size * num_images_per_prompt, seq_len, -1) + + negative_prompt_attention_mask = negative_prompt_attention_mask.view(bs_embed, -1) + negative_prompt_attention_mask = negative_prompt_attention_mask.repeat(num_images_per_prompt, 1) + else: + negative_prompt_embeds = None + negative_prompt_attention_mask = None + + return prompt_embeds, prompt_attention_mask, negative_prompt_embeds, negative_prompt_attention_mask + + # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.prepare_extra_step_kwargs + def prepare_extra_step_kwargs(self, generator, eta): + # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature + # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers. + # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502 + # and should be between [0, 1] + + accepts_eta = "eta" in set(inspect.signature(self.scheduler.step).parameters.keys()) + extra_step_kwargs = {} + if accepts_eta: + extra_step_kwargs["eta"] = eta + + # check if the scheduler accepts generator + accepts_generator = "generator" in set(inspect.signature(self.scheduler.step).parameters.keys()) + if accepts_generator: + extra_step_kwargs["generator"] = generator + return extra_step_kwargs + + # Copied from diffusers.pipelines.pixart_alpha.pipeline_pixart_alpha.PixArtAlphaPipeline.check_inputs + def check_inputs( + self, + prompt, + height, + width, + negative_prompt, + callback_steps, + prompt_embeds=None, + negative_prompt_embeds=None, + prompt_attention_mask=None, + negative_prompt_attention_mask=None, + ): + if height % 8 != 0 or width % 8 != 0: + raise ValueError(f"`height` and `width` have to be divisible by 8 but are {height} and {width}.") + + if (callback_steps is None) or ( + callback_steps is not None and (not isinstance(callback_steps, int) or callback_steps <= 0) + ): + raise ValueError( + f"`callback_steps` has to be a positive integer but is {callback_steps} of type" + f" {type(callback_steps)}." + ) + + if prompt is not None and prompt_embeds is not None: + raise ValueError( + f"Cannot forward both `prompt`: {prompt} and `prompt_embeds`: {prompt_embeds}. Please make sure to" + " only forward one of the two." + ) + elif prompt is None and prompt_embeds is None: + raise ValueError( + "Provide either `prompt` or `prompt_embeds`. Cannot leave both `prompt` and `prompt_embeds` undefined." + ) + elif prompt is not None and (not isinstance(prompt, str) and not isinstance(prompt, list)): + raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}") + + if prompt is not None and negative_prompt_embeds is not None: + raise ValueError( + f"Cannot forward both `prompt`: {prompt} and `negative_prompt_embeds`:" + f" {negative_prompt_embeds}. Please make sure to only forward one of the two." + ) + + if negative_prompt is not None and negative_prompt_embeds is not None: + raise ValueError( + f"Cannot forward both `negative_prompt`: {negative_prompt} and `negative_prompt_embeds`:" + f" {negative_prompt_embeds}. Please make sure to only forward one of the two." + ) + + if prompt_embeds is not None and prompt_attention_mask is None: + raise ValueError("Must provide `prompt_attention_mask` when specifying `prompt_embeds`.") + + if negative_prompt_embeds is not None and negative_prompt_attention_mask is None: + raise ValueError("Must provide `negative_prompt_attention_mask` when specifying `negative_prompt_embeds`.") + + if prompt_embeds is not None and negative_prompt_embeds is not None: + if prompt_embeds.shape != negative_prompt_embeds.shape: + raise ValueError( + "`prompt_embeds` and `negative_prompt_embeds` must have the same shape when passed directly, but" + f" got: `prompt_embeds` {prompt_embeds.shape} != `negative_prompt_embeds`" + f" {negative_prompt_embeds.shape}." + ) + if prompt_attention_mask.shape != negative_prompt_attention_mask.shape: + raise ValueError( + "`prompt_attention_mask` and `negative_prompt_attention_mask` must have the same shape when passed directly, but" + f" got: `prompt_attention_mask` {prompt_attention_mask.shape} != `negative_prompt_attention_mask`" + f" {negative_prompt_attention_mask.shape}." + ) + + # Copied from diffusers.pipelines.deepfloyd_if.pipeline_if.IFPipeline._text_preprocessing + def _text_preprocessing(self, text, clean_caption=False): + if clean_caption and not is_bs4_available(): + logger.warning(BACKENDS_MAPPING["bs4"][-1].format("Setting `clean_caption=True`")) + logger.warning("Setting `clean_caption` to False...") + clean_caption = False + + if clean_caption and not is_ftfy_available(): + logger.warning(BACKENDS_MAPPING["ftfy"][-1].format("Setting `clean_caption=True`")) + logger.warning("Setting `clean_caption` to False...") + clean_caption = False + + if not isinstance(text, (tuple, list)): + text = [text] + + def process(text: str): + if clean_caption: + text = self._clean_caption(text) + text = self._clean_caption(text) + else: + text = text.lower().strip() + return text + + return [process(t) for t in text] + + # Copied from diffusers.pipelines.deepfloyd_if.pipeline_if.IFPipeline._clean_caption + def _clean_caption(self, caption): + caption = str(caption) + caption = ul.unquote_plus(caption) + caption = caption.strip().lower() + caption = re.sub("", "person", caption) + # urls: + caption = re.sub( + r"\b((?:https?:(?:\/{1,3}|[a-zA-Z0-9%])|[a-zA-Z0-9.\-]+[.](?:com|co|ru|net|org|edu|gov|it)[\w/-]*\b\/?(?!@)))", # noqa + "", + caption, + ) # regex for urls + caption = re.sub( + r"\b((?:www:(?:\/{1,3}|[a-zA-Z0-9%])|[a-zA-Z0-9.\-]+[.](?:com|co|ru|net|org|edu|gov|it)[\w/-]*\b\/?(?!@)))", # noqa + "", + caption, + ) # regex for urls + # html: + caption = BeautifulSoup(caption, features="html.parser").text + + # @ + caption = re.sub(r"@[\w\d]+\b", "", caption) + + # 31C0—31EF CJK Strokes + # 31F0—31FF Katakana Phonetic Extensions + # 3200—32FF Enclosed CJK Letters and Months + # 3300—33FF CJK Compatibility + # 3400—4DBF CJK Unified Ideographs Extension A + # 4DC0—4DFF Yijing Hexagram Symbols + # 4E00—9FFF CJK Unified Ideographs + caption = re.sub(r"[\u31c0-\u31ef]+", "", caption) + caption = re.sub(r"[\u31f0-\u31ff]+", "", caption) + caption = re.sub(r"[\u3200-\u32ff]+", "", caption) + caption = re.sub(r"[\u3300-\u33ff]+", "", caption) + caption = re.sub(r"[\u3400-\u4dbf]+", "", caption) + caption = re.sub(r"[\u4dc0-\u4dff]+", "", caption) + caption = re.sub(r"[\u4e00-\u9fff]+", "", caption) + ####################################################### + + # все виды тире / all types of dash --> "-" + caption = re.sub( + r"[\u002D\u058A\u05BE\u1400\u1806\u2010-\u2015\u2E17\u2E1A\u2E3A\u2E3B\u2E40\u301C\u3030\u30A0\uFE31\uFE32\uFE58\uFE63\uFF0D]+", # noqa + "-", + caption, + ) + + # кавычки к одному стандарту + caption = re.sub(r"[`´«»“”¨]", '"', caption) + caption = re.sub(r"[‘’]", "'", caption) + + # " + caption = re.sub(r""?", "", caption) + # & + caption = re.sub(r"&", "", caption) + + # ip adresses: + caption = re.sub(r"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}", " ", caption) + + # article ids: + caption = re.sub(r"\d:\d\d\s+$", "", caption) + + # \n + caption = re.sub(r"\\n", " ", caption) + + # "#123" + caption = re.sub(r"#\d{1,3}\b", "", caption) + # "#12345.." + caption = re.sub(r"#\d{5,}\b", "", caption) + # "123456.." + caption = re.sub(r"\b\d{6,}\b", "", caption) + # filenames: + caption = re.sub(r"[\S]+\.(?:png|jpg|jpeg|bmp|webp|eps|pdf|apk|mp4)", "", caption) + + # + caption = re.sub(r"[\"\']{2,}", r'"', caption) # """AUSVERKAUFT""" + caption = re.sub(r"[\.]{2,}", r" ", caption) # """AUSVERKAUFT""" + + caption = re.sub(self.bad_punct_regex, r" ", caption) # ***AUSVERKAUFT***, #AUSVERKAUFT + caption = re.sub(r"\s+\.\s+", r" ", caption) # " . " + + # this-is-my-cute-cat / this_is_my_cute_cat + regex2 = re.compile(r"(?:\-|\_)") + if len(re.findall(regex2, caption)) > 3: + caption = re.sub(regex2, " ", caption) + + caption = ftfy.fix_text(caption) + caption = html.unescape(html.unescape(caption)) + + caption = re.sub(r"\b[a-zA-Z]{1,3}\d{3,15}\b", "", caption) # jc6640 + caption = re.sub(r"\b[a-zA-Z]+\d+[a-zA-Z]+\b", "", caption) # jc6640vc + caption = re.sub(r"\b\d+[a-zA-Z]+\d+\b", "", caption) # 6640vc231 + + caption = re.sub(r"(worldwide\s+)?(free\s+)?shipping", "", caption) + caption = re.sub(r"(free\s)?download(\sfree)?", "", caption) + caption = re.sub(r"\bclick\b\s(?:for|on)\s\w+", "", caption) + caption = re.sub(r"\b(?:png|jpg|jpeg|bmp|webp|eps|pdf|apk|mp4)(\simage[s]?)?", "", caption) + caption = re.sub(r"\bpage\s+\d+\b", "", caption) + + caption = re.sub(r"\b\d*[a-zA-Z]+\d+[a-zA-Z]+\d+[a-zA-Z\d]*\b", r" ", caption) # j2d1a2a... + + caption = re.sub(r"\b\d+\.?\d*[xх×]\d+\.?\d*\b", "", caption) + + caption = re.sub(r"\b\s+\:\s+", r": ", caption) + caption = re.sub(r"(\D[,\./])\b", r"\1 ", caption) + caption = re.sub(r"\s+", " ", caption) + + caption.strip() + + caption = re.sub(r"^[\"\']([\w\W]+)[\"\']$", r"\1", caption) + caption = re.sub(r"^[\'\_,\-\:;]", r"", caption) + caption = re.sub(r"[\'\_,\-\:\-\+]$", r"", caption) + caption = re.sub(r"^\.\S+$", "", caption) + + return caption.strip() + + # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.prepare_latents + def prepare_latents(self, batch_size, num_channels_latents, height, width, dtype, device, generator, latents=None): + shape = ( + batch_size, + num_channels_latents, + int(height) // self.vae_scale_factor, + int(width) // self.vae_scale_factor, + ) + if isinstance(generator, list) and len(generator) != batch_size: + raise ValueError( + f"You have passed a list of generators of length {len(generator)}, but requested an effective batch" + f" size of {batch_size}. Make sure the batch size matches the length of the generators." + ) + + if latents is None: + latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype) + else: + latents = latents.to(device) + + return latents + + @torch.no_grad() + @replace_example_docstring(EXAMPLE_DOC_STRING) + def __call__( + self, + prompt: Union[str, List[str]] = None, + negative_prompt: str = "", + num_inference_steps: int = 20, + timesteps: List[int] = None, + sigmas: List[float] = None, + guidance_scale: float = 4.5, + num_images_per_prompt: Optional[int] = 1, + height: Optional[int] = None, + width: Optional[int] = None, + eta: float = 0.0, + generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None, + latents: Optional[torch.Tensor] = None, + prompt_embeds: Optional[torch.Tensor] = None, + prompt_attention_mask: Optional[torch.Tensor] = None, + negative_prompt_embeds: Optional[torch.Tensor] = None, + negative_prompt_attention_mask: Optional[torch.Tensor] = None, + output_type: Optional[str] = "pil", + return_dict: bool = True, + callback: Optional[Callable[[int, int, torch.Tensor], None]] = None, + callback_steps: int = 1, + clean_caption: bool = True, + use_resolution_binning: bool = True, + max_sequence_length: int = 300, + pag_scale: float = 3.0, + pag_adaptive_scale: float = 0.0, + ) -> Union[ImagePipelineOutput, Tuple]: + """ + Function invoked when calling the pipeline for generation. + + Args: + prompt (`str` or `List[str]`, *optional*): + The prompt or prompts to guide the image generation. If not defined, one has to pass `prompt_embeds`. + instead. + negative_prompt (`str` or `List[str]`, *optional*): + The prompt or prompts not to guide the image generation. If not defined, one has to pass + `negative_prompt_embeds` instead. Ignored when not using guidance (i.e., ignored if `guidance_scale` is + less than `1`). + num_inference_steps (`int`, *optional*, defaults to 100): + The number of denoising steps. More denoising steps usually lead to a higher quality image at the + expense of slower inference. + timesteps (`List[int]`, *optional*): + Custom timesteps to use for the denoising process with schedulers which support a `timesteps` argument + in their `set_timesteps` method. If not defined, the default behavior when `num_inference_steps` is + passed will be used. Must be in descending order. + sigmas (`List[float]`, *optional*): + Custom sigmas to use for the denoising process with schedulers which support a `sigmas` argument in + their `set_timesteps` method. If not defined, the default behavior when `num_inference_steps` is passed + will be used. + guidance_scale (`float`, *optional*, defaults to 4.5): + Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598). + `guidance_scale` is defined as `w` of equation 2. of [Imagen + Paper](https://arxiv.org/pdf/2205.11487.pdf). Guidance scale is enabled by setting `guidance_scale > + 1`. Higher guidance scale encourages to generate images that are closely linked to the text `prompt`, + usually at the expense of lower image quality. + num_images_per_prompt (`int`, *optional*, defaults to 1): + The number of images to generate per prompt. + height (`int`, *optional*, defaults to self.unet.config.sample_size): + The height in pixels of the generated image. + width (`int`, *optional*, defaults to self.unet.config.sample_size): + The width in pixels of the generated image. + eta (`float`, *optional*, defaults to 0.0): + Corresponds to parameter eta (η) in the DDIM paper: https://arxiv.org/abs/2010.02502. Only applies to + [`schedulers.DDIMScheduler`], will be ignored for others. + generator (`torch.Generator` or `List[torch.Generator]`, *optional*): + One or a list of [torch generator(s)](https://pytorch.org/docs/stable/generated/torch.Generator.html) + to make generation deterministic. + latents (`torch.Tensor`, *optional*): + Pre-generated noisy latents, sampled from a Gaussian distribution, to be used as inputs for image + generation. Can be used to tweak the same generation with different prompts. If not provided, a latents + tensor will ge generated by sampling using the supplied random `generator`. + prompt_embeds (`torch.Tensor`, *optional*): + Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not + provided, text embeddings will be generated from `prompt` input argument. + prompt_attention_mask (`torch.Tensor`, *optional*): Pre-generated attention mask for text embeddings. + negative_prompt_embeds (`torch.Tensor`, *optional*): + Pre-generated negative text embeddings. For PixArt-Sigma this negative prompt should be "". If not + provided, negative_prompt_embeds will be generated from `negative_prompt` input argument. + negative_prompt_attention_mask (`torch.Tensor`, *optional*): + Pre-generated attention mask for negative text embeddings. + output_type (`str`, *optional*, defaults to `"pil"`): + The output format of the generate image. Choose between + [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` or `np.array`. + return_dict (`bool`, *optional*, defaults to `True`): + Whether or not to return a [`~pipelines.stable_diffusion.IFPipelineOutput`] instead of a plain tuple. + callback (`Callable`, *optional*): + A function that will be called every `callback_steps` steps during inference. The function will be + called with the following arguments: `callback(step: int, timestep: int, latents: torch.Tensor)`. + callback_steps (`int`, *optional*, defaults to 1): + The frequency at which the `callback` function will be called. If not specified, the callback will be + called at every step. + clean_caption (`bool`, *optional*, defaults to `True`): + Whether or not to clean the caption before creating embeddings. Requires `beautifulsoup4` and `ftfy` to + be installed. If the dependencies are not installed, the embeddings will be created from the raw + prompt. + use_resolution_binning (`bool` defaults to `True`): + If set to `True`, the requested height and width are first mapped to the closest resolutions using + `ASPECT_RATIO_1024_BIN`. After the produced latents are decoded into images, they are resized back to + the requested resolution. Useful for generating non-square images. + max_sequence_length (`int` defaults to 300): Maximum sequence length to use with the `prompt`. + pag_scale (`float`, *optional*, defaults to 3.0): + The scale factor for the perturbed attention guidance. If it is set to 0.0, the perturbed attention + guidance will not be used. + pag_adaptive_scale (`float`, *optional*, defaults to 0.0): + The adaptive scale factor for the perturbed attention guidance. If it is set to 0.0, `pag_scale` is + used. + Examples: + + Returns: + [`~pipelines.ImagePipelineOutput`] or `tuple`: + If `return_dict` is `True`, [`~pipelines.ImagePipelineOutput`] is returned, otherwise a `tuple` is + returned where the first element is a list with the generated images + """ + # 1. Check inputs. Raise error if not correct + height = height or self.transformer.config.sample_size * self.vae_scale_factor + width = width or self.transformer.config.sample_size * self.vae_scale_factor + if use_resolution_binning: + if self.transformer.config.sample_size == 64: + aspect_ratio_bin = ASPECT_RATIO_2048_BIN + elif self.transformer.config.sample_size == 32: + aspect_ratio_bin = ASPECT_RATIO_1024_BIN + elif self.transformer.config.sample_size == 16: + aspect_ratio_bin = ASPECT_RATIO_512_BIN + else: + raise ValueError("Invalid sample size") + orig_height, orig_width = height, width + height, width = self.image_processor.classify_height_width_bin(height, width, ratios=aspect_ratio_bin) + + self.check_inputs( + prompt, + height, + width, + negative_prompt, + callback_steps, + prompt_embeds, + negative_prompt_embeds, + prompt_attention_mask, + negative_prompt_attention_mask, + ) + self._pag_scale = pag_scale + self._pag_adaptive_scale = pag_adaptive_scale + + # 2. Default height and width to transformer + if prompt is not None and isinstance(prompt, str): + batch_size = 1 + elif prompt is not None and isinstance(prompt, list): + batch_size = len(prompt) + else: + batch_size = prompt_embeds.shape[0] + + device = self._execution_device + + # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2) + # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1` + # corresponds to doing no classifier free guidance. + do_classifier_free_guidance = guidance_scale > 1.0 + + # 3. Encode input prompt + ( + prompt_embeds, + prompt_attention_mask, + negative_prompt_embeds, + negative_prompt_attention_mask, + ) = self.encode_prompt( + prompt, + do_classifier_free_guidance, + negative_prompt=negative_prompt, + num_images_per_prompt=num_images_per_prompt, + device=device, + prompt_embeds=prompt_embeds, + negative_prompt_embeds=negative_prompt_embeds, + prompt_attention_mask=prompt_attention_mask, + negative_prompt_attention_mask=negative_prompt_attention_mask, + clean_caption=clean_caption, + max_sequence_length=max_sequence_length, + ) + if self.do_perturbed_attention_guidance: + prompt_embeds = self._prepare_perturbed_attention_guidance( + prompt_embeds, negative_prompt_embeds, do_classifier_free_guidance + ) + prompt_attention_mask = self._prepare_perturbed_attention_guidance( + prompt_attention_mask, negative_prompt_attention_mask, do_classifier_free_guidance + ) + elif do_classifier_free_guidance: + prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds], dim=0) + prompt_attention_mask = torch.cat([negative_prompt_attention_mask, prompt_attention_mask], dim=0) + + # 4. Prepare timesteps + timesteps, num_inference_steps = retrieve_timesteps( + self.scheduler, num_inference_steps, device, timesteps, sigmas + ) + + # 5. Prepare latents. + latent_channels = self.transformer.config.in_channels + latents = self.prepare_latents( + batch_size * num_images_per_prompt, + latent_channels, + height, + width, + prompt_embeds.dtype, + device, + generator, + latents, + ) + if self.do_perturbed_attention_guidance: + original_attn_proc = self.transformer.attn_processors + self._set_pag_attn_processor( + pag_applied_layers=self.pag_applied_layers, + do_classifier_free_guidance=do_classifier_free_guidance, + ) + + # 6. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline + extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta) + + # 6.1 Prepare micro-conditions. + added_cond_kwargs = {"resolution": None, "aspect_ratio": None} + + # 7. Denoising loop + num_warmup_steps = max(len(timesteps) - num_inference_steps * self.scheduler.order, 0) + + with self.progress_bar(total=num_inference_steps) as progress_bar: + for i, t in enumerate(timesteps): + # expand the latents if we are doing classifier free guidance, perturbed-attention guidance, or both + latent_model_input = torch.cat([latents] * (prompt_embeds.shape[0] // latents.shape[0])) + latent_model_input = self.scheduler.scale_model_input(latent_model_input, t) + + current_timestep = t + if not torch.is_tensor(current_timestep): + # TODO: this requires sync between CPU and GPU. So try to pass timesteps as tensors if you can + # This would be a good case for the `match` statement (Python 3.10+) + is_mps = latent_model_input.device.type == "mps" + if isinstance(current_timestep, float): + dtype = torch.float32 if is_mps else torch.float64 + else: + dtype = torch.int32 if is_mps else torch.int64 + current_timestep = torch.tensor([current_timestep], dtype=dtype, device=latent_model_input.device) + elif len(current_timestep.shape) == 0: + current_timestep = current_timestep[None].to(latent_model_input.device) + # broadcast to batch dimension in a way that's compatible with ONNX/Core ML + current_timestep = current_timestep.expand(latent_model_input.shape[0]) + + # predict noise model_output + noise_pred = self.transformer( + latent_model_input, + encoder_hidden_states=prompt_embeds, + encoder_attention_mask=prompt_attention_mask, + timestep=current_timestep, + added_cond_kwargs=added_cond_kwargs, + return_dict=False, + )[0] + + # perform guidance + if self.do_perturbed_attention_guidance: + noise_pred = self._apply_perturbed_attention_guidance( + noise_pred, do_classifier_free_guidance, guidance_scale, current_timestep + ) + elif do_classifier_free_guidance: + noise_pred_uncond, noise_pred_text = noise_pred.chunk(2) + noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) + + # learned sigma + if self.transformer.config.out_channels // 2 == latent_channels: + noise_pred = noise_pred.chunk(2, dim=1)[0] + else: + noise_pred = noise_pred + + # compute previous image: x_t -> x_t-1 + print(height, width, latents.shape) + latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs, return_dict=False)[0] + + # call the callback, if provided + if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0): + progress_bar.update() + if callback is not None and i % callback_steps == 0: + step_idx = i // getattr(self.scheduler, "order", 1) + callback(step_idx, t, latents) + # set to None for next + + if not output_type == "latent": + image = self.vae.decode(latents.to(self.vae.dtype) / self.vae.config.scaling_factor) + if use_resolution_binning: + image = self.image_processor.resize_and_crop_tensor(image, orig_width, orig_height) + else: + image = latents + + if not output_type == "latent": + image = self.image_processor.postprocess(image, output_type=output_type) + + # Offload all models + self.maybe_free_model_hooks() + + if self.do_perturbed_attention_guidance: + self.transformer.set_attn_processor(original_attn_proc) + + if not return_dict: + return (image,) + + return ImagePipelineOutput(images=image) diff --git a/src/diffusers/pipelines/sana/pipeline_sana.py b/src/diffusers/pipelines/sana/pipeline_sana.py index 995d4ab92f07..db093c0b8f8f 100644 --- a/src/diffusers/pipelines/sana/pipeline_sana.py +++ b/src/diffusers/pipelines/sana/pipeline_sana.py @@ -50,59 +50,15 @@ import ftfy -ASPECT_RATIO_2048_BIN = { - "0.25": [1024.0, 4096.0], - "0.26": [1024.0, 3968.0], - "0.27": [1024.0, 3840.0], - "0.28": [1024.0, 3712.0], - "0.32": [1152.0, 3584.0], - "0.33": [1152.0, 3456.0], - "0.35": [1152.0, 3328.0], - "0.4": [1280.0, 3200.0], - "0.42": [1280.0, 3072.0], - "0.48": [1408.0, 2944.0], - "0.5": [1408.0, 2816.0], - "0.52": [1408.0, 2688.0], - "0.57": [1536.0, 2688.0], - "0.6": [1536.0, 2560.0], - "0.68": [1664.0, 2432.0], - "0.72": [1664.0, 2304.0], - "0.78": [1792.0, 2304.0], - "0.82": [1792.0, 2176.0], - "0.88": [1920.0, 2176.0], - "0.94": [1920.0, 2048.0], - "1.0": [2048.0, 2048.0], - "1.07": [2048.0, 1920.0], - "1.13": [2176.0, 1920.0], - "1.21": [2176.0, 1792.0], - "1.29": [2304.0, 1792.0], - "1.38": [2304.0, 1664.0], - "1.46": [2432.0, 1664.0], - "1.67": [2560.0, 1536.0], - "1.75": [2688.0, 1536.0], - "2.0": [2816.0, 1408.0], - "2.09": [2944.0, 1408.0], - "2.4": [3072.0, 1280.0], - "2.5": [3200.0, 1280.0], - "2.89": [3328.0, 1152.0], - "3.0": [3456.0, 1152.0], - "3.11": [3584.0, 1152.0], - "3.62": [3712.0, 1024.0], - "3.75": [3840.0, 1024.0], - "3.88": [3968.0, 1024.0], - "4.0": [4096.0, 1024.0], -} - - EXAMPLE_DOC_STRING = """ Examples: ```py >>> import torch - >>> from diffusers import PixArtSigmaPipeline + >>> from diffusers import SanaPipeline - >>> # You can replace the checkpoint id with "PixArt-alpha/PixArt-Sigma-XL-2-512-MS" too. - >>> pipe = PixArtSigmaPipeline.from_pretrained( - ... "PixArt-alpha/PixArt-Sigma-XL-2-1024-MS", torch_dtype=torch.float16 + >>> # You can replace the checkpoint id with "Sana_1600M_1024px/Sana_1600M_1024px" too. + >>> pipe = SanaPipeline.from_pretrained( + ... "Sana_1600M_1024px/Sana_1600M_1024px", torch_dtype=torch.float16 ... ) >>> # Enable memory optimizations. >>> # pipe.enable_model_cpu_offload() diff --git a/src/diffusers/schedulers/scheduling_dpmsolver_multistep_flow.py b/src/diffusers/schedulers/scheduling_dpmsolver_multistep_flow.py index 4f407586a5be..b5a666f38bac 100644 --- a/src/diffusers/schedulers/scheduling_dpmsolver_multistep_flow.py +++ b/src/diffusers/schedulers/scheduling_dpmsolver_multistep_flow.py @@ -226,6 +226,11 @@ def set_timesteps( self.num_inference_steps = len(timesteps) + self.model_outputs = [ + None, + ] * self.config.solver_order + self.lower_order_nums = 0 + self._step_index = None self._begin_index = None self.sigmas = self.sigmas.to("cpu") # to avoid too much CPU/GPU communication From 48e45016b96db3df34f2bc549021e27b0e3ba1c0 Mon Sep 17 00:00:00 2001 From: junsong Date: Fri, 15 Nov 2024 04:08:28 -0800 Subject: [PATCH 090/141] remove prints; --- src/diffusers/pipelines/pag/pipeline_pag_sana.py | 1 - 1 file changed, 1 deletion(-) diff --git a/src/diffusers/pipelines/pag/pipeline_pag_sana.py b/src/diffusers/pipelines/pag/pipeline_pag_sana.py index 774c63c429e5..73a666342423 100644 --- a/src/diffusers/pipelines/pag/pipeline_pag_sana.py +++ b/src/diffusers/pipelines/pag/pipeline_pag_sana.py @@ -840,7 +840,6 @@ def __call__( noise_pred = noise_pred # compute previous image: x_t -> x_t-1 - print(height, width, latents.shape) latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs, return_dict=False)[0] # call the callback, if provided From 5870055eb47226f658c091a9bf2217ed23158c78 Mon Sep 17 00:00:00 2001 From: junsongc Date: Thu, 21 Nov 2024 14:57:30 +0800 Subject: [PATCH 091/141] add convert sana official checkpoint to diffusers format Safetensor. --- scripts/convert_sana_pag_to_diffusers.py | 301 +++++++++++++++++++++++ scripts/convert_sana_to_diffusers.py | 299 ++++++++++++++++++++++ 2 files changed, 600 insertions(+) create mode 100644 scripts/convert_sana_pag_to_diffusers.py create mode 100644 scripts/convert_sana_to_diffusers.py diff --git a/scripts/convert_sana_pag_to_diffusers.py b/scripts/convert_sana_pag_to_diffusers.py new file mode 100644 index 000000000000..cf550a1a995d --- /dev/null +++ b/scripts/convert_sana_pag_to_diffusers.py @@ -0,0 +1,301 @@ +#!/usr/bin/env python +from __future__ import annotations + +import argparse +import os +from contextlib import nullcontext + +import torch +from accelerate import init_empty_weights +from diffusers import ( + DCAE, + DCAE_HF, + FlowDPMSolverMultistepScheduler, + FlowMatchEulerDiscreteScheduler, + SanaPAGPipeline, + SanaTransformer2DModel, +) +from diffusers.models.modeling_utils import load_model_dict_into_meta +from diffusers.utils.import_utils import is_accelerate_available +from termcolor import colored +from transformers import AutoModelForCausalLM, AutoTokenizer + +CTX = init_empty_weights if is_accelerate_available else nullcontext + +ckpt_id = "Sana" +# https://github.com/NVlabs/Sana/blob/main/scripts/inference.py + + +def main(args): + all_state_dict = torch.load(args.orig_ckpt_path, map_location=torch.device("cpu")) + state_dict = all_state_dict.pop("state_dict") + converted_state_dict = {} + + # Patch embeddings. + converted_state_dict["pos_embed.proj.weight"] = state_dict.pop("x_embedder.proj.weight") + converted_state_dict["pos_embed.proj.bias"] = state_dict.pop("x_embedder.proj.bias") + + # Caption projection. + converted_state_dict["caption_projection.linear_1.weight"] = state_dict.pop("y_embedder.y_proj.fc1.weight") + converted_state_dict["caption_projection.linear_1.bias"] = state_dict.pop("y_embedder.y_proj.fc1.bias") + converted_state_dict["caption_projection.linear_2.weight"] = state_dict.pop("y_embedder.y_proj.fc2.weight") + converted_state_dict["caption_projection.linear_2.bias"] = state_dict.pop("y_embedder.y_proj.fc2.bias") + + # AdaLN-single LN + converted_state_dict["adaln_single.emb.timestep_embedder.linear_1.weight"] = state_dict.pop( + "t_embedder.mlp.0.weight" + ) + converted_state_dict["adaln_single.emb.timestep_embedder.linear_1.bias"] = state_dict.pop("t_embedder.mlp.0.bias") + converted_state_dict["adaln_single.emb.timestep_embedder.linear_2.weight"] = state_dict.pop( + "t_embedder.mlp.2.weight" + ) + converted_state_dict["adaln_single.emb.timestep_embedder.linear_2.bias"] = state_dict.pop("t_embedder.mlp.2.bias") + + # Shared norm. + converted_state_dict["adaln_single.linear.weight"] = state_dict.pop("t_block.1.weight") + converted_state_dict["adaln_single.linear.bias"] = state_dict.pop("t_block.1.bias") + + # y norm + converted_state_dict["caption_norm.weight"] = state_dict.pop("attention_y_norm.weight") + + if args.model_type == "SanaMS_1600M_P1_D20": + layer_num = 20 + flow_shift = 3.0 + elif args.model_type == "SanaMS_600M_P1_D28": + layer_num = 28 + flow_shift = 4.0 + else: + raise ValueError(f"{args.model_type} is not supported.") + + for depth in range(layer_num): + # Transformer blocks. + converted_state_dict[f"transformer_blocks.{depth}.scale_shift_table"] = state_dict.pop( + f"blocks.{depth}.scale_shift_table" + ) + # Linear Attention is all you need 🤘 + + # Self attention. + q, k, v = torch.chunk(state_dict.pop(f"blocks.{depth}.attn.qkv.weight"), 3, dim=0) + converted_state_dict[f"transformer_blocks.{depth}.attn1.to_q.weight"] = q + converted_state_dict[f"transformer_blocks.{depth}.attn1.to_k.weight"] = k + converted_state_dict[f"transformer_blocks.{depth}.attn1.to_v.weight"] = v + # Projection. + converted_state_dict[f"transformer_blocks.{depth}.attn1.to_out.0.weight"] = state_dict.pop( + f"blocks.{depth}.attn.proj.weight" + ) + converted_state_dict[f"transformer_blocks.{depth}.attn1.to_out.0.bias"] = state_dict.pop( + f"blocks.{depth}.attn.proj.bias" + ) + + # Feed-forward. + converted_state_dict[f"transformer_blocks.{depth}.ff.inverted_conv.conv.weight"] = state_dict.pop( + f"blocks.{depth}.mlp.inverted_conv.conv.weight" + ) + converted_state_dict[f"transformer_blocks.{depth}.ff.inverted_conv.conv.bias"] = state_dict.pop( + f"blocks.{depth}.mlp.inverted_conv.conv.bias" + ) + converted_state_dict[f"transformer_blocks.{depth}.ff.depth_conv.conv.weight"] = state_dict.pop( + f"blocks.{depth}.mlp.depth_conv.conv.weight" + ) + converted_state_dict[f"transformer_blocks.{depth}.ff.depth_conv.conv.bias"] = state_dict.pop( + f"blocks.{depth}.mlp.depth_conv.conv.bias" + ) + converted_state_dict[f"transformer_blocks.{depth}.ff.point_conv.conv.weight"] = state_dict.pop( + f"blocks.{depth}.mlp.point_conv.conv.weight" + ) + + # Cross-attention. + q = state_dict.pop(f"blocks.{depth}.cross_attn.q_linear.weight") + q_bias = state_dict.pop(f"blocks.{depth}.cross_attn.q_linear.bias") + k, v = torch.chunk(state_dict.pop(f"blocks.{depth}.cross_attn.kv_linear.weight"), 2, dim=0) + k_bias, v_bias = torch.chunk(state_dict.pop(f"blocks.{depth}.cross_attn.kv_linear.bias"), 2, dim=0) + + converted_state_dict[f"transformer_blocks.{depth}.attn2.to_q.weight"] = q + converted_state_dict[f"transformer_blocks.{depth}.attn2.to_q.bias"] = q_bias + converted_state_dict[f"transformer_blocks.{depth}.attn2.to_k.weight"] = k + converted_state_dict[f"transformer_blocks.{depth}.attn2.to_k.bias"] = k_bias + converted_state_dict[f"transformer_blocks.{depth}.attn2.to_v.weight"] = v + converted_state_dict[f"transformer_blocks.{depth}.attn2.to_v.bias"] = v_bias + + converted_state_dict[f"transformer_blocks.{depth}.attn2.to_out.0.weight"] = state_dict.pop( + f"blocks.{depth}.cross_attn.proj.weight" + ) + converted_state_dict[f"transformer_blocks.{depth}.attn2.to_out.0.bias"] = state_dict.pop( + f"blocks.{depth}.cross_attn.proj.bias" + ) + + # Final block. + converted_state_dict["proj_out.weight"] = state_dict.pop("final_layer.linear.weight") + converted_state_dict["proj_out.bias"] = state_dict.pop("final_layer.linear.bias") + converted_state_dict["scale_shift_table"] = state_dict.pop("final_layer.scale_shift_table") + + # Transformer + with CTX(): + transformer = SanaTransformer2DModel( + num_attention_heads=model_kwargs[args.model_type]["num_attention_heads"], + attention_head_dim=model_kwargs[args.model_type]["attention_head_dim"], + num_cross_attention_heads=model_kwargs[args.model_type]["num_cross_attention_heads"], + cross_attention_head_dim=model_kwargs[args.model_type]["cross_attention_head_dim"], + in_channels=32, + out_channels=32, + num_layers=model_kwargs[args.model_type]["num_layers"], + cross_attention_dim=model_kwargs[args.model_type]["cross_attention_dim"], + attention_bias=False, + sample_size=32, + patch_size=1, + activation_fn=("silu", "silu", None), + upcast_attention=False, + norm_type="ada_norm_single", + norm_elementwise_affine=False, + norm_eps=1e-6, + use_additional_conditions=False, + caption_channels=2304, + use_caption_norm=True, + caption_norm_scale_factor=0.1, + attention_type="default", + use_pe=False, + expand_ratio=2.5, + ff_bias=(True, True, False), + ff_norm=(None, None, None), + ) + if is_accelerate_available(): + load_model_dict_into_meta(transformer, converted_state_dict) + else: + transformer.load_state_dict(converted_state_dict, strict=True) + + try: + state_dict.pop("y_embedder.y_embedding") + state_dict.pop("pos_embed") + except: + pass + assert len(state_dict) == 0, f"State dict is not empty, {state_dict.keys()}" + + num_model_params = sum(p.numel() for p in transformer.parameters()) + print(f"Total number of transformer parameters: {num_model_params}") + + if not args.save_full_pipeline: + print( + colored( + f"Only saving transformer model of {args.model_type}. " + f"Set --save_full_pipeline to save the whole SanaPipeline", + "green", + attrs=["bold"], + ) + ) + transformer.to(weight_dtype).save_pretrained(os.path.join(args.dump_path, "transformer")) + else: + print(colored(f"Saving the whole SanaPAGPipeline containing {args.model_type}", "green", attrs=["bold"])) + # VAE + dc_ae = DCAE_HF.from_pretrained(f"mit-han-lab/dc-ae-f32c32-sana-1.0") + dc_ae_state_dict = dc_ae.state_dict() + dc_ae = DCAE( + in_channels=3, + latent_channels=32, + encoder_width_list=[128, 256, 512, 512, 1024, 1024], + encoder_depth_list=[2, 2, 2, 3, 3, 3], + encoder_block_type=["ResBlock", "ResBlock", "ResBlock", "EViTS5_GLU", "EViTS5_GLU", "EViTS5_GLU"], + encoder_norm="rms2d", + encoder_act="silu", + downsample_block_type="Conv", + decoder_width_list=[128, 256, 512, 512, 1024, 1024], + decoder_depth_list=[3, 3, 3, 3, 3, 3], + decoder_block_type=["ResBlock", "ResBlock", "ResBlock", "EViTS5_GLU", "EViTS5_GLU", "EViTS5_GLU"], + decoder_norm="rms2d", + decoder_act="silu", + upsample_block_type="InterpolateConv", + scaling_factor=0.41407, + ) + dc_ae.load_state_dict(dc_ae_state_dict, strict=True) + dc_ae.to(torch.float32).to(device) + + # Text Encoder + text_encoder_model_path = "google/gemma-2-2b-it" + tokenizer = AutoTokenizer.from_pretrained(text_encoder_model_path) + tokenizer.padding_side = "right" + text_encoder = ( + AutoModelForCausalLM.from_pretrained(text_encoder_model_path, torch_dtype=torch.bfloat16) + .get_decoder() + .to(device) + ) + + # Scheduler + if args.scheduler_type == "flow-dpm_solver": + scheduler = FlowDPMSolverMultistepScheduler(flow_shift=flow_shift) + elif args.scheduler_type == "flow-euler": + scheduler = FlowMatchEulerDiscreteScheduler(shift=flow_shift) + else: + raise ValueError(f"Scheduler type {args.scheduler_type} is not supported") + + # transformer + transformer.to(device).to(weight_dtype) + + pipe = SanaPAGPipeline( + tokenizer=tokenizer, + text_encoder=text_encoder, + transformer=transformer, + vae=dc_ae, + scheduler=scheduler, + pag_applied_layers="blocks.8", + ) + + image = pipe( + "a dog", + height=1024, + width=1024, + guidance_scale=5.0, + pag_scale=2.0, + )[0] + + image[0].save("sana_pag.png") + + pipe.save_pretrained(args.dump_path) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + + parser.add_argument( + "--orig_ckpt_path", default=None, type=str, required=False, help="Path to the checkpoint to convert." + ) + parser.add_argument( + "--image_size", + default=1024, + type=int, + choices=[512, 1024], + required=False, + help="Image size of pretrained model, 512 or 1024.", + ) + parser.add_argument( + "--model_type", default="SanaMS_1600M_P1_D20", type=str, choices=["SanaMS_1600M_P1_D20", "SanaMS_600M_P1_D28"] + ) + parser.add_argument( + "--scheduler_type", default="flow-dpm_solver", type=str, choices=["flow-dpm_solver", "flow-euler"] + ) + parser.add_argument("--dump_path", default=None, type=str, required=True, help="Path to the output pipeline.") + parser.add_argument("--save_full_pipeline", action="store_true", help="save all the pipelien elemets in one.") + + args = parser.parse_args() + + model_kwargs = { + "SanaMS_1600M_P1_D20": { + "num_attention_heads": 70, + "attention_head_dim": 32, + "num_cross_attention_heads": 20, + "cross_attention_head_dim": 112, + "cross_attention_dim": 2240, + "num_layers": 20, + }, + "SanaMS_600M_P1_D28": { + "num_attention_heads": 36, + "attention_head_dim": 32, + "num_cross_attention_heads": 16, + "cross_attention_head_dim": 72, + "cross_attention_dim": 1152, + "num_layers": 28, + }, + } + + device = "cuda" if torch.cuda.is_available() else "cpu" + weight_dtype = torch.float16 + + main(args) diff --git a/scripts/convert_sana_to_diffusers.py b/scripts/convert_sana_to_diffusers.py new file mode 100644 index 000000000000..8b93282d3ba7 --- /dev/null +++ b/scripts/convert_sana_to_diffusers.py @@ -0,0 +1,299 @@ +#!/usr/bin/env python +from __future__ import annotations + +import argparse +import os +from contextlib import nullcontext + +import torch +from accelerate import init_empty_weights +from diffusers import ( + DCAE, + DCAE_HF, + FlowDPMSolverMultistepScheduler, + FlowMatchEulerDiscreteScheduler, + SanaPipeline, + SanaTransformer2DModel, +) +from diffusers.models.modeling_utils import load_model_dict_into_meta +from diffusers.utils.import_utils import is_accelerate_available +from termcolor import colored +from transformers import AutoModelForCausalLM, AutoTokenizer + +CTX = init_empty_weights if is_accelerate_available else nullcontext + +ckpt_id = "Sana" +# https://github.com/NVlabs/Sana/blob/main/scripts/inference.py + + +def main(args): + all_state_dict = torch.load(args.orig_ckpt_path, map_location=torch.device("cpu")) + state_dict = all_state_dict.pop("state_dict") + converted_state_dict = {} + + # Patch embeddings. + converted_state_dict["pos_embed.proj.weight"] = state_dict.pop("x_embedder.proj.weight") + converted_state_dict["pos_embed.proj.bias"] = state_dict.pop("x_embedder.proj.bias") + + # Caption projection. + converted_state_dict["caption_projection.linear_1.weight"] = state_dict.pop("y_embedder.y_proj.fc1.weight") + converted_state_dict["caption_projection.linear_1.bias"] = state_dict.pop("y_embedder.y_proj.fc1.bias") + converted_state_dict["caption_projection.linear_2.weight"] = state_dict.pop("y_embedder.y_proj.fc2.weight") + converted_state_dict["caption_projection.linear_2.bias"] = state_dict.pop("y_embedder.y_proj.fc2.bias") + + # AdaLN-single LN + converted_state_dict["adaln_single.emb.timestep_embedder.linear_1.weight"] = state_dict.pop( + "t_embedder.mlp.0.weight" + ) + converted_state_dict["adaln_single.emb.timestep_embedder.linear_1.bias"] = state_dict.pop("t_embedder.mlp.0.bias") + converted_state_dict["adaln_single.emb.timestep_embedder.linear_2.weight"] = state_dict.pop( + "t_embedder.mlp.2.weight" + ) + converted_state_dict["adaln_single.emb.timestep_embedder.linear_2.bias"] = state_dict.pop("t_embedder.mlp.2.bias") + + # Shared norm. + converted_state_dict["adaln_single.linear.weight"] = state_dict.pop("t_block.1.weight") + converted_state_dict["adaln_single.linear.bias"] = state_dict.pop("t_block.1.bias") + + # y norm + converted_state_dict["caption_norm.weight"] = state_dict.pop("attention_y_norm.weight") + + if args.model_type == "SanaMS_1600M_P1_D20": + layer_num = 20 + flow_shift = 3.0 + elif args.model_type == "SanaMS_600M_P1_D28": + layer_num = 28 + flow_shift = 4.0 + else: + raise ValueError(f"{args.model_type} is not supported.") + + for depth in range(layer_num): + # Transformer blocks. + converted_state_dict[f"transformer_blocks.{depth}.scale_shift_table"] = state_dict.pop( + f"blocks.{depth}.scale_shift_table" + ) + # Linear Attention is all you need 🤘 + + # Self attention. + q, k, v = torch.chunk(state_dict.pop(f"blocks.{depth}.attn.qkv.weight"), 3, dim=0) + converted_state_dict[f"transformer_blocks.{depth}.attn1.to_q.weight"] = q + converted_state_dict[f"transformer_blocks.{depth}.attn1.to_k.weight"] = k + converted_state_dict[f"transformer_blocks.{depth}.attn1.to_v.weight"] = v + # Projection. + converted_state_dict[f"transformer_blocks.{depth}.attn1.to_out.0.weight"] = state_dict.pop( + f"blocks.{depth}.attn.proj.weight" + ) + converted_state_dict[f"transformer_blocks.{depth}.attn1.to_out.0.bias"] = state_dict.pop( + f"blocks.{depth}.attn.proj.bias" + ) + + # Feed-forward. + converted_state_dict[f"transformer_blocks.{depth}.ff.inverted_conv.conv.weight"] = state_dict.pop( + f"blocks.{depth}.mlp.inverted_conv.conv.weight" + ) + converted_state_dict[f"transformer_blocks.{depth}.ff.inverted_conv.conv.bias"] = state_dict.pop( + f"blocks.{depth}.mlp.inverted_conv.conv.bias" + ) + converted_state_dict[f"transformer_blocks.{depth}.ff.depth_conv.conv.weight"] = state_dict.pop( + f"blocks.{depth}.mlp.depth_conv.conv.weight" + ) + converted_state_dict[f"transformer_blocks.{depth}.ff.depth_conv.conv.bias"] = state_dict.pop( + f"blocks.{depth}.mlp.depth_conv.conv.bias" + ) + converted_state_dict[f"transformer_blocks.{depth}.ff.point_conv.conv.weight"] = state_dict.pop( + f"blocks.{depth}.mlp.point_conv.conv.weight" + ) + + # Cross-attention. + q = state_dict.pop(f"blocks.{depth}.cross_attn.q_linear.weight") + q_bias = state_dict.pop(f"blocks.{depth}.cross_attn.q_linear.bias") + k, v = torch.chunk(state_dict.pop(f"blocks.{depth}.cross_attn.kv_linear.weight"), 2, dim=0) + k_bias, v_bias = torch.chunk(state_dict.pop(f"blocks.{depth}.cross_attn.kv_linear.bias"), 2, dim=0) + + converted_state_dict[f"transformer_blocks.{depth}.attn2.to_q.weight"] = q + converted_state_dict[f"transformer_blocks.{depth}.attn2.to_q.bias"] = q_bias + converted_state_dict[f"transformer_blocks.{depth}.attn2.to_k.weight"] = k + converted_state_dict[f"transformer_blocks.{depth}.attn2.to_k.bias"] = k_bias + converted_state_dict[f"transformer_blocks.{depth}.attn2.to_v.weight"] = v + converted_state_dict[f"transformer_blocks.{depth}.attn2.to_v.bias"] = v_bias + + converted_state_dict[f"transformer_blocks.{depth}.attn2.to_out.0.weight"] = state_dict.pop( + f"blocks.{depth}.cross_attn.proj.weight" + ) + converted_state_dict[f"transformer_blocks.{depth}.attn2.to_out.0.bias"] = state_dict.pop( + f"blocks.{depth}.cross_attn.proj.bias" + ) + + # Final block. + converted_state_dict["proj_out.weight"] = state_dict.pop("final_layer.linear.weight") + converted_state_dict["proj_out.bias"] = state_dict.pop("final_layer.linear.bias") + converted_state_dict["scale_shift_table"] = state_dict.pop("final_layer.scale_shift_table") + + # Transformer + with CTX(): + transformer = SanaTransformer2DModel( + num_attention_heads=model_kwargs[args.model_type]["num_attention_heads"], + attention_head_dim=model_kwargs[args.model_type]["attention_head_dim"], + num_cross_attention_heads=model_kwargs[args.model_type]["num_cross_attention_heads"], + cross_attention_head_dim=model_kwargs[args.model_type]["cross_attention_head_dim"], + in_channels=32, + out_channels=32, + num_layers=model_kwargs[args.model_type]["num_layers"], + cross_attention_dim=model_kwargs[args.model_type]["cross_attention_dim"], + attention_bias=False, + sample_size=32, + patch_size=1, + activation_fn=("silu", "silu", None), + upcast_attention=False, + norm_type="ada_norm_single", + norm_elementwise_affine=False, + norm_eps=1e-6, + use_additional_conditions=False, + caption_channels=2304, + use_caption_norm=True, + caption_norm_scale_factor=0.1, + attention_type="default", + use_pe=False, + expand_ratio=2.5, + ff_bias=(True, True, False), + ff_norm=(None, None, None), + ) + if is_accelerate_available(): + load_model_dict_into_meta(transformer, converted_state_dict) + else: + transformer.load_state_dict(converted_state_dict, strict=True) + + try: + state_dict.pop("y_embedder.y_embedding") + state_dict.pop("pos_embed") + except: + pass + assert len(state_dict) == 0, f"State dict is not empty, {state_dict.keys()}" + + num_model_params = sum(p.numel() for p in transformer.parameters()) + print(f"Total number of transformer parameters: {num_model_params}") + + if not args.save_full_pipeline: + print( + colored( + f"Only saving transformer model of {args.model_type}. " + f"Set --save_full_pipeline to save the whole SanaPipeline", + "green", + attrs=["bold"], + ) + ) + transformer.to(weight_dtype).save_pretrained(os.path.join(args.dump_path, "transformer")) + else: + print(colored(f"Saving the whole SanaPipeline containing {args.model_type}", "green", attrs=["bold"])) + # VAE + dc_ae = DCAE_HF.from_pretrained(f"mit-han-lab/dc-ae-f32c32-sana-1.0") + dc_ae_state_dict = dc_ae.state_dict() + dc_ae = DCAE( + in_channels=3, + latent_channels=32, + encoder_width_list=[128, 256, 512, 512, 1024, 1024], + encoder_depth_list=[2, 2, 2, 3, 3, 3], + encoder_block_type=["ResBlock", "ResBlock", "ResBlock", "EViTS5_GLU", "EViTS5_GLU", "EViTS5_GLU"], + encoder_norm="rms2d", + encoder_act="silu", + downsample_block_type="Conv", + decoder_width_list=[128, 256, 512, 512, 1024, 1024], + decoder_depth_list=[3, 3, 3, 3, 3, 3], + decoder_block_type=["ResBlock", "ResBlock", "ResBlock", "EViTS5_GLU", "EViTS5_GLU", "EViTS5_GLU"], + decoder_norm="rms2d", + decoder_act="silu", + upsample_block_type="InterpolateConv", + scaling_factor=0.41407, + ) + dc_ae.load_state_dict(dc_ae_state_dict, strict=True) + dc_ae.to(torch.float32).to(device) + + # Text Encoder + text_encoder_model_path = "google/gemma-2-2b-it" + tokenizer = AutoTokenizer.from_pretrained(text_encoder_model_path) + tokenizer.padding_side = "right" + text_encoder = ( + AutoModelForCausalLM.from_pretrained(text_encoder_model_path, torch_dtype=torch.bfloat16) + .get_decoder() + .to(device) + ) + + # Scheduler + if args.scheduler_type == "flow-dpm_solver": + scheduler = FlowDPMSolverMultistepScheduler(flow_shift=flow_shift) + elif args.scheduler_type == "flow-euler": + scheduler = FlowMatchEulerDiscreteScheduler(shift=flow_shift) + else: + raise ValueError(f"Scheduler type {args.scheduler_type} is not supported") + + # transformer + transformer.to(device).to(weight_dtype) + + pipe = SanaPipeline( + tokenizer=tokenizer, + text_encoder=text_encoder, + transformer=transformer, + vae=dc_ae, + scheduler=scheduler, + ) + + image = pipe( + "a dog", + height=1024, + width=1024, + guidance_scale=5.0, + )[0] + + image[0].save("sana.png") + + pipe.save_pretrained(args.dump_path) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + + parser.add_argument( + "--orig_ckpt_path", default=None, type=str, required=False, help="Path to the checkpoint to convert." + ) + parser.add_argument( + "--image_size", + default=1024, + type=int, + choices=[512, 1024], + required=False, + help="Image size of pretrained model, 512 or 1024.", + ) + parser.add_argument( + "--model_type", default="SanaMS_1600M_P1_D20", type=str, choices=["SanaMS_1600M_P1_D20", "SanaMS_600M_P1_D28"] + ) + parser.add_argument( + "--scheduler_type", default="flow-dpm_solver", type=str, choices=["flow-dpm_solver", "flow-euler"] + ) + parser.add_argument("--dump_path", default=None, type=str, required=True, help="Path to the output pipeline.") + parser.add_argument("--save_full_pipeline", action="store_true", help="save all the pipelien elemets in one.") + + args = parser.parse_args() + + model_kwargs = { + "SanaMS_1600M_P1_D20": { + "num_attention_heads": 70, + "attention_head_dim": 32, + "num_cross_attention_heads": 20, + "cross_attention_head_dim": 112, + "cross_attention_dim": 2240, + "num_layers": 20, + }, + "SanaMS_600M_P1_D28": { + "num_attention_heads": 36, + "attention_head_dim": 32, + "num_cross_attention_heads": 16, + "cross_attention_head_dim": 72, + "cross_attention_dim": 1152, + "num_layers": 28, + }, + } + + device = "cuda" if torch.cuda.is_available() else "cpu" + weight_dtype = torch.float16 + + main(args) From 94edc7e70ffeb50030fc5f52ae44e2adf38abb50 Mon Sep 17 00:00:00 2001 From: Junsong Chen Date: Wed, 27 Nov 2024 00:44:17 +0800 Subject: [PATCH 092/141] Update src/diffusers/models/transformers/sana_transformer_2d.py Co-authored-by: Steven Liu <59462357+stevhliu@users.noreply.github.com> --- src/diffusers/models/transformers/sana_transformer_2d.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/diffusers/models/transformers/sana_transformer_2d.py b/src/diffusers/models/transformers/sana_transformer_2d.py index a13280277f54..2c891c601ebf 100644 --- a/src/diffusers/models/transformers/sana_transformer_2d.py +++ b/src/diffusers/models/transformers/sana_transformer_2d.py @@ -301,7 +301,7 @@ class SanaTransformer2DModel(ModelMixin, ConfigMixin): https://arxiv.org/abs/2403.04692). Parameters: - num_attention_heads (int, optional, defaults to 16): The number of heads to use for multi-head attention. + num_attention_heads (int, optional, defaults to 32): The number of heads to use for multi-head attention. attention_head_dim (int, optional, defaults to 72): The number of channels in each head. in_channels (int, defaults to 4): The number of channels in the input. out_channels (int, optional): From 64a644035ad960e8de093ac112255c3c8f7b1e9e Mon Sep 17 00:00:00 2001 From: Junsong Chen Date: Wed, 27 Nov 2024 00:44:29 +0800 Subject: [PATCH 093/141] Update src/diffusers/models/transformers/sana_transformer_2d.py Co-authored-by: Steven Liu <59462357+stevhliu@users.noreply.github.com> --- src/diffusers/models/transformers/sana_transformer_2d.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/diffusers/models/transformers/sana_transformer_2d.py b/src/diffusers/models/transformers/sana_transformer_2d.py index 2c891c601ebf..eef31594bc09 100644 --- a/src/diffusers/models/transformers/sana_transformer_2d.py +++ b/src/diffusers/models/transformers/sana_transformer_2d.py @@ -302,7 +302,7 @@ class SanaTransformer2DModel(ModelMixin, ConfigMixin): Parameters: num_attention_heads (int, optional, defaults to 32): The number of heads to use for multi-head attention. - attention_head_dim (int, optional, defaults to 72): The number of channels in each head. + attention_head_dim (int, optional, defaults to 36): The number of channels in each head. in_channels (int, defaults to 4): The number of channels in the input. out_channels (int, optional): The number of channels in the output. Specify this parameter if the output channel number differs from the From 09cf898a9d7f1d39acc15e6f53e77dfd385dea48 Mon Sep 17 00:00:00 2001 From: Junsong Chen Date: Wed, 27 Nov 2024 00:44:40 +0800 Subject: [PATCH 094/141] Update src/diffusers/models/transformers/sana_transformer_2d.py Co-authored-by: Steven Liu <59462357+stevhliu@users.noreply.github.com> --- src/diffusers/models/transformers/sana_transformer_2d.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/diffusers/models/transformers/sana_transformer_2d.py b/src/diffusers/models/transformers/sana_transformer_2d.py index eef31594bc09..78556c381fb0 100644 --- a/src/diffusers/models/transformers/sana_transformer_2d.py +++ b/src/diffusers/models/transformers/sana_transformer_2d.py @@ -317,7 +317,7 @@ class SanaTransformer2DModel(ModelMixin, ConfigMixin): Configure if the Transformer blocks' attention should contain a bias parameter. sample_size (int, defaults to 128): The width of the latent images. This parameter is fixed during training. - patch_size (int, defaults to 2): + patch_size (int, defaults to 1): Size of the patches the model processes, relevant for architectures working on non-sequential data. activation_fn (str, optional, defaults to "gelu-approximate"): Activation function to use in feed-forward networks within Transformer blocks. From 219e071892376e7d0e553feaf7b60c576ca82bb0 Mon Sep 17 00:00:00 2001 From: Junsong Chen Date: Wed, 27 Nov 2024 00:44:50 +0800 Subject: [PATCH 095/141] Update src/diffusers/pipelines/pag/pipeline_pag_sana.py Co-authored-by: Steven Liu <59462357+stevhliu@users.noreply.github.com> --- src/diffusers/pipelines/pag/pipeline_pag_sana.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/diffusers/pipelines/pag/pipeline_pag_sana.py b/src/diffusers/pipelines/pag/pipeline_pag_sana.py index 73a666342423..12926a316981 100644 --- a/src/diffusers/pipelines/pag/pipeline_pag_sana.py +++ b/src/diffusers/pipelines/pag/pipeline_pag_sana.py @@ -611,7 +611,7 @@ def __call__( The prompt or prompts not to guide the image generation. If not defined, one has to pass `negative_prompt_embeds` instead. Ignored when not using guidance (i.e., ignored if `guidance_scale` is less than `1`). - num_inference_steps (`int`, *optional*, defaults to 100): + num_inference_steps (`int`, *optional*, defaults to 20): The number of denoising steps. More denoising steps usually lead to a higher quality image at the expense of slower inference. timesteps (`List[int]`, *optional*): From 11f1c8de7e4151f524d52a1635f2981976e247a8 Mon Sep 17 00:00:00 2001 From: Junsong Chen Date: Wed, 27 Nov 2024 00:45:13 +0800 Subject: [PATCH 096/141] Update src/diffusers/models/transformers/sana_transformer_2d.py Co-authored-by: Steven Liu <59462357+stevhliu@users.noreply.github.com> --- src/diffusers/models/transformers/sana_transformer_2d.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/diffusers/models/transformers/sana_transformer_2d.py b/src/diffusers/models/transformers/sana_transformer_2d.py index 78556c381fb0..335d66402003 100644 --- a/src/diffusers/models/transformers/sana_transformer_2d.py +++ b/src/diffusers/models/transformers/sana_transformer_2d.py @@ -315,7 +315,7 @@ class SanaTransformer2DModel(ModelMixin, ConfigMixin): The dimensionality for cross-attention layers, typically matching the encoder's hidden dimension. attention_bias (bool, optional, defaults to True): Configure if the Transformer blocks' attention should contain a bias parameter. - sample_size (int, defaults to 128): + sample_size (int, defaults to 32): The width of the latent images. This parameter is fixed during training. patch_size (int, defaults to 1): Size of the patches the model processes, relevant for architectures working on non-sequential data. From 12b5160bd6a223c462db61213b73c88e448b9fa4 Mon Sep 17 00:00:00 2001 From: Junsong Chen Date: Wed, 27 Nov 2024 00:45:51 +0800 Subject: [PATCH 097/141] Update src/diffusers/models/transformers/sana_transformer_2d.py Co-authored-by: Steven Liu <59462357+stevhliu@users.noreply.github.com> --- src/diffusers/models/transformers/sana_transformer_2d.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/diffusers/models/transformers/sana_transformer_2d.py b/src/diffusers/models/transformers/sana_transformer_2d.py index 335d66402003..f22bc6db2bf4 100644 --- a/src/diffusers/models/transformers/sana_transformer_2d.py +++ b/src/diffusers/models/transformers/sana_transformer_2d.py @@ -303,7 +303,7 @@ class SanaTransformer2DModel(ModelMixin, ConfigMixin): Parameters: num_attention_heads (int, optional, defaults to 32): The number of heads to use for multi-head attention. attention_head_dim (int, optional, defaults to 36): The number of channels in each head. - in_channels (int, defaults to 4): The number of channels in the input. + in_channels (int, defaults to 32): The number of channels in the input. out_channels (int, optional): The number of channels in the output. Specify this parameter if the output channel number differs from the input. From 7823c8f6f0eaa7aa3ec4a134568a0f60611194bb Mon Sep 17 00:00:00 2001 From: Junsong Chen Date: Wed, 27 Nov 2024 00:46:29 +0800 Subject: [PATCH 098/141] Update src/diffusers/pipelines/sana/pipeline_sana.py Co-authored-by: Steven Liu <59462357+stevhliu@users.noreply.github.com> --- src/diffusers/pipelines/sana/pipeline_sana.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/diffusers/pipelines/sana/pipeline_sana.py b/src/diffusers/pipelines/sana/pipeline_sana.py index db093c0b8f8f..37d7183312b5 100644 --- a/src/diffusers/pipelines/sana/pipeline_sana.py +++ b/src/diffusers/pipelines/sana/pipeline_sana.py @@ -590,7 +590,7 @@ def __call__( The prompt or prompts not to guide the image generation. If not defined, one has to pass `negative_prompt_embeds` instead. Ignored when not using guidance (i.e., ignored if `guidance_scale` is less than `1`). - num_inference_steps (`int`, *optional*, defaults to 100): + num_inference_steps (`int`, *optional*, defaults to 20): The number of denoising steps. More denoising steps usually lead to a higher quality image at the expense of slower inference. timesteps (`List[int]`, *optional*): From d3fd40a815b199ea35f3475a4af818a8546b9a0c Mon Sep 17 00:00:00 2001 From: Junsong Chen Date: Wed, 27 Nov 2024 00:46:43 +0800 Subject: [PATCH 099/141] Update src/diffusers/pipelines/sana/pipeline_sana.py Co-authored-by: Steven Liu <59462357+stevhliu@users.noreply.github.com> From abee1eecf648260fad7d75509764c4e4151c1f66 Mon Sep 17 00:00:00 2001 From: junsong Date: Thu, 28 Nov 2024 09:32:01 -0800 Subject: [PATCH 100/141] update Sana for DC-AE's recent commit; --- scripts/convert_sana_pag_to_diffusers.py | 34 ++++++------------- scripts/convert_sana_to_diffusers.py | 34 ++++++------------- src/diffusers/__init__.py | 2 -- src/diffusers/models/autoencoders/__init__.py | 2 +- .../pipelines/pag/pipeline_pag_sana.py | 19 +++++++---- src/diffusers/pipelines/sana/pipeline_sana.py | 20 ++++++----- 6 files changed, 45 insertions(+), 66 deletions(-) diff --git a/scripts/convert_sana_pag_to_diffusers.py b/scripts/convert_sana_pag_to_diffusers.py index cf550a1a995d..ea5a3e5db27c 100644 --- a/scripts/convert_sana_pag_to_diffusers.py +++ b/scripts/convert_sana_pag_to_diffusers.py @@ -9,8 +9,7 @@ from accelerate import init_empty_weights from diffusers import ( DCAE, - DCAE_HF, - FlowDPMSolverMultistepScheduler, + DPMSolverMultistepScheduler, FlowMatchEulerDiscreteScheduler, SanaPAGPipeline, SanaTransformer2DModel, @@ -186,27 +185,10 @@ def main(args): else: print(colored(f"Saving the whole SanaPAGPipeline containing {args.model_type}", "green", attrs=["bold"])) # VAE - dc_ae = DCAE_HF.from_pretrained(f"mit-han-lab/dc-ae-f32c32-sana-1.0") - dc_ae_state_dict = dc_ae.state_dict() - dc_ae = DCAE( - in_channels=3, - latent_channels=32, - encoder_width_list=[128, 256, 512, 512, 1024, 1024], - encoder_depth_list=[2, 2, 2, 3, 3, 3], - encoder_block_type=["ResBlock", "ResBlock", "ResBlock", "EViTS5_GLU", "EViTS5_GLU", "EViTS5_GLU"], - encoder_norm="rms2d", - encoder_act="silu", - downsample_block_type="Conv", - decoder_width_list=[128, 256, 512, 512, 1024, 1024], - decoder_depth_list=[3, 3, 3, 3, 3, 3], - decoder_block_type=["ResBlock", "ResBlock", "ResBlock", "EViTS5_GLU", "EViTS5_GLU", "EViTS5_GLU"], - decoder_norm="rms2d", - decoder_act="silu", - upsample_block_type="InterpolateConv", - scaling_factor=0.41407, - ) - dc_ae.load_state_dict(dc_ae_state_dict, strict=True) - dc_ae.to(torch.float32).to(device) + dc_ae = DCAE.from_pretrained( + "Efficient-Large-Model/dc_ae_f32c32_sana_1.0_diffusers", + torch_dtype=torch.float32, + ).to(device) # Text Encoder text_encoder_model_path = "google/gemma-2-2b-it" @@ -220,7 +202,11 @@ def main(args): # Scheduler if args.scheduler_type == "flow-dpm_solver": - scheduler = FlowDPMSolverMultistepScheduler(flow_shift=flow_shift) + scheduler = DPMSolverMultistepScheduler( + flow_shift=flow_shift, + use_flow_sigmas=True, + prediction_type="flow_prediction", + ) elif args.scheduler_type == "flow-euler": scheduler = FlowMatchEulerDiscreteScheduler(shift=flow_shift) else: diff --git a/scripts/convert_sana_to_diffusers.py b/scripts/convert_sana_to_diffusers.py index 8b93282d3ba7..3735f506cad6 100644 --- a/scripts/convert_sana_to_diffusers.py +++ b/scripts/convert_sana_to_diffusers.py @@ -9,8 +9,7 @@ from accelerate import init_empty_weights from diffusers import ( DCAE, - DCAE_HF, - FlowDPMSolverMultistepScheduler, + DPMSolverMultistepScheduler, FlowMatchEulerDiscreteScheduler, SanaPipeline, SanaTransformer2DModel, @@ -186,27 +185,10 @@ def main(args): else: print(colored(f"Saving the whole SanaPipeline containing {args.model_type}", "green", attrs=["bold"])) # VAE - dc_ae = DCAE_HF.from_pretrained(f"mit-han-lab/dc-ae-f32c32-sana-1.0") - dc_ae_state_dict = dc_ae.state_dict() - dc_ae = DCAE( - in_channels=3, - latent_channels=32, - encoder_width_list=[128, 256, 512, 512, 1024, 1024], - encoder_depth_list=[2, 2, 2, 3, 3, 3], - encoder_block_type=["ResBlock", "ResBlock", "ResBlock", "EViTS5_GLU", "EViTS5_GLU", "EViTS5_GLU"], - encoder_norm="rms2d", - encoder_act="silu", - downsample_block_type="Conv", - decoder_width_list=[128, 256, 512, 512, 1024, 1024], - decoder_depth_list=[3, 3, 3, 3, 3, 3], - decoder_block_type=["ResBlock", "ResBlock", "ResBlock", "EViTS5_GLU", "EViTS5_GLU", "EViTS5_GLU"], - decoder_norm="rms2d", - decoder_act="silu", - upsample_block_type="InterpolateConv", - scaling_factor=0.41407, - ) - dc_ae.load_state_dict(dc_ae_state_dict, strict=True) - dc_ae.to(torch.float32).to(device) + dc_ae = DCAE.from_pretrained( + "Efficient-Large-Model/dc_ae_f32c32_sana_1.0_diffusers", + torch_dtype=torch.float32, + ).to(device) # Text Encoder text_encoder_model_path = "google/gemma-2-2b-it" @@ -220,7 +202,11 @@ def main(args): # Scheduler if args.scheduler_type == "flow-dpm_solver": - scheduler = FlowDPMSolverMultistepScheduler(flow_shift=flow_shift) + scheduler = DPMSolverMultistepScheduler( + flow_shift=flow_shift, + use_flow_sigmas=True, + prediction_type="flow_prediction", + ) elif args.scheduler_type == "flow-euler": scheduler = FlowMatchEulerDiscreteScheduler(shift=flow_shift) else: diff --git a/src/diffusers/__init__.py b/src/diffusers/__init__.py index 8235cf18db0f..106d4f2effab 100644 --- a/src/diffusers/__init__.py +++ b/src/diffusers/__init__.py @@ -131,7 +131,6 @@ "UVit2DModel", "VQModel", "DCAE", - "DCAE_HF", ] ) _import_structure["optimization"] = [ @@ -577,7 +576,6 @@ else: from .models import ( DCAE, - DCAE_HF, AllegroTransformer3DModel, AsymmetricAutoencoderKL, AuraFlowTransformer2DModel, diff --git a/src/diffusers/models/autoencoders/__init__.py b/src/diffusers/models/autoencoders/__init__.py index 4dc514b478e9..c5cff445e0cf 100644 --- a/src/diffusers/models/autoencoders/__init__.py +++ b/src/diffusers/models/autoencoders/__init__.py @@ -8,5 +8,5 @@ from .autoencoder_oobleck import AutoencoderOobleck from .autoencoder_tiny import AutoencoderTiny from .consistency_decoder_vae import ConsistencyDecoderVAE -from .dc_ae import DCAE, DCAE_HF +from .autoencoder_dc import DCAE from .vq_model import VQModel diff --git a/src/diffusers/pipelines/pag/pipeline_pag_sana.py b/src/diffusers/pipelines/pag/pipeline_pag_sana.py index 12926a316981..bff8a651dac6 100644 --- a/src/diffusers/pipelines/pag/pipeline_pag_sana.py +++ b/src/diffusers/pipelines/pag/pipeline_pag_sana.py @@ -22,7 +22,7 @@ from transformers import AutoModelForCausalLM, AutoTokenizer from ...image_processor import PixArtImageProcessor -from ...models import DCAE_HF, SanaTransformer2DModel +from ...models import DCAE, SanaTransformer2DModel from ...models.attention_processor import PAGCFGSanaLinearAttnProcessor2_0, PAGIdentitySanaLinearAttnProcessor2_0 from ...schedulers import FlowDPMSolverMultistepScheduler from ...utils import ( @@ -162,7 +162,7 @@ def __init__( self, tokenizer: AutoTokenizer, text_encoder: AutoModelForCausalLM, - vae: DCAE_HF, + vae: DCAE, transformer: SanaTransformer2DModel, scheduler: FlowDPMSolverMultistepScheduler, pag_applied_layers: Union[str, List[str]] = "blocks.1", # 1st transformer block @@ -840,22 +840,27 @@ def __call__( noise_pred = noise_pred # compute previous image: x_t -> x_t-1 + latents_dtype = latents.dtype latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs, return_dict=False)[0] + if latents.dtype != latents_dtype: + if torch.backends.mps.is_available(): + # some platforms (eg. apple mps) misbehave due to a pytorch bug: https://github.com/pytorch/pytorch/pull/99272 + latents = latents.to(latents_dtype) # call the callback, if provided if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0): progress_bar.update() if callback is not None and i % callback_steps == 0: step_idx = i // getattr(self.scheduler, "order", 1) callback(step_idx, t, latents) - # set to None for next - if not output_type == "latent": - image = self.vae.decode(latents.to(self.vae.dtype) / self.vae.config.scaling_factor) + if output_type == "latent": + image = latents + else: + latents = latents.to(self.vae.dtype) + image = self.vae.decode(latents / self.vae.config.scaling_factor, return_dict=False)[0] if use_resolution_binning: image = self.image_processor.resize_and_crop_tensor(image, orig_width, orig_height) - else: - image = latents if not output_type == "latent": image = self.image_processor.postprocess(image, output_type=output_type) diff --git a/src/diffusers/pipelines/sana/pipeline_sana.py b/src/diffusers/pipelines/sana/pipeline_sana.py index 37d7183312b5..cedb4b0e70c4 100644 --- a/src/diffusers/pipelines/sana/pipeline_sana.py +++ b/src/diffusers/pipelines/sana/pipeline_sana.py @@ -22,7 +22,7 @@ from transformers import AutoModelForCausalLM, AutoTokenizer from ...image_processor import PixArtImageProcessor -from ...models import DCAE_HF, SanaTransformer2DModel +from ...models import DCAE, SanaTransformer2DModel from ...schedulers import FlowDPMSolverMultistepScheduler from ...utils import ( BACKENDS_MAPPING, @@ -157,7 +157,7 @@ def __init__( self, tokenizer: AutoTokenizer, text_encoder: AutoModelForCausalLM, - vae: DCAE_HF, + vae: DCAE, transformer: SanaTransformer2DModel, scheduler: FlowDPMSolverMultistepScheduler, ): @@ -793,8 +793,13 @@ def __call__( noise_pred = noise_pred # compute previous image: x_t -> x_t-1 + latents_dtype = latents.dtype latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs, return_dict=False)[0] + if latents.dtype != latents_dtype: + if torch.backends.mps.is_available(): + # some platforms (eg. apple mps) misbehave due to a pytorch bug: https://github.com/pytorch/pytorch/pull/99272 + latents = latents.to(latents_dtype) # call the callback, if provided if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0): progress_bar.update() @@ -802,14 +807,13 @@ def __call__( step_idx = i // getattr(self.scheduler, "order", 1) callback(step_idx, t, latents) - if not output_type == "latent": - # image = self.vae.decode(latents / self.vae.config.scaling_factor, return_dict=False)[0] - # Temporary for DCAE_HF(the not ready version) - image = self.vae.decode(latents.to(self.vae.dtype) / self.vae.config.scaling_factor) + if output_type == "latent": + image = latents + else: + latents = latents.to(self.vae.dtype) + image = self.vae.decode(latents / self.vae.config.scaling_factor, return_dict=False)[0] if use_resolution_binning: image = self.image_processor.resize_and_crop_tensor(image, orig_width, orig_height) - else: - image = latents if not output_type == "latent": image = self.image_processor.postprocess(image, output_type=output_type) From fe08f6799ca2443d96c9b18e937b7b218ba902de Mon Sep 17 00:00:00 2001 From: junsong Date: Thu, 28 Nov 2024 10:19:42 -0800 Subject: [PATCH 101/141] make style && make quality --- scripts/convert_sana_pag_to_diffusers.py | 8 +++++--- scripts/convert_sana_to_diffusers.py | 8 +++++--- src/diffusers/pipelines/pag/pipeline_pag_sana.py | 1 - 3 files changed, 10 insertions(+), 7 deletions(-) diff --git a/scripts/convert_sana_pag_to_diffusers.py b/scripts/convert_sana_pag_to_diffusers.py index ea5a3e5db27c..9a794197eb2b 100644 --- a/scripts/convert_sana_pag_to_diffusers.py +++ b/scripts/convert_sana_pag_to_diffusers.py @@ -7,6 +7,9 @@ import torch from accelerate import init_empty_weights +from termcolor import colored +from transformers import AutoModelForCausalLM, AutoTokenizer + from diffusers import ( DCAE, DPMSolverMultistepScheduler, @@ -16,8 +19,7 @@ ) from diffusers.models.modeling_utils import load_model_dict_into_meta from diffusers.utils.import_utils import is_accelerate_available -from termcolor import colored -from transformers import AutoModelForCausalLM, AutoTokenizer + CTX = init_empty_weights if is_accelerate_available else nullcontext @@ -203,7 +205,7 @@ def main(args): # Scheduler if args.scheduler_type == "flow-dpm_solver": scheduler = DPMSolverMultistepScheduler( - flow_shift=flow_shift, + flow_shift=flow_shift, use_flow_sigmas=True, prediction_type="flow_prediction", ) diff --git a/scripts/convert_sana_to_diffusers.py b/scripts/convert_sana_to_diffusers.py index 3735f506cad6..7339dcd7e24a 100644 --- a/scripts/convert_sana_to_diffusers.py +++ b/scripts/convert_sana_to_diffusers.py @@ -7,6 +7,9 @@ import torch from accelerate import init_empty_weights +from termcolor import colored +from transformers import AutoModelForCausalLM, AutoTokenizer + from diffusers import ( DCAE, DPMSolverMultistepScheduler, @@ -16,8 +19,7 @@ ) from diffusers.models.modeling_utils import load_model_dict_into_meta from diffusers.utils.import_utils import is_accelerate_available -from termcolor import colored -from transformers import AutoModelForCausalLM, AutoTokenizer + CTX = init_empty_weights if is_accelerate_available else nullcontext @@ -203,7 +205,7 @@ def main(args): # Scheduler if args.scheduler_type == "flow-dpm_solver": scheduler = DPMSolverMultistepScheduler( - flow_shift=flow_shift, + flow_shift=flow_shift, use_flow_sigmas=True, prediction_type="flow_prediction", ) diff --git a/src/diffusers/pipelines/pag/pipeline_pag_sana.py b/src/diffusers/pipelines/pag/pipeline_pag_sana.py index bff8a651dac6..8e83f6f0ecda 100644 --- a/src/diffusers/pipelines/pag/pipeline_pag_sana.py +++ b/src/diffusers/pipelines/pag/pipeline_pag_sana.py @@ -36,7 +36,6 @@ from ...utils.torch_utils import randn_tensor from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput from ..pixart_alpha.pipeline_pixart_alpha import ( - ASPECT_RATIO_256_BIN, ASPECT_RATIO_512_BIN, ASPECT_RATIO_1024_BIN, ) From 658e7e9accf2e1ba071cd2b946f1c24ea45879c1 Mon Sep 17 00:00:00 2001 From: Benjamin Paine <57536852+painebenjamin@users.noreply.github.com> Date: Tue, 3 Dec 2024 02:39:47 -0500 Subject: [PATCH 102/141] Add StableDiffusion3PAGImg2Img Pipeline + Fix SD3 Unconditional PAG (#9932) * fix progress bar updates in SD 1.5 PAG Img2Img pipeline --------- Co-authored-by: Vinh H. Pham Co-authored-by: Sayak Paul --- src/diffusers/__init__.py | 1 + 1 file changed, 1 insertion(+) diff --git a/src/diffusers/__init__.py b/src/diffusers/__init__.py index 106d4f2effab..d6866d6e875d 100644 --- a/src/diffusers/__init__.py +++ b/src/diffusers/__init__.py @@ -346,6 +346,7 @@ "StableDiffusion3InpaintPipeline", "StableDiffusion3PAGImg2ImgPipeline", "StableDiffusion3PAGPipeline", + "StableDiffusion3PAGImg2ImgPipeline", "StableDiffusion3Pipeline", "StableDiffusionAdapterPipeline", "StableDiffusionAttendAndExcitePipeline", From 6ab2d8d07792e31d2e35c446f2b73a447677351a Mon Sep 17 00:00:00 2001 From: lawrence-cj Date: Wed, 4 Dec 2024 22:55:12 +0800 Subject: [PATCH 103/141] make the vae can be None in `__init__` of `SanaPipeline` --- src/diffusers/pipelines/sana/pipeline_sana.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/diffusers/pipelines/sana/pipeline_sana.py b/src/diffusers/pipelines/sana/pipeline_sana.py index cedb4b0e70c4..6ec2add20cfe 100644 --- a/src/diffusers/pipelines/sana/pipeline_sana.py +++ b/src/diffusers/pipelines/sana/pipeline_sana.py @@ -167,7 +167,9 @@ def __init__( tokenizer=tokenizer, text_encoder=text_encoder, vae=vae, transformer=transformer, scheduler=scheduler ) - self.vae_scale_factor = 2 ** (len(self.vae.config.encoder_width_list) - 1) + self.vae_scale_factor = ( + 2 ** (len(self.vae.config.encoder_width_list) - 1) if hasattr(self, "vae") and self.vae is not None else 32 + ) self.image_processor = PixArtImageProcessor(vae_scale_factor=self.vae_scale_factor) # Copied from diffusers.pipelines.pixart_alpha.pipeline_pixart_alpha.PixArtAlphaPipeline.encode_prompt with 120->300 From 7602dd5560667311aacfde6dcaa0d6256e1d7b4f Mon Sep 17 00:00:00 2001 From: Junsong Chen Date: Thu, 5 Dec 2024 01:08:58 +0800 Subject: [PATCH 104/141] Update src/diffusers/models/transformers/sana_transformer_2d.py Co-authored-by: hlky --- src/diffusers/models/transformers/sana_transformer_2d.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/diffusers/models/transformers/sana_transformer_2d.py b/src/diffusers/models/transformers/sana_transformer_2d.py index f22bc6db2bf4..d49d4df41268 100644 --- a/src/diffusers/models/transformers/sana_transformer_2d.py +++ b/src/diffusers/models/transformers/sana_transformer_2d.py @@ -682,7 +682,9 @@ def custom_forward(*inputs): encoder_attention_mask, timestep, cross_attention_kwargs, - HW=(height, width), + None, + added_cond_kwargs, + (height, width), **ckpt_kwargs, ) else: From 5687ba19769e40efa68a915fd69120f52c7f8351 Mon Sep 17 00:00:00 2001 From: lawrence-cj Date: Thu, 5 Dec 2024 23:08:03 +0800 Subject: [PATCH 105/141] change the ae related code due to the latest update of DCAE branch; --- scripts/convert_sana_pag_to_diffusers.py | 6 +++--- scripts/convert_sana_to_diffusers.py | 6 +++--- src/diffusers/__init__.py | 2 -- src/diffusers/models/transformers/sana_transformer_2d.py | 2 +- src/diffusers/pipelines/pag/pipeline_pag_sana.py | 4 ++-- src/diffusers/pipelines/sana/pipeline_sana.py | 4 ++-- 6 files changed, 11 insertions(+), 13 deletions(-) diff --git a/scripts/convert_sana_pag_to_diffusers.py b/scripts/convert_sana_pag_to_diffusers.py index 9a794197eb2b..bc06edb72749 100644 --- a/scripts/convert_sana_pag_to_diffusers.py +++ b/scripts/convert_sana_pag_to_diffusers.py @@ -11,7 +11,7 @@ from transformers import AutoModelForCausalLM, AutoTokenizer from diffusers import ( - DCAE, + AutoencoderDC, DPMSolverMultistepScheduler, FlowMatchEulerDiscreteScheduler, SanaPAGPipeline, @@ -187,7 +187,7 @@ def main(args): else: print(colored(f"Saving the whole SanaPAGPipeline containing {args.model_type}", "green", attrs=["bold"])) # VAE - dc_ae = DCAE.from_pretrained( + ae = AutoencoderDC.from_pretrained( "Efficient-Large-Model/dc_ae_f32c32_sana_1.0_diffusers", torch_dtype=torch.float32, ).to(device) @@ -221,7 +221,7 @@ def main(args): tokenizer=tokenizer, text_encoder=text_encoder, transformer=transformer, - vae=dc_ae, + vae=ae, scheduler=scheduler, pag_applied_layers="blocks.8", ) diff --git a/scripts/convert_sana_to_diffusers.py b/scripts/convert_sana_to_diffusers.py index 7339dcd7e24a..4d04e2dc9aa4 100644 --- a/scripts/convert_sana_to_diffusers.py +++ b/scripts/convert_sana_to_diffusers.py @@ -11,7 +11,7 @@ from transformers import AutoModelForCausalLM, AutoTokenizer from diffusers import ( - DCAE, + AutoencoderDC, DPMSolverMultistepScheduler, FlowMatchEulerDiscreteScheduler, SanaPipeline, @@ -187,7 +187,7 @@ def main(args): else: print(colored(f"Saving the whole SanaPipeline containing {args.model_type}", "green", attrs=["bold"])) # VAE - dc_ae = DCAE.from_pretrained( + ae = AutoencoderDC.from_pretrained( "Efficient-Large-Model/dc_ae_f32c32_sana_1.0_diffusers", torch_dtype=torch.float32, ).to(device) @@ -221,7 +221,7 @@ def main(args): tokenizer=tokenizer, text_encoder=text_encoder, transformer=transformer, - vae=dc_ae, + vae=ae, scheduler=scheduler, ) diff --git a/src/diffusers/__init__.py b/src/diffusers/__init__.py index d6866d6e875d..901f34499dd3 100644 --- a/src/diffusers/__init__.py +++ b/src/diffusers/__init__.py @@ -130,7 +130,6 @@ "UNetSpatioTemporalConditionModel", "UVit2DModel", "VQModel", - "DCAE", ] ) _import_structure["optimization"] = [ @@ -576,7 +575,6 @@ from .utils.dummy_pt_objects import * # noqa F403 else: from .models import ( - DCAE, AllegroTransformer3DModel, AsymmetricAutoencoderKL, AuraFlowTransformer2DModel, diff --git a/src/diffusers/models/transformers/sana_transformer_2d.py b/src/diffusers/models/transformers/sana_transformer_2d.py index d49d4df41268..4aa9bc9a6a96 100644 --- a/src/diffusers/models/transformers/sana_transformer_2d.py +++ b/src/diffusers/models/transformers/sana_transformer_2d.py @@ -26,7 +26,7 @@ FusedAttnProcessor2_0, SanaLinearAttnProcessor2_0, ) -from ..autoencoders.dc_ae import GLUMBConv +from ..autoencoders.autoencoder_dc import GLUMBConv from ..embeddings import PatchEmbed, PixArtAlphaTextProjection, SinusoidalPositionalEmbedding from ..modeling_outputs import Transformer2DModelOutput from ..modeling_utils import ModelMixin diff --git a/src/diffusers/pipelines/pag/pipeline_pag_sana.py b/src/diffusers/pipelines/pag/pipeline_pag_sana.py index 8e83f6f0ecda..ebd7e27f7df3 100644 --- a/src/diffusers/pipelines/pag/pipeline_pag_sana.py +++ b/src/diffusers/pipelines/pag/pipeline_pag_sana.py @@ -22,7 +22,7 @@ from transformers import AutoModelForCausalLM, AutoTokenizer from ...image_processor import PixArtImageProcessor -from ...models import DCAE, SanaTransformer2DModel +from ...models import AutoencoderDC, SanaTransformer2DModel from ...models.attention_processor import PAGCFGSanaLinearAttnProcessor2_0, PAGIdentitySanaLinearAttnProcessor2_0 from ...schedulers import FlowDPMSolverMultistepScheduler from ...utils import ( @@ -161,7 +161,7 @@ def __init__( self, tokenizer: AutoTokenizer, text_encoder: AutoModelForCausalLM, - vae: DCAE, + vae: AutoencoderDC, transformer: SanaTransformer2DModel, scheduler: FlowDPMSolverMultistepScheduler, pag_applied_layers: Union[str, List[str]] = "blocks.1", # 1st transformer block diff --git a/src/diffusers/pipelines/sana/pipeline_sana.py b/src/diffusers/pipelines/sana/pipeline_sana.py index 6ec2add20cfe..e3d3f37c730a 100644 --- a/src/diffusers/pipelines/sana/pipeline_sana.py +++ b/src/diffusers/pipelines/sana/pipeline_sana.py @@ -22,7 +22,7 @@ from transformers import AutoModelForCausalLM, AutoTokenizer from ...image_processor import PixArtImageProcessor -from ...models import DCAE, SanaTransformer2DModel +from ...models import AutoencoderDC, SanaTransformer2DModel from ...schedulers import FlowDPMSolverMultistepScheduler from ...utils import ( BACKENDS_MAPPING, @@ -157,7 +157,7 @@ def __init__( self, tokenizer: AutoTokenizer, text_encoder: AutoModelForCausalLM, - vae: DCAE, + vae: AutoencoderDC, transformer: SanaTransformer2DModel, scheduler: FlowDPMSolverMultistepScheduler, ): From b76493f962d9947fae5ce8bc0ec52cdc965202bb Mon Sep 17 00:00:00 2001 From: lawrence-cj Date: Fri, 6 Dec 2024 17:04:27 +0800 Subject: [PATCH 106/141] change the ae related code due to the latest update of DCAE branch; --- scripts/convert_sana_pag_to_diffusers.py | 4 +-- .../transformers/sana_transformer_2d.py | 36 +++++++------------ 2 files changed, 14 insertions(+), 26 deletions(-) diff --git a/scripts/convert_sana_pag_to_diffusers.py b/scripts/convert_sana_pag_to_diffusers.py index bc06edb72749..50e10623a271 100644 --- a/scripts/convert_sana_pag_to_diffusers.py +++ b/scripts/convert_sana_pag_to_diffusers.py @@ -188,8 +188,8 @@ def main(args): print(colored(f"Saving the whole SanaPAGPipeline containing {args.model_type}", "green", attrs=["bold"])) # VAE ae = AutoencoderDC.from_pretrained( - "Efficient-Large-Model/dc_ae_f32c32_sana_1.0_diffusers", - torch_dtype=torch.float32, + "mit-han-lab/dc-ae-f32c32-sana-1.0-diffusers", + torch_dtype=torch.bfloat16, ).to(device) # Text Encoder diff --git a/src/diffusers/models/transformers/sana_transformer_2d.py b/src/diffusers/models/transformers/sana_transformer_2d.py index 4aa9bc9a6a96..0abbae0e8275 100644 --- a/src/diffusers/models/transformers/sana_transformer_2d.py +++ b/src/diffusers/models/transformers/sana_transformer_2d.py @@ -60,30 +60,18 @@ def __init__(self, dim, eps: float, elementwise_affine: bool = True, scale_facto # Modified from diffusers.models.autoencoders.ecae.GLUMBConv @maybe_allow_in_graph -class SanaGLUMBConv(GLUMBConv): - def __init__( - self, - in_channels: int, - out_channels: int, - kernel_size=3, - stride=1, - mid_channels=None, - expand_ratio=2.5, - use_bias=False, - norm=(None, None, None), - act_func=("silu", "silu", None), - ): - super().__init__( - in_channels=in_channels, - out_channels=out_channels, - kernel_size=kernel_size, - stride=stride, - mid_channels=mid_channels, - expand_ratio=expand_ratio, - use_bias=use_bias, - norm=norm, - act_func=act_func, - ) +class SanaGLUMBConv(nn.Module): + def __init__(self, in_channels: int, out_channels: int) -> None: + super().__init__() + + hidden_channels = int(2.5 * in_channels) + + self.nonlinearity = nn.SiLU() + + self.conv_inverted = nn.Conv2d(in_channels, hidden_channels * 2, 1, 1, 0) + self.conv_depth = nn.Conv2d(hidden_channels * 2, hidden_channels * 2, 3, 1, 1, groups=hidden_channels * 2) + self.conv_point = nn.Conv2d(hidden_channels, out_channels, 1, 1, 0, bias=False) + self.norm = RMSNorm(out_channels, eps=1e-5, elementwise_affine=True, bias=True) def forward(self, x: torch.Tensor, HW=None) -> torch.Tensor: B, N, C = x.shape From 297c0e7802d70988261cbe1de960066e9221f1bb Mon Sep 17 00:00:00 2001 From: junsong Date: Fri, 6 Dec 2024 02:14:40 -0800 Subject: [PATCH 107/141] 1. change code based on AutoencoderDC; 2. fix the bug of new GLUMBConv; 3. run success; --- scripts/convert_sana_pag_to_diffusers.py | 15 +++---- scripts/convert_sana_to_diffusers.py | 19 ++++----- src/diffusers/models/attention_processor.py | 6 ++- .../transformers/sana_transformer_2d.py | 40 +++++++------------ .../pipelines/pag/pipeline_pag_sana.py | 2 +- src/diffusers/pipelines/sana/pipeline_sana.py | 2 +- 6 files changed, 36 insertions(+), 48 deletions(-) diff --git a/scripts/convert_sana_pag_to_diffusers.py b/scripts/convert_sana_pag_to_diffusers.py index 50e10623a271..dad2db9315b9 100644 --- a/scripts/convert_sana_pag_to_diffusers.py +++ b/scripts/convert_sana_pag_to_diffusers.py @@ -59,12 +59,11 @@ def main(args): # y norm converted_state_dict["caption_norm.weight"] = state_dict.pop("attention_y_norm.weight") + flow_shift = 3.0 if args.model_type == "SanaMS_1600M_P1_D20": layer_num = 20 - flow_shift = 3.0 elif args.model_type == "SanaMS_600M_P1_D28": layer_num = 28 - flow_shift = 4.0 else: raise ValueError(f"{args.model_type} is not supported.") @@ -89,19 +88,19 @@ def main(args): ) # Feed-forward. - converted_state_dict[f"transformer_blocks.{depth}.ff.inverted_conv.conv.weight"] = state_dict.pop( + converted_state_dict[f"transformer_blocks.{depth}.ff.conv_inverted.weight"] = state_dict.pop( f"blocks.{depth}.mlp.inverted_conv.conv.weight" ) - converted_state_dict[f"transformer_blocks.{depth}.ff.inverted_conv.conv.bias"] = state_dict.pop( + converted_state_dict[f"transformer_blocks.{depth}.ff.conv_inverted.bias"] = state_dict.pop( f"blocks.{depth}.mlp.inverted_conv.conv.bias" ) - converted_state_dict[f"transformer_blocks.{depth}.ff.depth_conv.conv.weight"] = state_dict.pop( + converted_state_dict[f"transformer_blocks.{depth}.ff.conv_depth.weight"] = state_dict.pop( f"blocks.{depth}.mlp.depth_conv.conv.weight" ) - converted_state_dict[f"transformer_blocks.{depth}.ff.depth_conv.conv.bias"] = state_dict.pop( + converted_state_dict[f"transformer_blocks.{depth}.ff.conv_depth.bias"] = state_dict.pop( f"blocks.{depth}.mlp.depth_conv.conv.bias" ) - converted_state_dict[f"transformer_blocks.{depth}.ff.point_conv.conv.weight"] = state_dict.pop( + converted_state_dict[f"transformer_blocks.{depth}.ff.conv_point.weight"] = state_dict.pop( f"blocks.{depth}.mlp.point_conv.conv.weight" ) @@ -156,8 +155,6 @@ def main(args): attention_type="default", use_pe=False, expand_ratio=2.5, - ff_bias=(True, True, False), - ff_norm=(None, None, None), ) if is_accelerate_available(): load_model_dict_into_meta(transformer, converted_state_dict) diff --git a/scripts/convert_sana_to_diffusers.py b/scripts/convert_sana_to_diffusers.py index 4d04e2dc9aa4..11d9c0011098 100644 --- a/scripts/convert_sana_to_diffusers.py +++ b/scripts/convert_sana_to_diffusers.py @@ -59,12 +59,11 @@ def main(args): # y norm converted_state_dict["caption_norm.weight"] = state_dict.pop("attention_y_norm.weight") + flow_shift = 3.0 if args.model_type == "SanaMS_1600M_P1_D20": layer_num = 20 - flow_shift = 3.0 elif args.model_type == "SanaMS_600M_P1_D28": layer_num = 28 - flow_shift = 4.0 else: raise ValueError(f"{args.model_type} is not supported.") @@ -89,19 +88,19 @@ def main(args): ) # Feed-forward. - converted_state_dict[f"transformer_blocks.{depth}.ff.inverted_conv.conv.weight"] = state_dict.pop( + converted_state_dict[f"transformer_blocks.{depth}.ff.conv_inverted.weight"] = state_dict.pop( f"blocks.{depth}.mlp.inverted_conv.conv.weight" ) - converted_state_dict[f"transformer_blocks.{depth}.ff.inverted_conv.conv.bias"] = state_dict.pop( + converted_state_dict[f"transformer_blocks.{depth}.ff.conv_inverted.bias"] = state_dict.pop( f"blocks.{depth}.mlp.inverted_conv.conv.bias" ) - converted_state_dict[f"transformer_blocks.{depth}.ff.depth_conv.conv.weight"] = state_dict.pop( + converted_state_dict[f"transformer_blocks.{depth}.ff.conv_depth.weight"] = state_dict.pop( f"blocks.{depth}.mlp.depth_conv.conv.weight" ) - converted_state_dict[f"transformer_blocks.{depth}.ff.depth_conv.conv.bias"] = state_dict.pop( + converted_state_dict[f"transformer_blocks.{depth}.ff.conv_depth.bias"] = state_dict.pop( f"blocks.{depth}.mlp.depth_conv.conv.bias" ) - converted_state_dict[f"transformer_blocks.{depth}.ff.point_conv.conv.weight"] = state_dict.pop( + converted_state_dict[f"transformer_blocks.{depth}.ff.conv_point.weight"] = state_dict.pop( f"blocks.{depth}.mlp.point_conv.conv.weight" ) @@ -156,8 +155,6 @@ def main(args): attention_type="default", use_pe=False, expand_ratio=2.5, - ff_bias=(True, True, False), - ff_norm=(None, None, None), ) if is_accelerate_available(): load_model_dict_into_meta(transformer, converted_state_dict) @@ -188,8 +185,8 @@ def main(args): print(colored(f"Saving the whole SanaPipeline containing {args.model_type}", "green", attrs=["bold"])) # VAE ae = AutoencoderDC.from_pretrained( - "Efficient-Large-Model/dc_ae_f32c32_sana_1.0_diffusers", - torch_dtype=torch.float32, + "mit-han-lab/dc-ae-f32c32-sana-1.0-diffusers", + torch_dtype=torch.bfloat16, ).to(device) # Text Encoder diff --git a/src/diffusers/models/attention_processor.py b/src/diffusers/models/attention_processor.py index 075f6b98d829..39b09c8a252a 100644 --- a/src/diffusers/models/attention_processor.py +++ b/src/diffusers/models/attention_processor.py @@ -5552,6 +5552,11 @@ def __call__( CustomDiffusionAttnProcessor2_0, SlicedAttnProcessor, SlicedAttnAddedKVProcessor, + SanaLinearAttnProcessor2_0, + SanaMultiscaleLinearAttention, + SanaMultiscaleAttnProcessor2_0, + SanaMultiscaleAttentionProjection, + PAGCFGSanaLinearAttnProcessor2_0, IPAdapterAttnProcessor, IPAdapterAttnProcessor2_0, IPAdapterXFormersAttnProcessor, @@ -5562,5 +5567,4 @@ def __call__( LoRAXFormersAttnProcessor, LoRAAttnAddedKVProcessor, SanaLinearAttnProcessor2_0, - PAGCFGSanaLinearAttnProcessor2_0, ] diff --git a/src/diffusers/models/transformers/sana_transformer_2d.py b/src/diffusers/models/transformers/sana_transformer_2d.py index 0abbae0e8275..469cbac7fa24 100644 --- a/src/diffusers/models/transformers/sana_transformer_2d.py +++ b/src/diffusers/models/transformers/sana_transformer_2d.py @@ -26,7 +26,6 @@ FusedAttnProcessor2_0, SanaLinearAttnProcessor2_0, ) -from ..autoencoders.autoencoder_dc import GLUMBConv from ..embeddings import PatchEmbed, PixArtAlphaTextProjection, SinusoidalPositionalEmbedding from ..modeling_outputs import Transformer2DModelOutput from ..modeling_utils import ModelMixin @@ -58,40 +57,40 @@ def __init__(self, dim, eps: float, elementwise_affine: bool = True, scale_facto self.weight = nn.Parameter(torch.ones(dim) * scale_factor) -# Modified from diffusers.models.autoencoders.ecae.GLUMBConv +# Modified from diffusers.models.autoencoders.autoencoder_dc.GLUMBConv @maybe_allow_in_graph class SanaGLUMBConv(nn.Module): - def __init__(self, in_channels: int, out_channels: int) -> None: + def __init__(self, in_channels: int, out_channels: int, expand_ratio: float = 2.5) -> None: super().__init__() - hidden_channels = int(2.5 * in_channels) + hidden_channels = int(expand_ratio * in_channels) self.nonlinearity = nn.SiLU() self.conv_inverted = nn.Conv2d(in_channels, hidden_channels * 2, 1, 1, 0) self.conv_depth = nn.Conv2d(hidden_channels * 2, hidden_channels * 2, 3, 1, 1, groups=hidden_channels * 2) self.conv_point = nn.Conv2d(hidden_channels, out_channels, 1, 1, 0, bias=False) - self.norm = RMSNorm(out_channels, eps=1e-5, elementwise_affine=True, bias=True) - def forward(self, x: torch.Tensor, HW=None) -> torch.Tensor: - B, N, C = x.shape + def forward(self, hidden_states: torch.Tensor, HW: Optional[tuple[int]] = None) -> torch.Tensor: + B, N, C = hidden_states.shape if HW is None: H = W = int(N**0.5) else: H, W = HW - x = x.reshape(B, H, W, C).permute(0, 3, 1, 2) - x = self.inverted_conv(x) - x = self.depth_conv(x) + hidden_states = hidden_states.reshape(B, H, W, C).permute(0, 3, 1, 2) - x, gate = torch.chunk(x, 2, dim=1) - gate = self.glu_act(gate) - x = x * gate + hidden_states = self.conv_inverted(hidden_states) + hidden_states = self.nonlinearity(hidden_states) - x = self.point_conv(x) - x = x.reshape(B, C, N).permute(0, 2, 1) + hidden_states = self.conv_depth(hidden_states) + hidden_states, gate = torch.chunk(hidden_states, 2, dim=1) + hidden_states = hidden_states * self.nonlinearity(gate) - return x + hidden_states = self.conv_point(hidden_states) + hidden_states = hidden_states.reshape(B, C, N).permute(0, 2, 1) + + return hidden_states # Modified from diffusers.models.attention.BasicTransformerBlock @@ -130,8 +129,6 @@ def __init__( use_pe: bool = False, num_positional_embeddings: Optional[int] = None, expand_ratio: float = 2.5, - ff_bias: tuple =(True, True, False), - ff_norm: tuple =(None, None, None), ): super().__init__() self.dim = dim @@ -186,9 +183,6 @@ def __init__( in_channels=dim, out_channels=dim, expand_ratio=expand_ratio, - use_bias=ff_bias, - norm=ff_norm, - act_func=activation_fn, ) # 5. Scale-shift for Sana. @@ -362,8 +356,6 @@ def __init__( attention_type: Optional[str] = "default", use_pe: Optional[bool] = False, expand_ratio=2.5, - ff_bias: tuple =(True, True, False), - ff_norm: tuple =(None, None, None), ): super().__init__() @@ -428,8 +420,6 @@ def __init__( norm_eps=self.config.norm_eps, use_pe=self.config.use_pe, expand_ratio=self.config.expand_ratio, - ff_bias=self.config.ff_bias, - ff_norm=self.config.ff_norm, ) for _ in range(self.config.num_layers) ] diff --git a/src/diffusers/pipelines/pag/pipeline_pag_sana.py b/src/diffusers/pipelines/pag/pipeline_pag_sana.py index ebd7e27f7df3..d176bfc9709a 100644 --- a/src/diffusers/pipelines/pag/pipeline_pag_sana.py +++ b/src/diffusers/pipelines/pag/pipeline_pag_sana.py @@ -172,7 +172,7 @@ def __init__( tokenizer=tokenizer, text_encoder=text_encoder, vae=vae, transformer=transformer, scheduler=scheduler ) - self.vae_scale_factor = 2 ** (len(self.vae.config.encoder_width_list) - 1) + self.vae_scale_factor = 2 ** (len(self.vae.config.encoder_block_out_channels) - 1) self.image_processor = PixArtImageProcessor(vae_scale_factor=self.vae_scale_factor) self.set_pag_applied_layers( diff --git a/src/diffusers/pipelines/sana/pipeline_sana.py b/src/diffusers/pipelines/sana/pipeline_sana.py index e3d3f37c730a..728776a89269 100644 --- a/src/diffusers/pipelines/sana/pipeline_sana.py +++ b/src/diffusers/pipelines/sana/pipeline_sana.py @@ -168,7 +168,7 @@ def __init__( ) self.vae_scale_factor = ( - 2 ** (len(self.vae.config.encoder_width_list) - 1) if hasattr(self, "vae") and self.vae is not None else 32 + 2 ** (len(self.vae.config.encoder_block_out_channels) - 1) if hasattr(self, "vae") and self.vae is not None else 32 ) self.image_processor = PixArtImageProcessor(vae_scale_factor=self.vae_scale_factor) From e7c1a59e5060ee5e1443343599fd490053fbb760 Mon Sep 17 00:00:00 2001 From: lawrence-cj Date: Mon, 9 Dec 2024 17:52:03 +0800 Subject: [PATCH 108/141] update for solving conversation. --- src/diffusers/models/attention_processor.py | 1 - src/diffusers/models/normalization.py | 38 ++++ src/diffusers/models/transformers/__init__.py | 2 +- ..._transformer_2d.py => sana_transformer.py} | 170 ++++++------------ 4 files changed, 89 insertions(+), 122 deletions(-) rename src/diffusers/models/transformers/{sana_transformer_2d.py => sana_transformer.py} (82%) diff --git a/src/diffusers/models/attention_processor.py b/src/diffusers/models/attention_processor.py index 39b09c8a252a..2ffac2b31dc9 100644 --- a/src/diffusers/models/attention_processor.py +++ b/src/diffusers/models/attention_processor.py @@ -5566,5 +5566,4 @@ def __call__( LoRAAttnProcessor2_0, LoRAXFormersAttnProcessor, LoRAAttnAddedKVProcessor, - SanaLinearAttnProcessor2_0, ] diff --git a/src/diffusers/models/normalization.py b/src/diffusers/models/normalization.py index 264de4d18d03..ec44c3d4e471 100644 --- a/src/diffusers/models/normalization.py +++ b/src/diffusers/models/normalization.py @@ -590,3 +590,41 @@ def get_normalization( else: raise ValueError(f"{norm_type=} is not supported.") return norm + + +class RMSNormScaled(nn.Module): + def __init__(self, dim, eps: float, elementwise_affine: bool = True, scale_factor: float = 1.0, bias: bool = False): + super().__init__(dim, eps, elementwise_affine) + self.weight = nn.Parameter(torch.ones(dim) * scale_factor) + + self.eps = eps + self.elementwise_affine = elementwise_affine + + if isinstance(dim, numbers.Integral): + dim = (dim,) + + self.dim = torch.Size(dim) + + self.weight = None + self.bias = None + + if elementwise_affine: + self.weight = nn.Parameter(torch.ones(dim) * scale_factor) + if bias: + self.bias = nn.Parameter(torch.zeros(dim)) + def forward(self, hidden_states): + input_dtype = hidden_states.dtype + variance = hidden_states.to(torch.float32).pow(2).mean(-1, keepdim=True) + hidden_states = hidden_states * torch.rsqrt(variance + self.eps) + + if self.weight is not None: + # convert into half-precision if necessary + if self.weight.dtype in [torch.float16, torch.bfloat16]: + hidden_states = hidden_states.to(self.weight.dtype) + hidden_states = hidden_states * self.weight + if self.bias is not None: + hidden_states = hidden_states + self.bias + else: + hidden_states = hidden_states.to(input_dtype) + + return hidden_states diff --git a/src/diffusers/models/transformers/__init__.py b/src/diffusers/models/transformers/__init__.py index ce9b2424ab9d..d920182ada0b 100644 --- a/src/diffusers/models/transformers/__init__.py +++ b/src/diffusers/models/transformers/__init__.py @@ -11,7 +11,7 @@ from .lumina_nextdit2d import LuminaNextDiT2DModel from .pixart_transformer_2d import PixArtTransformer2DModel from .prior_transformer import PriorTransformer - from .sana_transformer_2d import SanaTransformer2DModel + from .sana_transformer import SanaTransformer2DModel from .stable_audio_transformer import StableAudioDiTModel from .t5_film_transformer import T5FilmDecoder from .transformer_2d import Transformer2DModel diff --git a/src/diffusers/models/transformers/sana_transformer_2d.py b/src/diffusers/models/transformers/sana_transformer.py similarity index 82% rename from src/diffusers/models/transformers/sana_transformer_2d.py rename to src/diffusers/models/transformers/sana_transformer.py index 469cbac7fa24..967482bdd629 100644 --- a/src/diffusers/models/transformers/sana_transformer_2d.py +++ b/src/diffusers/models/transformers/sana_transformer.py @@ -11,6 +11,7 @@ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. +import numbers from typing import Any, Dict, Optional, Union import torch @@ -25,38 +26,18 @@ AttnProcessor2_0, FusedAttnProcessor2_0, SanaLinearAttnProcessor2_0, + SanaMultiscaleAttnProcessor2_0, + SanaMultiscaleLinearAttention, ) from ..embeddings import PatchEmbed, PixArtAlphaTextProjection, SinusoidalPositionalEmbedding from ..modeling_outputs import Transformer2DModelOutput from ..modeling_utils import ModelMixin -from ..normalization import AdaLayerNormSingle, RMSNorm +from ..normalization import AdaLayerNormSingle, RMSNormScaled logger = logging.get_logger(__name__) # pylint: disable=invalid-name -def _chunked_feed_forward(ff: nn.Module, hidden_states: torch.Tensor, chunk_dim: int, chunk_size: int, HW: tuple=None): - # "feed_forward_chunk_size" can be used to save memory - if hidden_states.shape[chunk_dim] % chunk_size != 0: - raise ValueError( - f"`hidden_states` dimension to be chunked: {hidden_states.shape[chunk_dim]} has to be divisible by chunk size: {chunk_size}. Make sure to set an appropriate `chunk_size` when calling `unet.enable_forward_chunking`." - ) - - num_chunks = hidden_states.shape[chunk_dim] // chunk_size - ff_output = torch.cat( - [ff(hid_slice, HW) for hid_slice in hidden_states.chunk(num_chunks, dim=chunk_dim)], - dim=chunk_dim, - ) - return ff_output - - -@maybe_allow_in_graph -class RMSNormScaled(RMSNorm): - def __init__(self, dim, eps: float, elementwise_affine: bool = True, scale_factor: float = 1.0): - super().__init__(dim, eps, elementwise_affine) - self.weight = nn.Parameter(torch.ones(dim) * scale_factor) - - # Modified from diffusers.models.autoencoders.autoencoder_dc.GLUMBConv @maybe_allow_in_graph class SanaGLUMBConv(nn.Module): @@ -105,22 +86,19 @@ class SanaLinearTransformerBlock(nn.Module): dim (`int`): The number of channels in the input and output. num_attention_heads (`int`): The number of heads to use for multi-head attention. attention_head_dim (`int`): The number of channels in each head. - context_pre_only (`bool`): Boolean to determine if we should add some blocks associated with the - processing of `context` conditions. """ def __init__( self, - dim: int, - num_attention_heads: int, - attention_head_dim: int, - dropout=0.0, - num_cross_attention_heads: Optional[int] = None, - cross_attention_head_dim: Optional[int] = None, - cross_attention_dim: Optional[int] = None, - activation_fn: tuple = ("silu", "silu", None), - num_embeds_ada_norm: Optional[int] = None, - attention_bias: bool = False, + dim: int = 2240, + num_attention_heads: int = 70, + attention_head_dim: int = 32, + dropout: float = 0.0, + num_cross_attention_heads: Optional[int] = 20, + cross_attention_head_dim: Optional[int] = 112, + cross_attention_dim: Optional[int] = 2240, + num_embeds_ada_norm: Optional[int] = 1000, + attention_bias: bool = True, upcast_attention: bool = False, norm_type: str = "ada_norm_single", norm_elementwise_affine: bool = False, @@ -136,7 +114,6 @@ def __init__( self.attention_head_dim = attention_head_dim self.dropout = dropout self.cross_attention_dim = cross_attention_dim - self.activation_fn = activation_fn self.attention_bias = attention_bias self.norm_elementwise_affine = norm_elementwise_affine @@ -205,8 +182,6 @@ def forward( encoder_attention_mask: Optional[torch.Tensor] = None, timestep: Optional[torch.LongTensor] = None, cross_attention_kwargs: Dict[str, Any] = None, - class_labels: Optional[torch.LongTensor] = None, - added_cond_kwargs: Optional[Dict[str, torch.Tensor]] = None, HW: Optional[tuple[int]] = None, ) -> torch.Tensor: if cross_attention_kwargs is not None: @@ -260,11 +235,7 @@ def forward( norm_hidden_states = self.norm2(hidden_states) norm_hidden_states = norm_hidden_states * (1 + scale_mlp) + shift_mlp - if self._chunk_size is not None: - # "feed_forward_chunk_size" can be used to save memory - ff_output = _chunked_feed_forward(self.ff, norm_hidden_states, self._chunk_dim, self._chunk_size, HW=HW) - else: - ff_output = self.ff(norm_hidden_states, HW=HW) + ff_output = self.ff(norm_hidden_states, HW=HW) if self.norm_type == "ada_norm_single": ff_output = gate_mlp * ff_output @@ -301,8 +272,6 @@ class SanaTransformer2DModel(ModelMixin, ConfigMixin): The width of the latent images. This parameter is fixed during training. patch_size (int, defaults to 1): Size of the patches the model processes, relevant for architectures working on non-sequential data. - activation_fn (str, optional, defaults to "gelu-approximate"): - Activation function to use in feed-forward networks within Transformer blocks. num_embeds_ada_norm (int, optional, defaults to 1000): Number of embeddings for AdaLayerNorm, fixed during training and affects the maximum denoising steps during inference. @@ -338,11 +307,10 @@ def __init__( norm_num_groups: int = 32, num_cross_attention_heads: Optional[int] = 20, cross_attention_head_dim: Optional[int] = 112, - cross_attention_dim: Optional[int] = 1152, + cross_attention_dim: Optional[int] = 2240, attention_bias: bool = True, sample_size: int = 32, patch_size: int = 1, - activation_fn: tuple = ("silu", "silu", None), num_embeds_ada_norm: Optional[int] = 1000, upcast_attention: bool = False, norm_type: str = "ada_norm_single", @@ -371,7 +339,7 @@ def __init__( # Set some common variables used across the board. self.attention_head_dim = attention_head_dim - self.inner_dim = self.config.num_attention_heads * self.config.attention_head_dim + self.inner_dim = num_attention_heads * attention_head_dim self.out_channels = in_channels if out_channels is None else out_channels if use_additional_conditions is None: if sample_size == 128: @@ -383,63 +351,66 @@ def __init__( self.gradient_checkpointing = False # 2. Initialize the position embedding and transformer blocks. - self.height = self.config.sample_size - self.width = self.config.sample_size + self.height = sample_size + self.width = sample_size + + if use_pe: + interpolation_scale = ( + interpolation_scale + if interpolation_scale is not None + else max(sample_size // 64, 1) + ) + else: + interpolation_scale = None - interpolation_scale = ( - self.config.interpolation_scale - if self.config.interpolation_scale is not None - else max(self.config.sample_size // 64, 1) - ) self.pos_embed = PatchEmbed( - height=self.config.sample_size, - width=self.config.sample_size, - patch_size=self.config.patch_size, - in_channels=self.config.in_channels, + height=sample_size, + width=sample_size, + patch_size=patch_size, + in_channels=in_channels, embed_dim=self.inner_dim, interpolation_scale=interpolation_scale, - pos_embed_type="sincos" if self.config.use_pe else None + pos_embed_type="sincos" if use_pe else None ) self.transformer_blocks = nn.ModuleList( [ SanaLinearTransformerBlock( self.inner_dim, - self.config.num_attention_heads, - self.config.attention_head_dim, - dropout=self.config.dropout, - num_cross_attention_heads=self.config.num_cross_attention_heads, - cross_attention_head_dim=self.config.cross_attention_head_dim, - cross_attention_dim=self.config.cross_attention_dim, - activation_fn=self.config.activation_fn, - num_embeds_ada_norm=self.config.num_embeds_ada_norm, - attention_bias=self.config.attention_bias, - upcast_attention=self.config.upcast_attention, + num_attention_heads, + attention_head_dim, + dropout=dropout, + num_cross_attention_heads=num_cross_attention_heads, + cross_attention_head_dim=cross_attention_head_dim, + cross_attention_dim=cross_attention_dim, + num_embeds_ada_norm=num_embeds_ada_norm, + attention_bias=attention_bias, + upcast_attention=upcast_attention, norm_type=norm_type, - norm_elementwise_affine=self.config.norm_elementwise_affine, - norm_eps=self.config.norm_eps, - use_pe=self.config.use_pe, - expand_ratio=self.config.expand_ratio, + norm_elementwise_affine=norm_elementwise_affine, + norm_eps=norm_eps, + use_pe=use_pe, + expand_ratio=expand_ratio, ) - for _ in range(self.config.num_layers) + for _ in range(num_layers) ] ) # 3. Output blocks. self.norm_out = nn.LayerNorm(self.inner_dim, elementwise_affine=False, eps=1e-6) self.scale_shift_table = nn.Parameter(torch.randn(2, self.inner_dim) / self.inner_dim**0.5) - self.proj_out = nn.Linear(self.inner_dim, self.config.patch_size * self.config.patch_size * self.out_channels) + self.proj_out = nn.Linear(self.inner_dim, patch_size * patch_size * self.out_channels) self.adaln_single = AdaLayerNormSingle( self.inner_dim, use_additional_conditions=self.use_additional_conditions ) self.caption_projection = None - if self.config.caption_channels is not None: + if caption_channels is not None: self.caption_projection = PixArtAlphaTextProjection( - in_features=self.config.caption_channels, hidden_size=self.inner_dim + in_features=caption_channels, hidden_size=self.inner_dim ) self.caption_norm = None - if self.config.use_caption_norm: + if use_caption_norm: self.caption_norm = RMSNormScaled(self.inner_dim, eps=1e-5, scale_factor=caption_norm_scale_factor) def _set_gradient_checkpointing(self, module, value=False): @@ -506,46 +477,6 @@ def fn_recursive_attn_processor(name: str, module: torch.nn.Module, processor): for name, module in self.named_children(): fn_recursive_attn_processor(name, module, processor) - # Copied from diffusers.models.unets.unet_2d_condition.UNet2DConditionModel.fuse_qkv_projections - def fuse_qkv_projections(self): - """ - Enables fused QKV projections. For self-attention modules, all projection matrices (i.e., query, key, value) - are fused. For cross-attention modules, key and value projection matrices are fused. - - - - This API is 🧪 experimental. - - - """ - self.original_attn_processors = None - - for _, attn_processor in self.attn_processors.items(): - if "Added" in str(attn_processor.__class__.__name__): - raise ValueError("`fuse_qkv_projections()` is not supported for models having added KV projections.") - - self.original_attn_processors = self.attn_processors - - for module in self.modules(): - if isinstance(module, Attention): - module.fuse_projections(fuse=True) - - self.set_attn_processor(FusedAttnProcessor2_0()) - - # Copied from diffusers.models.unets.unet_2d_condition.UNet2DConditionModel.unfuse_qkv_projections - def unfuse_qkv_projections(self): - """Disables the fused QKV projection if enabled. - - - - This API is 🧪 experimental. - - - - """ - if self.original_attn_processors is not None: - self.set_attn_processor(self.original_attn_processors) - def forward( self, hidden_states: torch.Tensor, @@ -556,7 +487,6 @@ def forward( cross_attention_kwargs: Dict[str, Any] = None, attention_mask: Optional[torch.Tensor] = None, return_dict: bool = True, - **kwargs, ): """ The [`PixArtTransformer2DModel`] forward method. From ad3935f968156c39e439bf62a21100d857b9f1b6 Mon Sep 17 00:00:00 2001 From: junsong Date: Mon, 9 Dec 2024 02:30:58 -0800 Subject: [PATCH 109/141] 1. fix bugs and run convert script success; 2. Downloading ckpt from hub automatically; --- scripts/convert_sana_to_diffusers.py | 29 +++++++++++++++++-- src/diffusers/models/__init__.py | 2 +- src/diffusers/models/autoencoders/__init__.py | 2 +- src/diffusers/models/normalization.py | 2 +- .../models/transformers/sana_transformer.py | 4 ++- 5 files changed, 32 insertions(+), 7 deletions(-) diff --git a/scripts/convert_sana_to_diffusers.py b/scripts/convert_sana_to_diffusers.py index 11d9c0011098..0fd8cb66e396 100644 --- a/scripts/convert_sana_to_diffusers.py +++ b/scripts/convert_sana_to_diffusers.py @@ -19,16 +19,39 @@ ) from diffusers.models.modeling_utils import load_model_dict_into_meta from diffusers.utils.import_utils import is_accelerate_available - +from huggingface_hub import hf_hub_download, snapshot_download CTX = init_empty_weights if is_accelerate_available else nullcontext -ckpt_id = "Sana" +ckpt_ids = [ + "Efficient-Large-Model/Sana_1600M_1024px_MultiLing", + "Efficient-Large-Model/Sana_1600M_512px_MultiLing", + "Efficient-Large-Model/Sana_1600M_1024px", + "Efficient-Large-Model/Sana_1600M_512px", + "Efficient-Large-Model/Sana_600M_1024px", + "Efficient-Large-Model/Sana_600M_512px", +] # https://github.com/NVlabs/Sana/blob/main/scripts/inference.py def main(args): - all_state_dict = torch.load(args.orig_ckpt_path, map_location=torch.device("cpu")) + ckpt_id = ckpt_ids[0] + cache_dir_path = os.path.expanduser("~/.cache/huggingface/hub") + if args.orig_ckpt_path is None: + snapshot_download( + repo_id=ckpt_id, + cache_dir=cache_dir_path, + repo_type="model", + ) + file_path = hf_hub_download( + repo_id=ckpt_id, + filename=f"checkpoints/{ckpt_id.split('/')[-1]}.pth", + cache_dir=cache_dir_path, + repo_type="model", + ) + else: + file_path = args.orig_ckpt_path + all_state_dict = torch.load(file_path, map_location=torch.device("cpu")) state_dict = all_state_dict.pop("state_dict") converted_state_dict = {} diff --git a/src/diffusers/models/__init__.py b/src/diffusers/models/__init__.py index 0cba7ad27f0b..5ce09e4dfe6f 100644 --- a/src/diffusers/models/__init__.py +++ b/src/diffusers/models/__init__.py @@ -57,7 +57,7 @@ _import_structure["transformers.latte_transformer_3d"] = ["LatteTransformer3DModel"] _import_structure["transformers.lumina_nextdit2d"] = ["LuminaNextDiT2DModel"] _import_structure["transformers.pixart_transformer_2d"] = ["PixArtTransformer2DModel"] - _import_structure["transformers.sana_transformer_2d"] = ["SanaTransformer2DModel"] + _import_structure["transformers.sana_transformer"] = ["SanaTransformer2DModel"] _import_structure["transformers.prior_transformer"] = ["PriorTransformer"] _import_structure["transformers.stable_audio_transformer"] = ["StableAudioDiTModel"] _import_structure["transformers.t5_film_transformer"] = ["T5FilmDecoder"] diff --git a/src/diffusers/models/autoencoders/__init__.py b/src/diffusers/models/autoencoders/__init__.py index c5cff445e0cf..66139347e7a0 100644 --- a/src/diffusers/models/autoencoders/__init__.py +++ b/src/diffusers/models/autoencoders/__init__.py @@ -8,5 +8,5 @@ from .autoencoder_oobleck import AutoencoderOobleck from .autoencoder_tiny import AutoencoderTiny from .consistency_decoder_vae import ConsistencyDecoderVAE -from .autoencoder_dc import DCAE +from .autoencoder_dc import AutoencoderDC from .vq_model import VQModel diff --git a/src/diffusers/models/normalization.py b/src/diffusers/models/normalization.py index ec44c3d4e471..35d5e6a03ba0 100644 --- a/src/diffusers/models/normalization.py +++ b/src/diffusers/models/normalization.py @@ -594,7 +594,7 @@ def get_normalization( class RMSNormScaled(nn.Module): def __init__(self, dim, eps: float, elementwise_affine: bool = True, scale_factor: float = 1.0, bias: bool = False): - super().__init__(dim, eps, elementwise_affine) + super().__init__() self.weight = nn.Parameter(torch.ones(dim) * scale_factor) self.eps = eps diff --git a/src/diffusers/models/transformers/sana_transformer.py b/src/diffusers/models/transformers/sana_transformer.py index 967482bdd629..8fed200c9ef6 100644 --- a/src/diffusers/models/transformers/sana_transformer.py +++ b/src/diffusers/models/transformers/sana_transformer.py @@ -248,7 +248,6 @@ def forward( class SanaTransformer2DModel(ModelMixin, ConfigMixin): - # TODO: Change pixart name below r""" A 2D Transformer model as introduced in Sana family of models (https://arxiv.org/abs/2310.00426, https://arxiv.org/abs/2403.04692). @@ -272,6 +271,8 @@ class SanaTransformer2DModel(ModelMixin, ConfigMixin): The width of the latent images. This parameter is fixed during training. patch_size (int, defaults to 1): Size of the patches the model processes, relevant for architectures working on non-sequential data. + activation_fn (str, optional, defaults to "gelu-approximate"): + Activation function to use in feed-forward networks within Transformer blocks. num_embeds_ada_norm (int, optional, defaults to 1000): Number of embeddings for AdaLayerNorm, fixed during training and affects the maximum denoising steps during inference. @@ -311,6 +312,7 @@ def __init__( attention_bias: bool = True, sample_size: int = 32, patch_size: int = 1, + activation_fn: tuple = None, num_embeds_ada_norm: Optional[int] = 1000, upcast_attention: bool = False, norm_type: str = "ada_norm_single", From f0aa9b9dc333e7d943f24b37dee5a34b2977e0da Mon Sep 17 00:00:00 2001 From: lawrence-cj Date: Mon, 9 Dec 2024 18:37:43 +0800 Subject: [PATCH 110/141] make style && make quality; --- scripts/convert_sana_to_diffusers.py | 3 ++- src/diffusers/__init__.py | 2 +- src/diffusers/models/transformers/sana_transformer.py | 6 +----- src/diffusers/pipelines/__init__.py | 2 +- 4 files changed, 5 insertions(+), 8 deletions(-) diff --git a/scripts/convert_sana_to_diffusers.py b/scripts/convert_sana_to_diffusers.py index 0fd8cb66e396..a60e1485ffa4 100644 --- a/scripts/convert_sana_to_diffusers.py +++ b/scripts/convert_sana_to_diffusers.py @@ -7,6 +7,7 @@ import torch from accelerate import init_empty_weights +from huggingface_hub import hf_hub_download, snapshot_download from termcolor import colored from transformers import AutoModelForCausalLM, AutoTokenizer @@ -19,7 +20,7 @@ ) from diffusers.models.modeling_utils import load_model_dict_into_meta from diffusers.utils.import_utils import is_accelerate_available -from huggingface_hub import hf_hub_download, snapshot_download + CTX = init_empty_weights if is_accelerate_available else nullcontext diff --git a/src/diffusers/__init__.py b/src/diffusers/__init__.py index 901f34499dd3..838428d94e86 100644 --- a/src/diffusers/__init__.py +++ b/src/diffusers/__init__.py @@ -806,8 +806,8 @@ PixArtSigmaPAGPipeline, PixArtSigmaPipeline, ReduxImageEncoder, - SanaPipeline, SanaPAGPipeline, + SanaPipeline, SemanticStableDiffusionPipeline, ShapEImg2ImgPipeline, ShapEPipeline, diff --git a/src/diffusers/models/transformers/sana_transformer.py b/src/diffusers/models/transformers/sana_transformer.py index 8fed200c9ef6..ec50ac602c6a 100644 --- a/src/diffusers/models/transformers/sana_transformer.py +++ b/src/diffusers/models/transformers/sana_transformer.py @@ -11,7 +11,6 @@ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. -import numbers from typing import Any, Dict, Optional, Union import torch @@ -24,10 +23,7 @@ Attention, AttentionProcessor, AttnProcessor2_0, - FusedAttnProcessor2_0, SanaLinearAttnProcessor2_0, - SanaMultiscaleAttnProcessor2_0, - SanaMultiscaleLinearAttention, ) from ..embeddings import PatchEmbed, PixArtAlphaTextProjection, SinusoidalPositionalEmbedding from ..modeling_outputs import Transformer2DModelOutput @@ -491,7 +487,7 @@ def forward( return_dict: bool = True, ): """ - The [`PixArtTransformer2DModel`] forward method. + The [`SanaTransformer2DModel`] forward method. Args: hidden_states (`torch.FloatTensor` of shape `(batch size, channel, height, width)`): diff --git a/src/diffusers/pipelines/__init__.py b/src/diffusers/pipelines/__init__.py index bbdfeed1ad15..2d191d5ca4c1 100644 --- a/src/diffusers/pipelines/__init__.py +++ b/src/diffusers/pipelines/__init__.py @@ -592,8 +592,8 @@ HunyuanDiTPAGPipeline, KolorsPAGPipeline, PixArtSigmaPAGPipeline, - StableDiffusion3PAGImg2ImgPipeline, SanaPAGPipeline, + StableDiffusion3PAGImg2ImgPipeline, StableDiffusion3PAGPipeline, StableDiffusionControlNetPAGInpaintPipeline, StableDiffusionControlNetPAGPipeline, From 7fa435faff8dd3f59e6eeb8c00120d3c7d446354 Mon Sep 17 00:00:00 2001 From: lawrence-cj Date: Mon, 9 Dec 2024 18:49:02 +0800 Subject: [PATCH 111/141] 1. remove un-unsed parameters in init; 2. code update; --- scripts/convert_sana_pag_to_diffusers.py | 31 ++++++++++++++++--- scripts/convert_sana_to_diffusers.py | 3 +- .../models/transformers/sana_transformer.py | 3 -- 3 files changed, 28 insertions(+), 9 deletions(-) diff --git a/scripts/convert_sana_pag_to_diffusers.py b/scripts/convert_sana_pag_to_diffusers.py index dad2db9315b9..21c0bd19dc2f 100644 --- a/scripts/convert_sana_pag_to_diffusers.py +++ b/scripts/convert_sana_pag_to_diffusers.py @@ -7,6 +7,7 @@ import torch from accelerate import init_empty_weights +from huggingface_hub import hf_hub_download, snapshot_download from termcolor import colored from transformers import AutoModelForCausalLM, AutoTokenizer @@ -23,12 +24,35 @@ CTX = init_empty_weights if is_accelerate_available else nullcontext -ckpt_id = "Sana" +ckpt_ids = [ + "Efficient-Large-Model/Sana_1600M_1024px_MultiLing", + "Efficient-Large-Model/Sana_1600M_512px_MultiLing", + "Efficient-Large-Model/Sana_1600M_1024px", + "Efficient-Large-Model/Sana_1600M_512px", + "Efficient-Large-Model/Sana_600M_1024px", + "Efficient-Large-Model/Sana_600M_512px", +] # https://github.com/NVlabs/Sana/blob/main/scripts/inference.py def main(args): - all_state_dict = torch.load(args.orig_ckpt_path, map_location=torch.device("cpu")) + ckpt_id = ckpt_ids[0] + cache_dir_path = os.path.expanduser("~/.cache/huggingface/hub") + if args.orig_ckpt_path is None: + snapshot_download( + repo_id=ckpt_id, + cache_dir=cache_dir_path, + repo_type="model", + ) + file_path = hf_hub_download( + repo_id=ckpt_id, + filename=f"checkpoints/{ckpt_id.split('/')[-1]}.pth", + cache_dir=cache_dir_path, + repo_type="model", + ) + else: + file_path = args.orig_ckpt_path + all_state_dict = torch.load(file_path, weights_only=True) state_dict = all_state_dict.pop("state_dict") converted_state_dict = {} @@ -143,7 +167,6 @@ def main(args): attention_bias=False, sample_size=32, patch_size=1, - activation_fn=("silu", "silu", None), upcast_attention=False, norm_type="ada_norm_single", norm_elementwise_affine=False, @@ -175,7 +198,7 @@ def main(args): print( colored( f"Only saving transformer model of {args.model_type}. " - f"Set --save_full_pipeline to save the whole SanaPipeline", + f"Set --save_full_pipeline to save the whole SanaPAGPipeline", "green", attrs=["bold"], ) diff --git a/scripts/convert_sana_to_diffusers.py b/scripts/convert_sana_to_diffusers.py index a60e1485ffa4..b413d921f00e 100644 --- a/scripts/convert_sana_to_diffusers.py +++ b/scripts/convert_sana_to_diffusers.py @@ -52,7 +52,7 @@ def main(args): ) else: file_path = args.orig_ckpt_path - all_state_dict = torch.load(file_path, map_location=torch.device("cpu")) + all_state_dict = torch.load(file_path, weights_only=True) state_dict = all_state_dict.pop("state_dict") converted_state_dict = {} @@ -167,7 +167,6 @@ def main(args): attention_bias=False, sample_size=32, patch_size=1, - activation_fn=("silu", "silu", None), upcast_attention=False, norm_type="ada_norm_single", norm_elementwise_affine=False, diff --git a/src/diffusers/models/transformers/sana_transformer.py b/src/diffusers/models/transformers/sana_transformer.py index ec50ac602c6a..b8132a7f4452 100644 --- a/src/diffusers/models/transformers/sana_transformer.py +++ b/src/diffusers/models/transformers/sana_transformer.py @@ -267,8 +267,6 @@ class SanaTransformer2DModel(ModelMixin, ConfigMixin): The width of the latent images. This parameter is fixed during training. patch_size (int, defaults to 1): Size of the patches the model processes, relevant for architectures working on non-sequential data. - activation_fn (str, optional, defaults to "gelu-approximate"): - Activation function to use in feed-forward networks within Transformer blocks. num_embeds_ada_norm (int, optional, defaults to 1000): Number of embeddings for AdaLayerNorm, fixed during training and affects the maximum denoising steps during inference. @@ -308,7 +306,6 @@ def __init__( attention_bias: bool = True, sample_size: int = 32, patch_size: int = 1, - activation_fn: tuple = None, num_embeds_ada_norm: Optional[int] = 1000, upcast_attention: bool = False, norm_type: str = "ada_norm_single", From 0f9daecb4e80118a623a4570b0950cbf2e6eadb7 Mon Sep 17 00:00:00 2001 From: Aryan Date: Wed, 11 Dec 2024 21:21:28 +0100 Subject: [PATCH 112/141] remove test file --- sana.py | 69 --------------------------------------------------------- 1 file changed, 69 deletions(-) delete mode 100644 sana.py diff --git a/sana.py b/sana.py deleted file mode 100644 index b7583207a8f2..000000000000 --- a/sana.py +++ /dev/null @@ -1,69 +0,0 @@ -import torch - -from diffusers import ( - SanaTransformer2DModel, PixArtSigmaPipeline, SanaPipeline, - FlowDPMSolverMultistepScheduler, DPMSolverMultistepScheduler -) - -from torchvision.utils import save_image - - - -def run_pixart_sigam(): - pipe = PixArtSigmaPipeline.from_pretrained( - "PixArt-alpha/PixArt-Sigma-XL-2-1024-MS", - torch_dtype=torch.float16, - use_safetensors=True - ).to(device) - - - image = pipe("a dog").images[0] - - -if __name__ == "__main__": - import argparse - - parser = argparse.ArgumentParser() - - args = parser.parse_args() - - device = "cuda" if torch.cuda.is_available() else "cpu" - dtype = torch.float16 - prompt = 'a cyberpunk cat with a neon sign that says "Sana"' - generator = torch.Generator(device=device).manual_seed(42) - - latents = torch.randn( - 1, - 32, - 32, - 32, - generator=generator, - device=device, - ).to(dtype) - # diffusers Sana Model - pipe = SanaPipeline.from_pretrained( - "/home/junsongc/junsongc/code/diffusion/Sana/output/Sana_1600M_1024px_diffusers_flowshift3_full", - torch_dtype=dtype, - use_safetensors=True, - ).to(device) - - scheduler = FlowDPMSolverMultistepScheduler(flow_shift=3.0) - # scheduler = DPMSolverMultistepScheduler(use_flow_sigmas=True, prediction_type='flow_prediction', flow_shift=3.0) - pipe.scheduler = scheduler - - pipe.text_encoder.to(torch.bfloat16) - pipe.vae.to(torch.float32) - image = pipe( - prompt=prompt, - height=1024, - width=1024, - guidance_scale=5.0, - num_inference_steps=20, - generator=generator, - latents=latents, - )[0] - image[0].save('sana_diffusers_flowdpmsolver4.png') - - - # run pixart - # run_pixart_sigam() From f6985241f7e5143403e98db0b2a77b8a724471a4 Mon Sep 17 00:00:00 2001 From: Aryan Date: Wed, 11 Dec 2024 23:39:20 +0100 Subject: [PATCH 113/141] refactor; add docs; add tests; update conversion script --- docs/source/en/_toctree.yml | 4 + .../en/api/models/sana_transformer2d.md | 32 ++ docs/source/en/api/pipelines/sana.md | 39 ++ scripts/convert_sana_to_diffusers.py | 56 +-- src/diffusers/models/attention_processor.py | 46 +- src/diffusers/models/normalization.py | 39 -- .../models/transformers/sana_transformer.py | 436 +++++------------- .../pipelines/sana/pipeline_output.py | 21 + src/diffusers/pipelines/sana/pipeline_sana.py | 89 ++-- .../test_models_transformer_sana.py | 82 ++++ tests/pipelines/sana/__init__.py | 0 tests/pipelines/sana/test_sana.py | 261 +++++++++++ 12 files changed, 629 insertions(+), 476 deletions(-) create mode 100644 docs/source/en/api/models/sana_transformer2d.md create mode 100644 docs/source/en/api/pipelines/sana.md create mode 100644 src/diffusers/pipelines/sana/pipeline_output.py create mode 100644 tests/models/transformers/test_models_transformer_sana.py create mode 100644 tests/pipelines/sana/__init__.py create mode 100644 tests/pipelines/sana/test_sana.py diff --git a/docs/source/en/_toctree.yml b/docs/source/en/_toctree.yml index 06e05e0206f1..470084af5eed 100644 --- a/docs/source/en/_toctree.yml +++ b/docs/source/en/_toctree.yml @@ -282,6 +282,8 @@ title: PriorTransformer - local: api/models/sd3_transformer2d title: SD3Transformer2DModel + - local: api/models/sana_transformer2d + title: SanaTransformer2DModel - local: api/models/stable_audio_transformer title: StableAudioDiTModel - local: api/models/transformer2d @@ -428,6 +430,8 @@ title: PixArt-α - local: api/pipelines/pixart_sigma title: PixArt-Σ + - local: api/pipelines/sana + title: Sana - local: api/pipelines/self_attention_guidance title: Self-Attention Guidance - local: api/pipelines/semantic_stable_diffusion diff --git a/docs/source/en/api/models/sana_transformer2d.md b/docs/source/en/api/models/sana_transformer2d.md new file mode 100644 index 000000000000..b0550dd6b7d4 --- /dev/null +++ b/docs/source/en/api/models/sana_transformer2d.md @@ -0,0 +1,32 @@ + + +# SanaTransformer2DModel + +A Diffusion Transformer model for 2D data from [SANA: Efficient High-Resolution Image Synthesis with Linear Diffusion Transformers](https://huggingface.co/papers/2410.10629) was introduced from NVIDIA and MIT HAN Lab, by Enze Xie, Junsong Chen, Junyu Chen, Han Cai, Haotian Tang, Yujun Lin, Zhekai Zhang, Muyang Li, Ligeng Zhu, Yao Lu, Song Han. + +The abstract from the paper is: + +*We introduce Sana, a text-to-image framework that can efficiently generate images up to 4096×4096 resolution. Sana can synthesize high-resolution, high-quality images with strong text-image alignment at a remarkably fast speed, deployable on laptop GPU. Core designs include: (1) Deep compression autoencoder: unlike traditional AEs, which compress images only 8×, we trained an AE that can compress images 32×, effectively reducing the number of latent tokens. (2) Linear DiT: we replace all vanilla attention in DiT with linear attention, which is more efficient at high resolutions without sacrificing quality. (3) Decoder-only text encoder: we replaced T5 with modern decoder-only small LLM as the text encoder and designed complex human instruction with in-context learning to enhance the image-text alignment. (4) Efficient training and sampling: we propose Flow-DPM-Solver to reduce sampling steps, with efficient caption labeling and selection to accelerate convergence. As a result, Sana-0.6B is very competitive with modern giant diffusion model (e.g. Flux-12B), being 20 times smaller and 100+ times faster in measured throughput. Moreover, Sana-0.6B can be deployed on a 16GB laptop GPU, taking less than 1 second to generate a 1024×1024 resolution image. Sana enables content creation at low cost. Code and model will be publicly released.* + +The model can be loaded with the following code snippet. + +```python +TODO(aryan) +``` + +## SanaTransformer2DModel + +[[autodoc]] SanaPlusTransformer2DModel + +## Transformer2DModelOutput + +[[autodoc]] models.modeling_outputs.Transformer2DModelOutput diff --git a/docs/source/en/api/pipelines/sana.md b/docs/source/en/api/pipelines/sana.md new file mode 100644 index 000000000000..153696f04c17 --- /dev/null +++ b/docs/source/en/api/pipelines/sana.md @@ -0,0 +1,39 @@ + + +# SanaPipeline + +[SANA: Efficient High-Resolution Image Synthesis with Linear Diffusion Transformers](https://huggingface.co/papers/2410.10629) from NVIDIA and MIT HAN Lab, by Enze Xie, Junsong Chen, Junyu Chen, Han Cai, Haotian Tang, Yujun Lin, Zhekai Zhang, Muyang Li, Ligeng Zhu, Yao Lu, Song Han. + +The abstract from the paper is: + +*We introduce Sana, a text-to-image framework that can efficiently generate images up to 4096×4096 resolution. Sana can synthesize high-resolution, high-quality images with strong text-image alignment at a remarkably fast speed, deployable on laptop GPU. Core designs include: (1) Deep compression autoencoder: unlike traditional AEs, which compress images only 8×, we trained an AE that can compress images 32×, effectively reducing the number of latent tokens. (2) Linear DiT: we replace all vanilla attention in DiT with linear attention, which is more efficient at high resolutions without sacrificing quality. (3) Decoder-only text encoder: we replaced T5 with modern decoder-only small LLM as the text encoder and designed complex human instruction with in-context learning to enhance the image-text alignment. (4) Efficient training and sampling: we propose Flow-DPM-Solver to reduce sampling steps, with efficient caption labeling and selection to accelerate convergence. As a result, Sana-0.6B is very competitive with modern giant diffusion model (e.g. Flux-12B), being 20 times smaller and 100+ times faster in measured throughput. Moreover, Sana-0.6B can be deployed on a 16GB laptop GPU, taking less than 1 second to generate a 1024×1024 resolution image. Sana enables content creation at low cost. Code and model will be publicly released.* + + + +Make sure to check out the Schedulers [guide](../../using-diffusers/schedulers.md) to learn how to explore the tradeoff between scheduler speed and quality, and see the [reuse components across pipelines](../../using-diffusers/loading.md#reuse-a-pipeline) section to learn how to efficiently load the same components into multiple pipelines. + + + +This pipeline was contributed by [lawrence-cj](https://github.com/lawrence-cj). The original codebase can be found [here](https://github.com/NVlabs/Sana). The original weights can be found under [hf.co/Efficient-Large-Model]https://huggingface.co/Efficient-Large-Model). + +## SanaPipeline + +[[autodoc]] SanaPipeline + - all + - __call__ + +## SanaPipelineOutput + +[[autodoc]] pipelines.sana.pipeline_output.SanaPipelineOutput diff --git a/scripts/convert_sana_to_diffusers.py b/scripts/convert_sana_to_diffusers.py index b413d921f00e..d66eb9258fad 100644 --- a/scripts/convert_sana_to_diffusers.py +++ b/scripts/convert_sana_to_diffusers.py @@ -38,6 +38,7 @@ def main(args): ckpt_id = ckpt_ids[0] cache_dir_path = os.path.expanduser("~/.cache/huggingface/hub") + if args.orig_ckpt_path is None: snapshot_download( repo_id=ckpt_id, @@ -52,6 +53,7 @@ def main(args): ) else: file_path = args.orig_ckpt_path + all_state_dict = torch.load(file_path, weights_only=True) state_dict = all_state_dict.pop("state_dict") converted_state_dict = {} @@ -96,8 +98,8 @@ def main(args): converted_state_dict[f"transformer_blocks.{depth}.scale_shift_table"] = state_dict.pop( f"blocks.{depth}.scale_shift_table" ) + # Linear Attention is all you need 🤘 - # Self attention. q, k, v = torch.chunk(state_dict.pop(f"blocks.{depth}.attn.qkv.weight"), 3, dim=0) converted_state_dict[f"transformer_blocks.{depth}.attn1.to_q.weight"] = q @@ -156,27 +158,20 @@ def main(args): # Transformer with CTX(): transformer = SanaTransformer2DModel( + in_channels=32, + out_channels=32, num_attention_heads=model_kwargs[args.model_type]["num_attention_heads"], attention_head_dim=model_kwargs[args.model_type]["attention_head_dim"], + num_layers=model_kwargs[args.model_type]["num_layers"], num_cross_attention_heads=model_kwargs[args.model_type]["num_cross_attention_heads"], cross_attention_head_dim=model_kwargs[args.model_type]["cross_attention_head_dim"], - in_channels=32, - out_channels=32, - num_layers=model_kwargs[args.model_type]["num_layers"], cross_attention_dim=model_kwargs[args.model_type]["cross_attention_dim"], attention_bias=False, sample_size=32, patch_size=1, - upcast_attention=False, - norm_type="ada_norm_single", norm_elementwise_affine=False, norm_eps=1e-6, - use_additional_conditions=False, caption_channels=2304, - use_caption_norm=True, - caption_norm_scale_factor=0.1, - attention_type="default", - use_pe=False, expand_ratio=2.5, ) if is_accelerate_available(): @@ -203,24 +198,17 @@ def main(args): attrs=["bold"], ) ) - transformer.to(weight_dtype).save_pretrained(os.path.join(args.dump_path, "transformer")) + transformer.save_pretrained(os.path.join(args.dump_path, "transformer"), safe_serialization=True, max_shard_size="5GB", variant=variant) else: print(colored(f"Saving the whole SanaPipeline containing {args.model_type}", "green", attrs=["bold"])) # VAE - ae = AutoencoderDC.from_pretrained( - "mit-han-lab/dc-ae-f32c32-sana-1.0-diffusers", - torch_dtype=torch.bfloat16, - ).to(device) + ae = AutoencoderDC.from_pretrained("mit-han-lab/dc-ae-f32c32-sana-1.0-diffusers",) # Text Encoder text_encoder_model_path = "google/gemma-2-2b-it" tokenizer = AutoTokenizer.from_pretrained(text_encoder_model_path) tokenizer.padding_side = "right" - text_encoder = ( - AutoModelForCausalLM.from_pretrained(text_encoder_model_path, torch_dtype=torch.bfloat16) - .get_decoder() - .to(device) - ) + text_encoder = AutoModelForCausalLM.from_pretrained(text_encoder_model_path).get_decoder() # Scheduler if args.scheduler_type == "flow-dpm_solver": @@ -234,9 +222,6 @@ def main(args): else: raise ValueError(f"Scheduler type {args.scheduler_type} is not supported") - # transformer - transformer.to(device).to(weight_dtype) - pipe = SanaPipeline( tokenizer=tokenizer, text_encoder=text_encoder, @@ -244,17 +229,20 @@ def main(args): vae=ae, scheduler=scheduler, ) + pipe.save_pretrained(args.dump_path, safe_serialization=True, max_shard_size="5GB", variant=variant) - image = pipe( - "a dog", - height=1024, - width=1024, - guidance_scale=5.0, - )[0] - image[0].save("sana.png") +DTYPE_MAPPING = { + "fp32": torch.float32, + "fp16": torch.float16, + "bf16": torch.bfloat16, +} - pipe.save_pretrained(args.dump_path) +VARIANT_MAPPING = { + "fp32": None, + "fp16": "fp16", + "bf16": "bf16", +} if __name__ == "__main__": @@ -279,6 +267,7 @@ def main(args): ) parser.add_argument("--dump_path", default=None, type=str, required=True, help="Path to the output pipeline.") parser.add_argument("--save_full_pipeline", action="store_true", help="save all the pipelien elemets in one.") + parser.add_argument("--dtype", default="fp32", type=str, choices=["fp32", "fp16", "bf16"], help="Weight dtype.") args = parser.parse_args() @@ -302,6 +291,7 @@ def main(args): } device = "cuda" if torch.cuda.is_available() else "cpu" - weight_dtype = torch.float16 + weight_dtype = DTYPE_MAPPING[args.dtype] + variant = VARIANT_MAPPING[args.dtype] main(args) diff --git a/src/diffusers/models/attention_processor.py b/src/diffusers/models/attention_processor.py index 824330dbe529..2dea9eb8c669 100644 --- a/src/diffusers/models/attention_processor.py +++ b/src/diffusers/models/attention_processor.py @@ -5358,77 +5358,47 @@ def __call__( hidden_states: torch.Tensor, encoder_hidden_states: Optional[torch.Tensor] = None, attention_mask: Optional[torch.Tensor] = None, - temb: Optional[torch.Tensor] = None, - *args, - **kwargs, ) -> torch.Tensor: - if len(args) > 0 or kwargs.get("scale", None) is not None: - deprecation_message = "The `scale` argument is deprecated and will be ignored. Please remove it, as passing it will raise an error in the future. `scale` should directly be passed while calling the underlying pipeline component i.e., via `cross_attention_kwargs`." - deprecate("scale", "1.0.0", deprecation_message) - - residual = hidden_states - if attn.spatial_norm is not None: - hidden_states = attn.spatial_norm(hidden_states, temb) - input_ndim = hidden_states.ndim + original_dtype = hidden_states.dtype - if input_ndim == 4: - batch_size, channel, height, width = hidden_states.shape - hidden_states = hidden_states.view(batch_size, channel, height * width).transpose(1, 2) - - batch_size, sequence_length, _ = ( + batch_size, _, _ = ( hidden_states.shape if encoder_hidden_states is None else encoder_hidden_states.shape ) - query = attn.to_q(hidden_states) - if encoder_hidden_states is None: encoder_hidden_states = hidden_states - elif attn.norm_cross: - encoder_hidden_states = attn.norm_encoder_hidden_states(encoder_hidden_states) + query = attn.to_q(hidden_states) key = attn.to_k(encoder_hidden_states) value = attn.to_v(encoder_hidden_states) inner_dim = key.shape[-1] head_dim = inner_dim // attn.heads - dtype = query.dtype - query = query.transpose(-1, -2).reshape(batch_size, attn.heads, head_dim, -1) key = key.transpose(-1, -2).reshape(batch_size, attn.heads, head_dim, -1).transpose(-1, -2) value = value.transpose(-1, -2).reshape(batch_size, attn.heads, head_dim, -1) - query = self.kernel_func(query) # B, h, h_d, N + query = self.kernel_func(query) key = self.kernel_func(key) - # need torch.float query, key, value = query.float(), key.float(), value.float() value = F.pad(value, (0, 0, 0, 1), mode="constant", value=self.pad_val) - vk = torch.matmul(value, key) - hidden_states = torch.matmul(vk, query) + scores = torch.matmul(value, key) + hidden_states = torch.matmul(scores, query) if hidden_states.dtype in [torch.float16, torch.bfloat16]: hidden_states = hidden_states.float() + hidden_states = hidden_states[:, :, :-1] / (hidden_states[:, :, -1:] + self.eps) - hidden_states = hidden_states.view(batch_size, attn.heads * head_dim, -1).permute(0, 2, 1) - hidden_states = hidden_states.to(dtype) + hidden_states = hidden_states.to(original_dtype) - # linear proj hidden_states = attn.to_out[0](hidden_states) - # dropout hidden_states = attn.to_out[1](hidden_states) - if input_ndim == 4: - hidden_states = hidden_states.transpose(-1, -2).reshape(batch_size, channel, height, width) - - if attn.residual_connection: - hidden_states = hidden_states + residual - - hidden_states = hidden_states / attn.rescale_output_factor - if hidden_states.dtype == torch.float16: hidden_states = hidden_states.clip(-65504, 65504) diff --git a/src/diffusers/models/normalization.py b/src/diffusers/models/normalization.py index 1f70b0580c2b..264de4d18d03 100644 --- a/src/diffusers/models/normalization.py +++ b/src/diffusers/models/normalization.py @@ -590,42 +590,3 @@ def get_normalization( else: raise ValueError(f"{norm_type=} is not supported.") return norm - - -class RMSNormScaled(nn.Module): - def __init__(self, dim, eps: float, elementwise_affine: bool = True, scale_factor: float = 1.0, bias: bool = False): - super().__init__() - self.weight = nn.Parameter(torch.ones(dim) * scale_factor) - - self.eps = eps - self.elementwise_affine = elementwise_affine - - if isinstance(dim, numbers.Integral): - dim = (dim,) - - self.dim = torch.Size(dim) - - self.weight = None - self.bias = None - - if elementwise_affine: - self.weight = nn.Parameter(torch.ones(dim) * scale_factor) - if bias: - self.bias = nn.Parameter(torch.zeros(dim)) - - def forward(self, hidden_states): - input_dtype = hidden_states.dtype - variance = hidden_states.to(torch.float32).pow(2).mean(-1, keepdim=True) - hidden_states = hidden_states * torch.rsqrt(variance + self.eps) - - if self.weight is not None: - # convert into half-precision if necessary - if self.weight.dtype in [torch.float16, torch.bfloat16]: - hidden_states = hidden_states.to(self.weight.dtype) - hidden_states = hidden_states * self.weight - if self.bias is not None: - hidden_states = hidden_states + self.bias - else: - hidden_states = hidden_states.to(input_dtype) - - return hidden_states diff --git a/src/diffusers/models/transformers/sana_transformer.py b/src/diffusers/models/transformers/sana_transformer.py index b8132a7f4452..5bc4c3fb7d4a 100644 --- a/src/diffusers/models/transformers/sana_transformer.py +++ b/src/diffusers/models/transformers/sana_transformer.py @@ -11,6 +11,8 @@ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. + +from functools import partial from typing import Any, Dict, Optional, Union import torch @@ -23,12 +25,13 @@ Attention, AttentionProcessor, AttnProcessor2_0, + SanaMultiscaleLinearAttention, SanaLinearAttnProcessor2_0, ) -from ..embeddings import PatchEmbed, PixArtAlphaTextProjection, SinusoidalPositionalEmbedding +from ..embeddings import PatchEmbed, PixArtAlphaTextProjection from ..modeling_outputs import Transformer2DModelOutput from ..modeling_utils import ModelMixin -from ..normalization import AdaLayerNormSingle, RMSNormScaled +from ..normalization import AdaLayerNormSingle, RMSNorm logger = logging.get_logger(__name__) # pylint: disable=invalid-name @@ -37,10 +40,10 @@ # Modified from diffusers.models.autoencoders.autoencoder_dc.GLUMBConv @maybe_allow_in_graph class SanaGLUMBConv(nn.Module): - def __init__(self, in_channels: int, out_channels: int, expand_ratio: float = 2.5) -> None: + def __init__(self, in_channels: int, out_channels: int, mlp_ratio: float = 2.5) -> None: super().__init__() - hidden_channels = int(expand_ratio * in_channels) + hidden_channels = int(mlp_ratio * in_channels) self.nonlinearity = nn.SiLU() @@ -70,9 +73,7 @@ def forward(self, hidden_states: torch.Tensor, HW: Optional[tuple[int]] = None) return hidden_states -# Modified from diffusers.models.attention.BasicTransformerBlock -@maybe_allow_in_graph -class SanaLinearTransformerBlock(nn.Module): +class SanaTransformerBlock(nn.Module): r""" A Transformer block following the Linear Transformer architecture, introduced in Sana @@ -93,38 +94,16 @@ def __init__( num_cross_attention_heads: Optional[int] = 20, cross_attention_head_dim: Optional[int] = 112, cross_attention_dim: Optional[int] = 2240, - num_embeds_ada_norm: Optional[int] = 1000, attention_bias: bool = True, - upcast_attention: bool = False, - norm_type: str = "ada_norm_single", norm_elementwise_affine: bool = False, norm_eps: float = 1e-6, attention_out_bias: bool = True, - use_pe: bool = False, - num_positional_embeddings: Optional[int] = None, - expand_ratio: float = 2.5, - ): + mlp_ratio: float = 2.5, + ) -> None: super().__init__() - self.dim = dim - self.num_attention_heads = num_attention_heads - self.attention_head_dim = attention_head_dim - self.dropout = dropout - self.cross_attention_dim = cross_attention_dim - self.attention_bias = attention_bias - self.norm_elementwise_affine = norm_elementwise_affine - - self.use_ada_layer_norm_single = norm_type == "ada_norm_single" - self.norm_type = norm_type - self.num_embeds_ada_norm = num_embeds_ada_norm - - self.use_pe = use_pe - if use_pe: - self.pos_embed = SinusoidalPositionalEmbedding(dim, max_seq_length=num_positional_embeddings) - else: - self.pos_embed = None + # 1. Self Attention self.norm1 = nn.LayerNorm(dim, elementwise_affine=False, eps=norm_eps) - self.attn1 = Attention( query_dim=dim, heads=num_attention_heads, @@ -132,14 +111,12 @@ def __init__( dropout=dropout, bias=attention_bias, cross_attention_dim=None, - upcast_attention=upcast_attention, processor=SanaLinearAttnProcessor2_0(), ) - # 2. Cross-Attn + # 2. Cross Attention if cross_attention_dim is not None: self.norm2 = nn.LayerNorm(dim, elementwise_affine=norm_elementwise_affine, eps=norm_eps) - self.attn2 = Attention( query_dim=dim, cross_attention_dim=cross_attention_dim, @@ -147,29 +124,19 @@ def __init__( dim_head=cross_attention_head_dim, dropout=dropout, bias=True, - upcast_attention=upcast_attention, out_bias=attention_out_bias, processor=AttnProcessor2_0(), ) + # 3. Feed-forward self.ff = SanaGLUMBConv( in_channels=dim, out_channels=dim, - expand_ratio=expand_ratio, + mlp_ratio=mlp_ratio, ) - # 5. Scale-shift for Sana. self.scale_shift_table = nn.Parameter(torch.randn(6, dim) / dim ** 0.5) - # let chunk size default to None - self._chunk_size = None - self._chunk_dim = 0 - - def set_chunk_feed_forward(self, chunk_size: Optional[int], dim: int = 0): - # Sets chunk feed-forward - self._chunk_size = chunk_size - self._chunk_dim = dim - def forward( self, hidden_states: torch.Tensor, @@ -177,236 +144,154 @@ def forward( encoder_hidden_states: Optional[torch.Tensor] = None, encoder_attention_mask: Optional[torch.Tensor] = None, timestep: Optional[torch.LongTensor] = None, - cross_attention_kwargs: Dict[str, Any] = None, HW: Optional[tuple[int]] = None, ) -> torch.Tensor: - if cross_attention_kwargs is not None: - if cross_attention_kwargs.get("scale", None) is not None: - logger.warning("Passing `scale` to `cross_attention_kwargs` is deprecated. `scale` will be ignored.") - - # Notice that normalization is always applied before the real computation in the following blocks. - # 0. Self-Attention batch_size = hidden_states.shape[0] + # 1. Modulation shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = ( self.scale_shift_table[None] + timestep.reshape(batch_size, 6, -1) ).chunk(6, dim=1) + + # 2. Self Attention norm_hidden_states = self.norm1(hidden_states) norm_hidden_states = norm_hidden_states * (1 + scale_msa) + shift_msa - if self.pos_embed is not None: - norm_hidden_states = self.pos_embed(norm_hidden_states) - - cross_attention_kwargs = cross_attention_kwargs.copy() if cross_attention_kwargs is not None else {} - - attn_output = self.attn1( - norm_hidden_states, - encoder_hidden_states=None, - attention_mask=attention_mask, - **cross_attention_kwargs, - ) - attn_output = gate_msa * attn_output + attn_output = self.attn1(norm_hidden_states) + hidden_states = hidden_states + gate_msa * attn_output - hidden_states = attn_output + hidden_states - if hidden_states.ndim == 4: - hidden_states = hidden_states.squeeze(1) - - # 3. Cross-Attention + # 3. Cross Attention if self.attn2 is not None: - norm_hidden_states = hidden_states - - if self.pos_embed is not None: - norm_hidden_states = self.pos_embed(norm_hidden_states) - attn_output = self.attn2( - norm_hidden_states, + hidden_states, encoder_hidden_states=encoder_hidden_states, attention_mask=encoder_attention_mask, - **cross_attention_kwargs, ) hidden_states = attn_output + hidden_states # 4. Feed-forward - if self.norm_type == "ada_norm_single": - norm_hidden_states = self.norm2(hidden_states) - norm_hidden_states = norm_hidden_states * (1 + scale_mlp) + shift_mlp + norm_hidden_states = self.norm2(hidden_states) + norm_hidden_states = norm_hidden_states * (1 + scale_mlp) + shift_mlp ff_output = self.ff(norm_hidden_states, HW=HW) - - if self.norm_type == "ada_norm_single": - ff_output = gate_mlp * ff_output - - hidden_states = ff_output + hidden_states - if hidden_states.ndim == 4: - hidden_states = hidden_states.squeeze(1) + hidden_states = hidden_states + gate_mlp * ff_output return hidden_states class SanaTransformer2DModel(ModelMixin, ConfigMixin): r""" - A 2D Transformer model as introduced in Sana family of models (https://arxiv.org/abs/2310.00426, - https://arxiv.org/abs/2403.04692). - - Parameters: - num_attention_heads (int, optional, defaults to 32): The number of heads to use for multi-head attention. - attention_head_dim (int, optional, defaults to 36): The number of channels in each head. - in_channels (int, defaults to 32): The number of channels in the input. - out_channels (int, optional): - The number of channels in the output. Specify this parameter if the output channel number differs from the - input. - num_layers (int, optional, defaults to 28): The number of layers of Transformer blocks to use. - dropout (float, optional, defaults to 0.0): The dropout probability to use within the Transformer blocks. - norm_num_groups (int, optional, defaults to 32): - Number of groups for group normalization within Transformer blocks. - cross_attention_dim (int, optional): - The dimensionality for cross-attention layers, typically matching the encoder's hidden dimension. - attention_bias (bool, optional, defaults to True): - Configure if the Transformer blocks' attention should contain a bias parameter. - sample_size (int, defaults to 32): - The width of the latent images. This parameter is fixed during training. - patch_size (int, defaults to 1): - Size of the patches the model processes, relevant for architectures working on non-sequential data. - num_embeds_ada_norm (int, optional, defaults to 1000): - Number of embeddings for AdaLayerNorm, fixed during training and affects the maximum denoising steps during - inference. - upcast_attention (bool, optional, defaults to False): - If true, upcasts the attention mechanism dimensions for potentially improved performance. - norm_type (str, optional, defaults to "ada_norm_zero"): - Specifies the type of normalization used, can be 'ada_norm_zero'. - norm_elementwise_affine (bool, optional, defaults to False): - If true, enables element-wise affine parameters in the normalization layers. - norm_eps (float, optional, defaults to 1e-6): - A small constant added to the denominator in normalization layers to prevent division by zero. - interpolation_scale (int, optional): Scale factor to use during interpolating the position embeddings. - use_additional_conditions (bool, optional): If we're using additional conditions as inputs. - attention_type (str, optional, defaults to "default"): Kind of attention mechanism to be used. - caption_channels (int, optional, defaults to None): - Number of channels to use for projecting the caption embeddings. - num_vector_embeds (bool, optional, defaults to False): - Deprecated argument. Will be removed in a future version. + A 2D Transformer model as introduced in [Sana](https://arxiv.org/abs/2410.10629) family of models. + + Args: + in_channels (`int`, defaults to `32`): + The number of channels in the input. + out_channels (`int`, *optional*, defaults to `32`): + The number of channels in the output. + num_attention_heads (`int`, defaults to `70`): + The number of heads to use for multi-head attention. + attention_head_dim (`int`, defaults to `32`): + The number of channels in each head. + num_layers (`int`, defaults to `20`): + The number of layers of Transformer blocks to use. + num_cross_attention_heads (`int`, *optional*, defaults to `20`): + The number of heads to use for cross-attention. + cross_attention_head_dim (`int`, *optional*, defaults to `112`): + The number of channels in each head for cross-attention. + cross_attention_dim (`int`, *optional*, defaults to `2240`): + The number of channels in the cross-attention output. + caption_channels (`int`, defaults to `2304`): + The number of channels in the caption embeddings. + mlp_ratio (`float`, defaults to `2.5`): + The expansion ratio to use in the GLUMBConv layer. + dropout (`float`, defaults to `0.0`): + The dropout probability. + attention_bias (`bool`, defaults to `True`): + Whether to use bias in the attention layer. + sample_size (`int`, defaults to `32`): + The base size of the input latent. + patch_size (`int`, defaults to `1`): + The size of the patches to use in the patch embedding layer. + norm_elementwise_affine (`bool`, defaults to `False`): + Whether to use elementwise affinity in the normalization layer. + norm_eps (`float`, defaults to `1e-6`): + The epsilon value for the normalization layer. """ _supports_gradient_checkpointing = True - _no_split_modules = ["BasicTransformerBlock", "PatchEmbed"] + _no_split_modules = ["SanaTransformerBlock", "PatchEmbed"] @register_to_config def __init__( self, - num_attention_heads: int = 32, - attention_head_dim: int = 36, in_channels: int = 32, out_channels: Optional[int] = 32, - num_layers: int = 28, - dropout: float = 0.0, - norm_num_groups: int = 32, + num_attention_heads: int = 70, + attention_head_dim: int = 32, + num_layers: int = 20, num_cross_attention_heads: Optional[int] = 20, cross_attention_head_dim: Optional[int] = 112, cross_attention_dim: Optional[int] = 2240, + caption_channels: int = 2304, + mlp_ratio: float = 2.5, + dropout: float = 0.0, attention_bias: bool = True, sample_size: int = 32, patch_size: int = 1, - num_embeds_ada_norm: Optional[int] = 1000, - upcast_attention: bool = False, - norm_type: str = "ada_norm_single", norm_elementwise_affine: bool = False, norm_eps: float = 1e-6, - interpolation_scale: Optional[int] = None, - use_additional_conditions: Optional[bool] = None, - caption_channels: Optional[int] = None, - use_caption_norm: Optional[bool] = True, - caption_norm_scale_factor: Optional[float] = 0.1, - attention_type: Optional[str] = "default", - use_pe: Optional[bool] = False, - expand_ratio=2.5, - ): + ) -> None: super().__init__() - # Validate inputs. - if norm_type != "ada_norm_single": - raise NotImplementedError( - f"Forward pass is not implemented when `patch_size` is not None and `norm_type` is '{norm_type}'." - ) - elif norm_type == "ada_norm_single" and num_embeds_ada_norm is None: - raise ValueError( - f"When using a `patch_size` and this `norm_type` ({norm_type}), `num_embeds_ada_norm` cannot be None." - ) - - # Set some common variables used across the board. - self.attention_head_dim = attention_head_dim - self.inner_dim = num_attention_heads * attention_head_dim - self.out_channels = in_channels if out_channels is None else out_channels - if use_additional_conditions is None: - if sample_size == 128: - use_additional_conditions = True - else: - use_additional_conditions = False - self.use_additional_conditions = use_additional_conditions - - self.gradient_checkpointing = False - - # 2. Initialize the position embedding and transformer blocks. - self.height = sample_size - self.width = sample_size - - if use_pe: - interpolation_scale = ( - interpolation_scale - if interpolation_scale is not None - else max(sample_size // 64, 1) - ) - else: - interpolation_scale = None + out_channels = out_channels or in_channels + inner_dim = num_attention_heads * attention_head_dim + # 1. Patch Embedding self.pos_embed = PatchEmbed( height=sample_size, width=sample_size, patch_size=patch_size, in_channels=in_channels, - embed_dim=self.inner_dim, - interpolation_scale=interpolation_scale, - pos_embed_type="sincos" if use_pe else None + embed_dim=inner_dim, + interpolation_scale=None, + pos_embed_type=None, + ) + + # 2. Caption Embedding + self.caption_projection = PixArtAlphaTextProjection( + in_features=caption_channels, hidden_size=inner_dim ) + self.caption_norm = RMSNorm(inner_dim, eps=1e-5) + # 3. Transformer blocks self.transformer_blocks = nn.ModuleList( [ - SanaLinearTransformerBlock( - self.inner_dim, + SanaTransformerBlock( + inner_dim, num_attention_heads, attention_head_dim, dropout=dropout, num_cross_attention_heads=num_cross_attention_heads, cross_attention_head_dim=cross_attention_head_dim, cross_attention_dim=cross_attention_dim, - num_embeds_ada_norm=num_embeds_ada_norm, attention_bias=attention_bias, - upcast_attention=upcast_attention, - norm_type=norm_type, norm_elementwise_affine=norm_elementwise_affine, norm_eps=norm_eps, - use_pe=use_pe, - expand_ratio=expand_ratio, + mlp_ratio=mlp_ratio, ) for _ in range(num_layers) ] ) - # 3. Output blocks. - self.norm_out = nn.LayerNorm(self.inner_dim, elementwise_affine=False, eps=1e-6) - self.scale_shift_table = nn.Parameter(torch.randn(2, self.inner_dim) / self.inner_dim**0.5) - self.proj_out = nn.Linear(self.inner_dim, patch_size * patch_size * self.out_channels) + # 4. Output blocks + self.scale_shift_table = nn.Parameter(torch.randn(2, inner_dim) / inner_dim**0.5) + + self.norm_out = nn.LayerNorm(inner_dim, elementwise_affine=False, eps=1e-6) + self.proj_out = nn.Linear(inner_dim, patch_size * patch_size * out_channels) - self.adaln_single = AdaLayerNormSingle( - self.inner_dim, use_additional_conditions=self.use_additional_conditions - ) - self.caption_projection = None - if caption_channels is not None: - self.caption_projection = PixArtAlphaTextProjection( - in_features=caption_channels, hidden_size=self.inner_dim - ) - self.caption_norm = None - if use_caption_norm: - self.caption_norm = RMSNormScaled(self.inner_dim, eps=1e-5, scale_factor=caption_norm_scale_factor) + self.adaln_single = AdaLayerNormSingle(inner_dim) + + self.gradient_checkpointing = False def _set_gradient_checkpointing(self, module, value=False): if hasattr(module, "gradient_checkpointing"): @@ -475,53 +360,12 @@ def fn_recursive_attn_processor(name: str, module: torch.nn.Module, processor): def forward( self, hidden_states: torch.Tensor, - timestep: Optional[torch.LongTensor] = None, - encoder_hidden_states: Optional[torch.Tensor] = None, + encoder_hidden_states: torch.Tensor, + timestep: torch.LongTensor, encoder_attention_mask: Optional[torch.Tensor] = None, - added_cond_kwargs: Dict[str, torch.Tensor] = None, - cross_attention_kwargs: Dict[str, Any] = None, attention_mask: Optional[torch.Tensor] = None, return_dict: bool = True, ): - """ - The [`SanaTransformer2DModel`] forward method. - - Args: - hidden_states (`torch.FloatTensor` of shape `(batch size, channel, height, width)`): - Input `hidden_states`. - encoder_hidden_states (`torch.FloatTensor` of shape `(batch size, sequence len, embed dims)`, *optional*): - Conditional embeddings for cross attention layer. If not given, cross-attention defaults to - self-attention. - timestep (`torch.LongTensor`, *optional*): - Used to indicate denoising step. Optional timestep to be applied as an embedding in `AdaLayerNorm`. - added_cond_kwargs: (`Dict[str, Any]`, *optional*): Additional conditions to be used as inputs. - cross_attention_kwargs ( `Dict[str, Any]`, *optional*): - A kwargs dictionary that if specified is passed along to the `AttentionProcessor` as defined under - `self.processor` in - [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). - attention_mask ( `torch.Tensor`, *optional*): - An attention mask of shape `(batch, key_tokens)` is applied to `encoder_hidden_states`. If `1` the mask - is kept, otherwise if `0` it is discarded. Mask will be converted into a bias, which adds large - negative values to the attention scores corresponding to "discard" tokens. - encoder_attention_mask ( `torch.Tensor`, *optional*): - Cross-attention mask applied to `encoder_hidden_states`. Two formats supported: - - * Mask `(batch, sequence_length)` True = keep, False = discard. - * Bias `(batch, 1, sequence_length)` 0 = keep, -10000 = discard. - - If `ndim == 2`: will be interpreted as a mask, then converted into a bias consistent with the format - above. This bias will be added to the cross-attention scores. - return_dict (`bool`, *optional*, defaults to `True`): - Whether or not to return a [`~models.unets.unet_2d_condition.UNet2DConditionOutput`] instead of a plain - tuple. - - Returns: - If `return_dict` is True, an [`~models.transformer_2d.Transformer2DModelOutput`] is returned, otherwise a - `tuple` where the first element is the sample tensor. - """ - if self.use_additional_conditions and added_cond_kwargs is None: - raise ValueError("`added_cond_kwargs` cannot be None when using additional conditions for `adaln_single`.") - # ensure attention_mask is a bias, and give it a singleton query_tokens dimension. # we may have done this conversion already, e.g. if we came here via UNet2DConditionModel#forward. # we can tell by counting dims; if ndim == 2: it's a mask rather than a bias. @@ -546,82 +390,58 @@ def forward( encoder_attention_mask = encoder_attention_mask.unsqueeze(1) # 1. Input - batch_size = hidden_states.shape[0] - height, width = ( - hidden_states.shape[-2] // self.config.patch_size, - hidden_states.shape[-1] // self.config.patch_size, - ) + batch_size, num_channels, height, width = hidden_states.shape + post_patch_height = height // self.config.patch_size + post_patch_width = width // self.config.patch_size hidden_states = self.pos_embed(hidden_states) timestep, embedded_timestep = self.adaln_single( - timestep, added_cond_kwargs, batch_size=batch_size, hidden_dtype=hidden_states.dtype + timestep, batch_size=batch_size, hidden_dtype=hidden_states.dtype ) - if self.caption_projection is not None: - encoder_hidden_states = self.caption_projection(encoder_hidden_states) - encoder_hidden_states = encoder_hidden_states.view(batch_size, -1, hidden_states.shape[-1]) - if self.caption_norm is not None: - encoder_hidden_states = self.caption_norm(encoder_hidden_states) - - # 2. Blocks - for block in self.transformer_blocks: - if self.training and self.gradient_checkpointing: - - def create_custom_forward(module, return_dict=None): - def custom_forward(*inputs): - if return_dict is not None: - return module(*inputs, return_dict=return_dict) - else: - return module(*inputs) - - return custom_forward - - ckpt_kwargs: Dict[str, Any] = {"use_reentrant": False} if is_torch_version(">=", "1.11.0") else {} - hidden_states = torch.utils.checkpoint.checkpoint( - create_custom_forward(block), - hidden_states, - attention_mask, - encoder_hidden_states, - encoder_attention_mask, - timestep, - cross_attention_kwargs, - None, - added_cond_kwargs, - (height, width), - **ckpt_kwargs, + encoder_hidden_states = self.caption_projection(encoder_hidden_states) + encoder_hidden_states = encoder_hidden_states.view(batch_size, -1, hidden_states.shape[-1]) + + encoder_hidden_states = self.caption_norm(encoder_hidden_states) + + # 2. Transformer blocks + use_reentrant = is_torch_version("<=", "1.11.0") + + def create_block_forward(block): + if torch.is_grad_enabled() and self.gradient_checkpointing: + return lambda *inputs: torch.utils.checkpoint.checkpoint( + lambda *x: block(*x), *inputs, use_reentrant=use_reentrant ) else: - hidden_states = block( - hidden_states, - attention_mask=attention_mask, - encoder_hidden_states=encoder_hidden_states, - encoder_attention_mask=encoder_attention_mask, - timestep=timestep, - cross_attention_kwargs=cross_attention_kwargs, - class_labels=None, - HW=(height, width), - ) + return block - # 3. Output + for block in self.transformer_blocks: + hidden_states = create_block_forward(block)( + hidden_states, + attention_mask, + encoder_hidden_states, + encoder_attention_mask, + timestep, + (post_patch_height, post_patch_width), + ) + + # 3. Normalization shift, scale = ( self.scale_shift_table[None] + embedded_timestep[:, None].to(self.scale_shift_table.device) ).chunk(2, dim=1) hidden_states = self.norm_out(hidden_states) - # Modulation - hidden_states = hidden_states * (1 + scale.to(hidden_states.device)) + shift.to(hidden_states.device) + + # 4. Modulation + hidden_states = hidden_states * (1 + scale) + shift hidden_states = self.proj_out(hidden_states) - hidden_states = hidden_states.squeeze(1) - # unpatchify - hidden_states = hidden_states.reshape( - shape=(-1, height, width, self.config.patch_size, self.config.patch_size, self.out_channels) - ) - hidden_states = torch.einsum("nhwpqc->nchpwq", hidden_states) + # 5. Unpatchify + hidden_states = hidden_states.reshape(batch_size, post_patch_height, post_patch_width, self.config.patch_size, self.config.patch_size, -1) + hidden_states = hidden_states.permute(0, 5, 1, 3, 2, 4) output = hidden_states.reshape( - shape=(-1, self.out_channels, height * self.config.patch_size, width * self.config.patch_size) + shape=(batch_size, -1, post_patch_height * self.config.patch_size, post_patch_width * self.config.patch_size) ) if not return_dict: return (output,) - return Transformer2DModelOutput(sample=output) diff --git a/src/diffusers/pipelines/sana/pipeline_output.py b/src/diffusers/pipelines/sana/pipeline_output.py new file mode 100644 index 000000000000..f8ac12951644 --- /dev/null +++ b/src/diffusers/pipelines/sana/pipeline_output.py @@ -0,0 +1,21 @@ +from dataclasses import dataclass +from typing import List, Union + +import numpy as np +import PIL.Image + +from ...utils import BaseOutput + + +@dataclass +class SanaPipelineOutput(BaseOutput): + """ + Output class for Sana pipelines. + + Args: + images (`List[PIL.Image.Image]` or `np.ndarray`) + List of denoised PIL images of length `batch_size` or numpy array of shape `(batch_size, height, width, + num_channels)`. PIL images or numpy array present the denoised images of the diffusion pipeline. + """ + + images: Union[List[PIL.Image.Image], np.ndarray] diff --git a/src/diffusers/pipelines/sana/pipeline_sana.py b/src/diffusers/pipelines/sana/pipeline_sana.py index 728776a89269..dba5b3ec7348 100644 --- a/src/diffusers/pipelines/sana/pipeline_sana.py +++ b/src/diffusers/pipelines/sana/pipeline_sana.py @@ -16,11 +16,12 @@ import inspect import re import urllib.parse as ul -from typing import Callable, List, Optional, Tuple, Union +from typing import Callable, Dict, List, Optional, Tuple, Union import torch from transformers import AutoModelForCausalLM, AutoTokenizer +from ...callbacks import MultiPipelineCallbacks, PipelineCallback from ...image_processor import PixArtImageProcessor from ...models import AutoencoderDC, SanaTransformer2DModel from ...schedulers import FlowDPMSolverMultistepScheduler @@ -33,12 +34,13 @@ replace_example_docstring, ) from ...utils.torch_utils import randn_tensor -from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput +from ..pipeline_utils import DiffusionPipeline from ..pixart_alpha.pipeline_pixart_alpha import ( ASPECT_RATIO_512_BIN, ASPECT_RATIO_1024_BIN, ) from ..pixart_alpha.pipeline_pixart_sigma import ASPECT_RATIO_2048_BIN +from .pipeline_output import SanaPipelineOutput logger = logging.get_logger(__name__) # pylint: disable=invalid-name @@ -131,7 +133,7 @@ def retrieve_timesteps( class SanaPipeline(DiffusionPipeline): r""" - Pipeline for text-to-image generation using PixArt-Sigma. + Pipeline for text-to-image generation using [SANA](https://huggingface.co/papers/2410.10629). """ bad_punct_regex = re.compile( @@ -152,6 +154,7 @@ class SanaPipeline(DiffusionPipeline): _optional_components = ["tokenizer", "text_encoder"] model_cpu_offload_seq = "text_encoder->transformer->vae" + _callback_tensor_inputs = ["latents", "prompt_embeds", "negative_prompt_embeds"] def __init__( self, @@ -172,7 +175,6 @@ def __init__( ) self.image_processor = PixArtImageProcessor(vae_scale_factor=self.vae_scale_factor) - # Copied from diffusers.pipelines.pixart_alpha.pipeline_pixart_alpha.PixArtAlphaPipeline.encode_prompt with 120->300 def encode_prompt( self, prompt: Union[str, List[str]], @@ -186,7 +188,6 @@ def encode_prompt( negative_prompt_attention_mask: Optional[torch.Tensor] = None, clean_caption: bool = False, max_sequence_length: int = 300, - **kwargs, ): r""" Encodes the prompt into text encoder hidden states. @@ -215,10 +216,6 @@ def encode_prompt( max_sequence_length (`int`, defaults to 300): Maximum sequence length to use for the prompt. """ - if "mask_feature" in kwargs: - deprecation_message = "The use of `mask_feature` is deprecated. It is no longer used in any computation and that doesn't affect the end results. It will be removed in a future version." - deprecate("mask_feature", "1.0.0", deprecation_message, standard_warn=False) - if device is None: device = self._execution_device @@ -330,7 +327,6 @@ def check_inputs( height, width, negative_prompt, - callback_steps, prompt_embeds=None, negative_prompt_embeds=None, prompt_attention_mask=None, @@ -339,14 +335,6 @@ def check_inputs( if height % 8 != 0 or width % 8 != 0: raise ValueError(f"`height` and `width` have to be divisible by 8 but are {height} and {width}.") - if (callback_steps is None) or ( - callback_steps is not None and (not isinstance(callback_steps, int) or callback_steps <= 0) - ): - raise ValueError( - f"`callback_steps` has to be a positive integer but is {callback_steps} of type" - f" {type(callback_steps)}." - ) - if prompt is not None and prompt_embeds is not None: raise ValueError( f"Cannot forward both `prompt`: {prompt} and `prompt_embeds`: {prompt_embeds}. Please make sure to" @@ -563,8 +551,8 @@ def __call__( sigmas: List[float] = None, guidance_scale: float = 4.5, num_images_per_prompt: Optional[int] = 1, - height: Optional[int] = None, - width: Optional[int] = None, + height: int = 1024, + width: int = 1024, eta: float = 0.0, generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None, latents: Optional[torch.Tensor] = None, @@ -574,13 +562,12 @@ def __call__( negative_prompt_attention_mask: Optional[torch.Tensor] = None, output_type: Optional[str] = "pil", return_dict: bool = True, - callback: Optional[Callable[[int, int, torch.Tensor], None]] = None, - callback_steps: int = 1, clean_caption: bool = True, use_resolution_binning: bool = True, + callback_on_step_end: Optional[Callable[[int, int, Dict], None]] = None, + callback_on_step_end_tensor_inputs: List[str] = ["latents"], max_sequence_length: int = 300, - **kwargs, - ) -> Union[ImagePipelineOutput, Tuple]: + ) -> Union[SanaPipelineOutput, Tuple]: """ Function invoked when calling the pipeline for generation. @@ -639,12 +626,6 @@ def __call__( [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` or `np.array`. return_dict (`bool`, *optional*, defaults to `True`): Whether or not to return a [`~pipelines.stable_diffusion.IFPipelineOutput`] instead of a plain tuple. - callback (`Callable`, *optional*): - A function that will be called every `callback_steps` steps during inference. The function will be - called with the following arguments: `callback(step: int, timestep: int, latents: torch.Tensor)`. - callback_steps (`int`, *optional*, defaults to 1): - The frequency at which the `callback` function will be called. If not specified, the callback will be - called at every step. clean_caption (`bool`, *optional*, defaults to `True`): Whether or not to clean the caption before creating embeddings. Requires `beautifulsoup4` and `ftfy` to be installed. If the dependencies are not installed, the embeddings will be created from the raw @@ -653,18 +634,30 @@ def __call__( If set to `True`, the requested height and width are first mapped to the closest resolutions using `ASPECT_RATIO_1024_BIN`. After the produced latents are decoded into images, they are resized back to the requested resolution. Useful for generating non-square images. - max_sequence_length (`int` defaults to 300): Maximum sequence length to use with the `prompt`. + callback_on_step_end (`Callable`, *optional*): + A function that calls at the end of each denoising steps during the inference. The function is called + with the following arguments: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, + callback_kwargs: Dict)`. `callback_kwargs` will include a list of all tensors as specified by + `callback_on_step_end_tensor_inputs`. + callback_on_step_end_tensor_inputs (`List`, *optional*): + The list of tensor inputs for the `callback_on_step_end` function. The tensors specified in the list + will be passed as `callback_kwargs` argument. You will only be able to include variables listed in the + `._callback_tensor_inputs` attribute of your pipeline class. + max_sequence_length (`int` defaults to `300`): + Maximum sequence length to use with the `prompt`. Examples: Returns: - [`~pipelines.ImagePipelineOutput`] or `tuple`: - If `return_dict` is `True`, [`~pipelines.ImagePipelineOutput`] is returned, otherwise a `tuple` is + [`~pipelines.sana.pipeline_output.SanaPipelineOutput`] or `tuple`: + If `return_dict` is `True`, [`~pipelines.sana.pipeline_output.SanaPipelineOutput`] is returned, otherwise a `tuple` is returned where the first element is a list with the generated images """ + + if isinstance(callback_on_step_end, (PipelineCallback, MultiPipelineCallbacks)): + callback_on_step_end_tensor_inputs = callback_on_step_end.tensor_inputs + # 1. Check inputs. Raise error if not correct - height = height or self.transformer.config.sample_size * self.vae_scale_factor - width = width or self.transformer.config.sample_size * self.vae_scale_factor if use_resolution_binning: if self.transformer.config.sample_size == 64: aspect_ratio_bin = ASPECT_RATIO_2048_BIN @@ -682,7 +675,6 @@ def __call__( height, width, negative_prompt, - callback_steps, prompt_embeds, negative_prompt_embeds, prompt_attention_mask, @@ -748,9 +740,6 @@ def __call__( # 6. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta) - # 6.1 Prepare micro-conditions. - added_cond_kwargs = {"resolution": None, "aspect_ratio": None} - # 7. Denoising loop num_warmup_steps = max(len(timesteps) - num_inference_steps * self.scheduler.order, 0) @@ -758,28 +747,15 @@ def __call__( for i, t in enumerate(timesteps): latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents - current_timestep = t - if not torch.is_tensor(current_timestep): - # TODO: this requires sync between CPU and GPU. So try to pass timesteps as tensors if you can - # This would be a good case for the `match` statement (Python 3.10+) - is_mps = latent_model_input.device.type == "mps" - if isinstance(current_timestep, float): - dtype = torch.float32 if is_mps else torch.float64 - else: - dtype = torch.int32 if is_mps else torch.int64 - current_timestep = torch.tensor([current_timestep], dtype=dtype, device=latent_model_input.device) - elif len(current_timestep.shape) == 0: - current_timestep = current_timestep[None].to(latent_model_input.device) # broadcast to batch dimension in a way that's compatible with ONNX/Core ML - current_timestep = current_timestep.expand(latent_model_input.shape[0]) + timestep = t.expand(latent_model_input.shape[0]).to(latents.dtype) # predict noise model_output noise_pred = self.transformer( latent_model_input, encoder_hidden_states=prompt_embeds, encoder_attention_mask=prompt_attention_mask, - timestep=current_timestep, - added_cond_kwargs=added_cond_kwargs, + timestep=timestep, return_dict=False, )[0] @@ -805,9 +781,6 @@ def __call__( # call the callback, if provided if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0): progress_bar.update() - if callback is not None and i % callback_steps == 0: - step_idx = i // getattr(self.scheduler, "order", 1) - callback(step_idx, t, latents) if output_type == "latent": image = latents @@ -826,4 +799,4 @@ def __call__( if not return_dict: return (image,) - return ImagePipelineOutput(images=image) + return SanaPipelineOutput(images=image) diff --git a/tests/models/transformers/test_models_transformer_sana.py b/tests/models/transformers/test_models_transformer_sana.py new file mode 100644 index 000000000000..0222bef4c7c3 --- /dev/null +++ b/tests/models/transformers/test_models_transformer_sana.py @@ -0,0 +1,82 @@ +# Copyright 2024 HuggingFace Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import unittest + +import torch + +from diffusers import SanaTransformer2DModel +from diffusers.utils.testing_utils import ( + enable_full_determinism, + torch_device, +) + +from ..test_modeling_common import ModelTesterMixin + + +enable_full_determinism() + + +class SanaTransformerTests(ModelTesterMixin, unittest.TestCase): + model_class = SanaTransformer2DModel + main_input_name = "hidden_states" + uses_custom_attn_processor = True + + @property + def dummy_input(self): + batch_size = 2 + num_channels = 4 + height = 32 + width = 32 + embedding_dim = 8 + sequence_length = 8 + + hidden_states = torch.randn((batch_size, num_channels, height, width)).to(torch_device) + encoder_hidden_states = torch.randn((batch_size, sequence_length, embedding_dim)).to(torch_device) + timestep = torch.randint(0, 1000, size=(batch_size,)).to(torch_device) + + return { + "hidden_states": hidden_states, + "encoder_hidden_states": encoder_hidden_states, + "timestep": timestep, + } + + @property + def input_shape(self): + return (4, 32, 32) + + @property + def output_shape(self): + return (4, 32, 32) + + def prepare_init_args_and_inputs_for_common(self): + init_dict = { + "patch_size": 1, + "in_channels": 4, + "out_channels": 4, + "num_layers": 1, + "attention_head_dim": 4, + "num_attention_heads": 2, + "num_cross_attention_heads": 2, + "cross_attention_head_dim": 4, + "cross_attention_dim": 8, + "caption_channels": 8, + "sample_size": 32, + } + inputs_dict = self.dummy_input + return init_dict, inputs_dict + + def test_gradient_checkpointing_is_applied(self): + expected_set = {"SanaTransformer2DModel"} + super().test_gradient_checkpointing_is_applied(expected_set=expected_set) diff --git a/tests/pipelines/sana/__init__.py b/tests/pipelines/sana/__init__.py new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/tests/pipelines/sana/test_sana.py b/tests/pipelines/sana/test_sana.py new file mode 100644 index 000000000000..42128b2a8bb4 --- /dev/null +++ b/tests/pipelines/sana/test_sana.py @@ -0,0 +1,261 @@ +# Copyright 2024 The HuggingFace Team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import gc +import inspect +import unittest + +import numpy as np +import torch +from transformers import AutoTokenizer, Gemma2ForCausalLM, Gemma2Config, GemmaTokenizer + +from diffusers import AutoencoderDC, FlowMatchEulerDiscreteScheduler, SanaPipeline, SanaTransformer2DModel +from diffusers.utils.testing_utils import ( + enable_full_determinism, + numpy_cosine_similarity_distance, + require_torch_gpu, + slow, + torch_device +) + +from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS +from ..test_pipelines_common import ( + PipelineTesterMixin, + to_np +) + + +enable_full_determinism() + + +class SanaPipelineFastTests(PipelineTesterMixin, unittest.TestCase): + pipeline_class = SanaPipeline + params = TEXT_TO_IMAGE_PARAMS - {"cross_attention_kwargs"} + batch_params = TEXT_TO_IMAGE_BATCH_PARAMS + image_params = TEXT_TO_IMAGE_IMAGE_PARAMS + image_latents_params = TEXT_TO_IMAGE_IMAGE_PARAMS + required_optional_params = frozenset( + [ + "num_inference_steps", + "generator", + "latents", + "return_dict", + "callback_on_step_end", + "callback_on_step_end_tensor_inputs", + ] + ) + test_xformers_attention = False + + def get_dummy_components(self): + torch.manual_seed(0) + transformer = SanaTransformer2DModel( + patch_size=1, + in_channels=4, + out_channels=4, + num_layers=1, + num_attention_heads=2, + attention_head_dim=4, + num_cross_attention_heads=2, + cross_attention_head_dim=4, + cross_attention_dim=8, + caption_channels=8, + sample_size=32, + ) + + torch.manual_seed(0) + vae = AutoencoderDC( + in_channels=3, + latent_channels=4, + attention_head_dim=2, + encoder_block_types=( + "ResBlock", + "EfficientViTBlock", + ), + decoder_block_types=( + "ResBlock", + "EfficientViTBlock", + ), + encoder_block_out_channels=(8, 8), + decoder_block_out_channels=(8, 8), + encoder_qkv_multiscales=((), (5,)), + decoder_qkv_multiscales=((), (5,)), + encoder_layers_per_block=(1, 1), + decoder_layers_per_block=[1, 1], + downsample_block_type="conv", + upsample_block_type="interpolate", + decoder_norm_types="rms_norm", + decoder_act_fns="silu", + scaling_factor=0.41407, + ) + + torch.manual_seed(0) + scheduler = FlowMatchEulerDiscreteScheduler(shift=7.0) + + torch.manual_seed(0) + text_encoder_config = Gemma2Config( + head_dim=16, + hidden_size=32, + initializer_range=0.02, + intermediate_size=64, + max_position_embeddings=8192, + model_type="gemma2", + num_attention_heads=2, + num_hidden_layers=1, + num_key_value_heads=2, + vocab_size=8, + attn_implementation='eager', + ) + text_encoder = Gemma2ForCausalLM(text_encoder_config) + tokenizer = GemmaTokenizer.from_pretrained("hf-internal-testing/dummy-gemma") + + components = { + "transformer": transformer, + "vae": vae, + "scheduler": scheduler, + "text_encoder": text_encoder, + "tokenizer": tokenizer, + } + return components + + def get_dummy_inputs(self, device, seed=0): + if str(device).startswith("mps"): + generator = torch.manual_seed(seed) + else: + generator = torch.Generator(device=device).manual_seed(seed) + inputs = { + "prompt": "", + "negative_prompt": "", + "generator": generator, + "num_inference_steps": 2, + "guidance_scale": 6.0, + "height": 32, + "width": 32, + "max_sequence_length": 16, + "output_type": "pt", + } + return inputs + + def test_inference(self): + device = "cpu" + + components = self.get_dummy_components() + pipe = self.pipeline_class(**components) + pipe.to(device) + pipe.set_progress_bar_config(disable=None) + + inputs = self.get_dummy_inputs(device) + image = pipe(**inputs)[0] + generated_image = image[0] + + self.assertEqual(generated_image.shape, (3, 32, 32)) + expected_image = torch.randn(3, 32, 32) + max_diff = np.abs(generated_image - expected_image).max() + self.assertLessEqual(max_diff, 1e10) + + def test_callback_inputs(self): + sig = inspect.signature(self.pipeline_class.__call__) + has_callback_tensor_inputs = "callback_on_step_end_tensor_inputs" in sig.parameters + has_callback_step_end = "callback_on_step_end" in sig.parameters + + if not (has_callback_tensor_inputs and has_callback_step_end): + return + + components = self.get_dummy_components() + pipe = self.pipeline_class(**components) + pipe = pipe.to(torch_device) + pipe.set_progress_bar_config(disable=None) + self.assertTrue( + hasattr(pipe, "_callback_tensor_inputs"), + f" {self.pipeline_class} should have `_callback_tensor_inputs` that defines a list of tensor variables its callback function can use as inputs", + ) + + def callback_inputs_subset(pipe, i, t, callback_kwargs): + # iterate over callback args + for tensor_name, tensor_value in callback_kwargs.items(): + # check that we're only passing in allowed tensor inputs + assert tensor_name in pipe._callback_tensor_inputs + + return callback_kwargs + + def callback_inputs_all(pipe, i, t, callback_kwargs): + for tensor_name in pipe._callback_tensor_inputs: + assert tensor_name in callback_kwargs + + # iterate over callback args + for tensor_name, tensor_value in callback_kwargs.items(): + # check that we're only passing in allowed tensor inputs + assert tensor_name in pipe._callback_tensor_inputs + + return callback_kwargs + + inputs = self.get_dummy_inputs(torch_device) + + # Test passing in a subset + inputs["callback_on_step_end"] = callback_inputs_subset + inputs["callback_on_step_end_tensor_inputs"] = ["latents"] + output = pipe(**inputs)[0] + + # Test passing in a everything + inputs["callback_on_step_end"] = callback_inputs_all + inputs["callback_on_step_end_tensor_inputs"] = pipe._callback_tensor_inputs + output = pipe(**inputs)[0] + + def callback_inputs_change_tensor(pipe, i, t, callback_kwargs): + is_last = i == (pipe.num_timesteps - 1) + if is_last: + callback_kwargs["latents"] = torch.zeros_like(callback_kwargs["latents"]) + return callback_kwargs + + inputs["callback_on_step_end"] = callback_inputs_change_tensor + inputs["callback_on_step_end_tensor_inputs"] = pipe._callback_tensor_inputs + output = pipe(**inputs)[0] + assert output.abs().sum() < 1e10 + + def test_inference_batch_single_identical(self): + self._test_inference_batch_single_identical(batch_size=3, expected_max_diff=1e-3) + + def test_attention_slicing_forward_pass( + self, test_max_difference=True, test_mean_pixel_difference=True, expected_max_diff=1e-3 + ): + if not self.test_attention_slicing: + return + + components = self.get_dummy_components() + pipe = self.pipeline_class(**components) + for component in pipe.components.values(): + if hasattr(component, "set_default_attn_processor"): + component.set_default_attn_processor() + pipe.to(torch_device) + pipe.set_progress_bar_config(disable=None) + + generator_device = "cpu" + inputs = self.get_dummy_inputs(generator_device) + output_without_slicing = pipe(**inputs)[0] + + pipe.enable_attention_slicing(slice_size=1) + inputs = self.get_dummy_inputs(generator_device) + output_with_slicing1 = pipe(**inputs)[0] + + pipe.enable_attention_slicing(slice_size=2) + inputs = self.get_dummy_inputs(generator_device) + output_with_slicing2 = pipe(**inputs)[0] + + if test_max_difference: + max_diff1 = np.abs(to_np(output_with_slicing1) - to_np(output_without_slicing)).max() + max_diff2 = np.abs(to_np(output_with_slicing2) - to_np(output_without_slicing)).max() + self.assertLess( + max(max_diff1, max_diff2), + expected_max_diff, + "Attention slicing should not affect the inference results", + ) From 9d314263459bcd3c5455bff96a8d4990d3f6994c Mon Sep 17 00:00:00 2001 From: Aryan Date: Wed, 11 Dec 2024 23:41:41 +0100 Subject: [PATCH 114/141] make style --- scripts/convert_sana_pag_to_diffusers.py | 5 +-- scripts/convert_sana_to_diffusers.py | 19 +++++++----- src/diffusers/__init__.py | 8 ++--- src/diffusers/models/__init__.py | 2 +- src/diffusers/models/attention_processor.py | 7 ++--- src/diffusers/models/autoencoders/__init__.py | 1 - .../models/transformers/sana_transformer.py | 31 ++++++++++--------- .../pipelines/pag/pipeline_pag_sana.py | 3 +- src/diffusers/pipelines/sana/pipeline_sana.py | 26 +++++++++++----- src/diffusers/schedulers/__init__.py | 2 +- .../scheduling_dpmsolver_multistep_flow.py | 4 +-- tests/pipelines/sana/test_sana.py | 18 +++-------- 12 files changed, 66 insertions(+), 60 deletions(-) diff --git a/scripts/convert_sana_pag_to_diffusers.py b/scripts/convert_sana_pag_to_diffusers.py index 21c0bd19dc2f..ec6d4d692f0f 100644 --- a/scripts/convert_sana_pag_to_diffusers.py +++ b/scripts/convert_sana_pag_to_diffusers.py @@ -187,8 +187,9 @@ def main(args): try: state_dict.pop("y_embedder.y_embedding") state_dict.pop("pos_embed") - except: - pass + except KeyError: + print("y_embedder.y_embedding or pos_embed not found in the state_dict") + assert len(state_dict) == 0, f"State dict is not empty, {state_dict.keys()}" num_model_params = sum(p.numel() for p in transformer.parameters()) diff --git a/scripts/convert_sana_to_diffusers.py b/scripts/convert_sana_to_diffusers.py index d66eb9258fad..bf068ede1d42 100644 --- a/scripts/convert_sana_to_diffusers.py +++ b/scripts/convert_sana_to_diffusers.py @@ -38,7 +38,7 @@ def main(args): ckpt_id = ckpt_ids[0] cache_dir_path = os.path.expanduser("~/.cache/huggingface/hub") - + if args.orig_ckpt_path is None: snapshot_download( repo_id=ckpt_id, @@ -53,7 +53,7 @@ def main(args): ) else: file_path = args.orig_ckpt_path - + all_state_dict = torch.load(file_path, weights_only=True) state_dict = all_state_dict.pop("state_dict") converted_state_dict = {} @@ -98,7 +98,7 @@ def main(args): converted_state_dict[f"transformer_blocks.{depth}.scale_shift_table"] = state_dict.pop( f"blocks.{depth}.scale_shift_table" ) - + # Linear Attention is all you need 🤘 # Self attention. q, k, v = torch.chunk(state_dict.pop(f"blocks.{depth}.attn.qkv.weight"), 3, dim=0) @@ -182,8 +182,9 @@ def main(args): try: state_dict.pop("y_embedder.y_embedding") state_dict.pop("pos_embed") - except: - pass + except KeyError: + print("y_embedder.y_embedding or pos_embed not found in the state_dict") + assert len(state_dict) == 0, f"State dict is not empty, {state_dict.keys()}" num_model_params = sum(p.numel() for p in transformer.parameters()) @@ -198,11 +199,15 @@ def main(args): attrs=["bold"], ) ) - transformer.save_pretrained(os.path.join(args.dump_path, "transformer"), safe_serialization=True, max_shard_size="5GB", variant=variant) + transformer.save_pretrained( + os.path.join(args.dump_path, "transformer"), safe_serialization=True, max_shard_size="5GB", variant=variant + ) else: print(colored(f"Saving the whole SanaPipeline containing {args.model_type}", "green", attrs=["bold"])) # VAE - ae = AutoencoderDC.from_pretrained("mit-han-lab/dc-ae-f32c32-sana-1.0-diffusers",) + ae = AutoencoderDC.from_pretrained( + "mit-han-lab/dc-ae-f32c32-sana-1.0-diffusers", + ) # Text Encoder text_encoder_model_path = "google/gemma-2-2b-it" diff --git a/src/diffusers/__init__.py b/src/diffusers/__init__.py index 23ec1c6bc217..7d2f55811c2d 100644 --- a/src/diffusers/__init__.py +++ b/src/diffusers/__init__.py @@ -111,8 +111,8 @@ "MultiAdapter", "MultiControlNetModel", "PixArtTransformer2DModel", - "SanaTransformer2DModel", "PriorTransformer", + "SanaTransformer2DModel", "SD3ControlNetModel", "SD3MultiControlNetModel", "SD3Transformer2DModel", @@ -180,12 +180,12 @@ "DEISMultistepScheduler", "DPMSolverMultistepInverseScheduler", "DPMSolverMultistepScheduler", - "FlowDPMSolverMultistepScheduler", "DPMSolverSinglestepScheduler", "EDMDPMSolverMultistepScheduler", "EDMEulerScheduler", "EulerAncestralDiscreteScheduler", "EulerDiscreteScheduler", + "FlowDPMSolverMultistepScheduler", "FlowMatchEulerDiscreteScheduler", "FlowMatchHeunDiscreteScheduler", "HeunDiscreteScheduler", @@ -330,8 +330,8 @@ "PixArtSigmaPAGPipeline", "PixArtSigmaPipeline", "ReduxImageEncoder", - "SanaPipeline", "SanaPAGPipeline", + "SanaPipeline", "SemanticStableDiffusionPipeline", "ShapEImg2ImgPipeline", "ShapEPipeline", @@ -345,8 +345,8 @@ "StableDiffusion3Img2ImgPipeline", "StableDiffusion3InpaintPipeline", "StableDiffusion3PAGImg2ImgPipeline", - "StableDiffusion3PAGPipeline", "StableDiffusion3PAGImg2ImgPipeline", + "StableDiffusion3PAGPipeline", "StableDiffusion3Pipeline", "StableDiffusionAdapterPipeline", "StableDiffusionAttendAndExcitePipeline", diff --git a/src/diffusers/models/__init__.py b/src/diffusers/models/__init__.py index 410cb4e67459..6a28b1681a81 100644 --- a/src/diffusers/models/__init__.py +++ b/src/diffusers/models/__init__.py @@ -58,8 +58,8 @@ _import_structure["transformers.latte_transformer_3d"] = ["LatteTransformer3DModel"] _import_structure["transformers.lumina_nextdit2d"] = ["LuminaNextDiT2DModel"] _import_structure["transformers.pixart_transformer_2d"] = ["PixArtTransformer2DModel"] - _import_structure["transformers.sana_transformer"] = ["SanaTransformer2DModel"] _import_structure["transformers.prior_transformer"] = ["PriorTransformer"] + _import_structure["transformers.sana_transformer"] = ["SanaTransformer2DModel"] _import_structure["transformers.stable_audio_transformer"] = ["StableAudioDiTModel"] _import_structure["transformers.t5_film_transformer"] = ["T5FilmDecoder"] _import_structure["transformers.transformer_2d"] = ["Transformer2DModel"] diff --git a/src/diffusers/models/attention_processor.py b/src/diffusers/models/attention_processor.py index 2dea9eb8c669..af803c879dd9 100644 --- a/src/diffusers/models/attention_processor.py +++ b/src/diffusers/models/attention_processor.py @@ -5359,12 +5359,9 @@ def __call__( encoder_hidden_states: Optional[torch.Tensor] = None, attention_mask: Optional[torch.Tensor] = None, ) -> torch.Tensor: - input_ndim = hidden_states.ndim original_dtype = hidden_states.dtype - batch_size, _, _ = ( - hidden_states.shape if encoder_hidden_states is None else encoder_hidden_states.shape - ) + batch_size, _, _ = hidden_states.shape if encoder_hidden_states is None else encoder_hidden_states.shape if encoder_hidden_states is None: encoder_hidden_states = hidden_states @@ -5391,7 +5388,7 @@ def __call__( if hidden_states.dtype in [torch.float16, torch.bfloat16]: hidden_states = hidden_states.float() - + hidden_states = hidden_states[:, :, :-1] / (hidden_states[:, :, -1:] + self.eps) hidden_states = hidden_states.view(batch_size, attn.heads * head_dim, -1).permute(0, 2, 1) hidden_states = hidden_states.to(original_dtype) diff --git a/src/diffusers/models/autoencoders/__init__.py b/src/diffusers/models/autoencoders/__init__.py index 66139347e7a0..7a36e88f1a36 100644 --- a/src/diffusers/models/autoencoders/__init__.py +++ b/src/diffusers/models/autoencoders/__init__.py @@ -8,5 +8,4 @@ from .autoencoder_oobleck import AutoencoderOobleck from .autoencoder_tiny import AutoencoderTiny from .consistency_decoder_vae import ConsistencyDecoderVAE -from .autoencoder_dc import AutoencoderDC from .vq_model import VQModel diff --git a/src/diffusers/models/transformers/sana_transformer.py b/src/diffusers/models/transformers/sana_transformer.py index 5bc4c3fb7d4a..cc9d16005df1 100644 --- a/src/diffusers/models/transformers/sana_transformer.py +++ b/src/diffusers/models/transformers/sana_transformer.py @@ -12,8 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -from functools import partial -from typing import Any, Dict, Optional, Union +from typing import Dict, Optional, Union import torch from torch import nn @@ -25,7 +24,6 @@ Attention, AttentionProcessor, AttnProcessor2_0, - SanaMultiscaleLinearAttention, SanaLinearAttnProcessor2_0, ) from ..embeddings import PatchEmbed, PixArtAlphaTextProjection @@ -135,7 +133,7 @@ def __init__( mlp_ratio=mlp_ratio, ) - self.scale_shift_table = nn.Parameter(torch.randn(6, dim) / dim ** 0.5) + self.scale_shift_table = nn.Parameter(torch.randn(6, dim) / dim**0.5) def forward( self, @@ -152,7 +150,7 @@ def forward( shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = ( self.scale_shift_table[None] + timestep.reshape(batch_size, 6, -1) ).chunk(6, dim=1) - + # 2. Self Attention norm_hidden_states = self.norm1(hidden_states) norm_hidden_states = norm_hidden_states * (1 + scale_msa) + shift_msa @@ -258,9 +256,7 @@ def __init__( ) # 2. Caption Embedding - self.caption_projection = PixArtAlphaTextProjection( - in_features=caption_channels, hidden_size=inner_dim - ) + self.caption_projection = PixArtAlphaTextProjection(in_features=caption_channels, hidden_size=inner_dim) self.caption_norm = RMSNorm(inner_dim, eps=1e-5) # 3. Transformer blocks @@ -285,7 +281,7 @@ def __init__( # 4. Output blocks self.scale_shift_table = nn.Parameter(torch.randn(2, inner_dim) / inner_dim**0.5) - + self.norm_out = nn.LayerNorm(inner_dim, elementwise_affine=False, eps=1e-6) self.proj_out = nn.Linear(inner_dim, patch_size * patch_size * out_channels) @@ -401,12 +397,12 @@ def forward( encoder_hidden_states = self.caption_projection(encoder_hidden_states) encoder_hidden_states = encoder_hidden_states.view(batch_size, -1, hidden_states.shape[-1]) - + encoder_hidden_states = self.caption_norm(encoder_hidden_states) # 2. Transformer blocks use_reentrant = is_torch_version("<=", "1.11.0") - + def create_block_forward(block): if torch.is_grad_enabled() and self.gradient_checkpointing: return lambda *inputs: torch.utils.checkpoint.checkpoint( @@ -430,16 +426,23 @@ def create_block_forward(block): self.scale_shift_table[None] + embedded_timestep[:, None].to(self.scale_shift_table.device) ).chunk(2, dim=1) hidden_states = self.norm_out(hidden_states) - + # 4. Modulation hidden_states = hidden_states * (1 + scale) + shift hidden_states = self.proj_out(hidden_states) # 5. Unpatchify - hidden_states = hidden_states.reshape(batch_size, post_patch_height, post_patch_width, self.config.patch_size, self.config.patch_size, -1) + hidden_states = hidden_states.reshape( + batch_size, post_patch_height, post_patch_width, self.config.patch_size, self.config.patch_size, -1 + ) hidden_states = hidden_states.permute(0, 5, 1, 3, 2, 4) output = hidden_states.reshape( - shape=(batch_size, -1, post_patch_height * self.config.patch_size, post_patch_width * self.config.patch_size) + shape=( + batch_size, + -1, + post_patch_height * self.config.patch_size, + post_patch_width * self.config.patch_size, + ) ) if not return_dict: diff --git a/src/diffusers/pipelines/pag/pipeline_pag_sana.py b/src/diffusers/pipelines/pag/pipeline_pag_sana.py index d176bfc9709a..f49a43c6e9a5 100644 --- a/src/diffusers/pipelines/pag/pipeline_pag_sana.py +++ b/src/diffusers/pipelines/pag/pipeline_pag_sana.py @@ -176,7 +176,8 @@ def __init__( self.image_processor = PixArtImageProcessor(vae_scale_factor=self.vae_scale_factor) self.set_pag_applied_layers( - pag_applied_layers, pag_attn_processors=(PAGCFGSanaLinearAttnProcessor2_0(), PAGIdentitySanaLinearAttnProcessor2_0()) + pag_applied_layers, + pag_attn_processors=(PAGCFGSanaLinearAttnProcessor2_0(), PAGIdentitySanaLinearAttnProcessor2_0()), ) # Copied from diffusers.pipelines.pixart_alpha.pipeline_pixart_alpha.PixArtAlphaPipeline.encode_prompt with 120->300 diff --git a/src/diffusers/pipelines/sana/pipeline_sana.py b/src/diffusers/pipelines/sana/pipeline_sana.py index dba5b3ec7348..f1e47e0eb255 100644 --- a/src/diffusers/pipelines/sana/pipeline_sana.py +++ b/src/diffusers/pipelines/sana/pipeline_sana.py @@ -27,7 +27,6 @@ from ...schedulers import FlowDPMSolverMultistepScheduler from ...utils import ( BACKENDS_MAPPING, - deprecate, is_bs4_available, is_ftfy_available, logging, @@ -59,9 +58,7 @@ >>> from diffusers import SanaPipeline >>> # You can replace the checkpoint id with "Sana_1600M_1024px/Sana_1600M_1024px" too. - >>> pipe = SanaPipeline.from_pretrained( - ... "Sana_1600M_1024px/Sana_1600M_1024px", torch_dtype=torch.float16 - ... ) + >>> pipe = SanaPipeline.from_pretrained("Sana_1600M_1024px/Sana_1600M_1024px", torch_dtype=torch.float16) >>> # Enable memory optimizations. >>> # pipe.enable_model_cpu_offload() @@ -171,7 +168,9 @@ def __init__( ) self.vae_scale_factor = ( - 2 ** (len(self.vae.config.encoder_block_out_channels) - 1) if hasattr(self, "vae") and self.vae is not None else 32 + 2 ** (len(self.vae.config.encoder_block_out_channels) - 1) + if hasattr(self, "vae") and self.vae is not None + else 32 ) self.image_processor = PixArtImageProcessor(vae_scale_factor=self.vae_scale_factor) @@ -650,13 +649,13 @@ def __call__( Returns: [`~pipelines.sana.pipeline_output.SanaPipelineOutput`] or `tuple`: - If `return_dict` is `True`, [`~pipelines.sana.pipeline_output.SanaPipelineOutput`] is returned, otherwise a `tuple` is - returned where the first element is a list with the generated images + If `return_dict` is `True`, [`~pipelines.sana.pipeline_output.SanaPipelineOutput`] is returned, + otherwise a `tuple` is returned where the first element is a list with the generated images """ if isinstance(callback_on_step_end, (PipelineCallback, MultiPipelineCallbacks)): callback_on_step_end_tensor_inputs = callback_on_step_end.tensor_inputs - + # 1. Check inputs. Raise error if not correct if use_resolution_binning: if self.transformer.config.sample_size == 64: @@ -778,6 +777,17 @@ def __call__( if torch.backends.mps.is_available(): # some platforms (eg. apple mps) misbehave due to a pytorch bug: https://github.com/pytorch/pytorch/pull/99272 latents = latents.to(latents_dtype) + + if callback_on_step_end is not None: + callback_kwargs = {} + for k in callback_on_step_end_tensor_inputs: + callback_kwargs[k] = locals()[k] + callback_outputs = callback_on_step_end(self, i, t, callback_kwargs) + + latents = callback_outputs.pop("latents", latents) + prompt_embeds = callback_outputs.pop("prompt_embeds", prompt_embeds) + negative_prompt_embeds = callback_outputs.pop("negative_prompt_embeds", negative_prompt_embeds) + # call the callback, if provided if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0): progress_bar.update() diff --git a/src/diffusers/schedulers/__init__.py b/src/diffusers/schedulers/__init__.py index eb77969f6f49..c64a20c43974 100644 --- a/src/diffusers/schedulers/__init__.py +++ b/src/diffusers/schedulers/__init__.py @@ -52,9 +52,9 @@ _import_structure["scheduling_deis_multistep"] = ["DEISMultistepScheduler"] _import_structure["scheduling_dpm_cogvideox"] = ["CogVideoXDPMScheduler"] _import_structure["scheduling_dpmsolver_multistep"] = ["DPMSolverMultistepScheduler"] + _import_structure["scheduling_dpmsolver_multistep_flow"] = ["FlowDPMSolverMultistepScheduler"] _import_structure["scheduling_dpmsolver_multistep_inverse"] = ["DPMSolverMultistepInverseScheduler"] _import_structure["scheduling_dpmsolver_singlestep"] = ["DPMSolverSinglestepScheduler"] - _import_structure["scheduling_dpmsolver_multistep_flow"] = ["FlowDPMSolverMultistepScheduler"] _import_structure["scheduling_edm_dpmsolver_multistep"] = ["EDMDPMSolverMultistepScheduler"] _import_structure["scheduling_edm_euler"] = ["EDMEulerScheduler"] _import_structure["scheduling_euler_ancestral_discrete"] = ["EulerAncestralDiscreteScheduler"] diff --git a/src/diffusers/schedulers/scheduling_dpmsolver_multistep_flow.py b/src/diffusers/schedulers/scheduling_dpmsolver_multistep_flow.py index b5a666f38bac..955ecf514167 100644 --- a/src/diffusers/schedulers/scheduling_dpmsolver_multistep_flow.py +++ b/src/diffusers/schedulers/scheduling_dpmsolver_multistep_flow.py @@ -45,8 +45,8 @@ class FlowDPMSolverMultistepScheduler(SchedulerMixin, ConfigMixin): sampling, and `solver_order=3` for unconditional sampling. This affects the number of model outputs stored and used in multistep updates. prediction_type (`str`, defaults to "flow_prediction"): - Prediction type of the scheduler function; must be `flow_prediction` for this scheduler, which predicts - the flow of the diffusion process. + Prediction type of the scheduler function; must be `flow_prediction` for this scheduler, which predicts the + flow of the diffusion process. flow_shift (`float`, *optional*, defaults to 1.0): A factor used to adjust the sigmas in the noise schedule. It modifies the step sizes during the sampling process. diff --git a/tests/pipelines/sana/test_sana.py b/tests/pipelines/sana/test_sana.py index 42128b2a8bb4..c75c038f4be3 100644 --- a/tests/pipelines/sana/test_sana.py +++ b/tests/pipelines/sana/test_sana.py @@ -12,28 +12,18 @@ # See the License for the specific language governing permissions and # limitations under the License. -import gc import inspect import unittest import numpy as np import torch -from transformers import AutoTokenizer, Gemma2ForCausalLM, Gemma2Config, GemmaTokenizer +from transformers import Gemma2Config, Gemma2ForCausalLM, GemmaTokenizer from diffusers import AutoencoderDC, FlowMatchEulerDiscreteScheduler, SanaPipeline, SanaTransformer2DModel -from diffusers.utils.testing_utils import ( - enable_full_determinism, - numpy_cosine_similarity_distance, - require_torch_gpu, - slow, - torch_device -) +from diffusers.utils.testing_utils import enable_full_determinism, torch_device from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS -from ..test_pipelines_common import ( - PipelineTesterMixin, - to_np -) +from ..test_pipelines_common import PipelineTesterMixin, to_np enable_full_determinism() @@ -114,7 +104,7 @@ def get_dummy_components(self): num_hidden_layers=1, num_key_value_heads=2, vocab_size=8, - attn_implementation='eager', + attn_implementation="eager", ) text_encoder = Gemma2ForCausalLM(text_encoder_config) tokenizer = GemmaTokenizer.from_pretrained("hf-internal-testing/dummy-gemma") From 0debade619dbd23151715cd259c37d5fec213390 Mon Sep 17 00:00:00 2001 From: Aryan Date: Wed, 11 Dec 2024 23:45:31 +0100 Subject: [PATCH 115/141] make fix-copies --- .../pipelines/pag/pipeline_pag_sana.py | 19 +++---------------- src/diffusers/pipelines/sana/pipeline_sana.py | 3 ++- 2 files changed, 5 insertions(+), 17 deletions(-) diff --git a/src/diffusers/pipelines/pag/pipeline_pag_sana.py b/src/diffusers/pipelines/pag/pipeline_pag_sana.py index f49a43c6e9a5..d33814473bda 100644 --- a/src/diffusers/pipelines/pag/pipeline_pag_sana.py +++ b/src/diffusers/pipelines/pag/pipeline_pag_sana.py @@ -180,7 +180,7 @@ def __init__( pag_attn_processors=(PAGCFGSanaLinearAttnProcessor2_0(), PAGIdentitySanaLinearAttnProcessor2_0()), ) - # Copied from diffusers.pipelines.pixart_alpha.pipeline_pixart_alpha.PixArtAlphaPipeline.encode_prompt with 120->300 + # Copied from diffusers.pipelines.sana.pipeline_sana.SanaPipeline.encode_prompt def encode_prompt( self, prompt: Union[str, List[str]], @@ -194,7 +194,6 @@ def encode_prompt( negative_prompt_attention_mask: Optional[torch.Tensor] = None, clean_caption: bool = False, max_sequence_length: int = 300, - **kwargs, ): r""" Encodes the prompt into text encoder hidden states. @@ -223,10 +222,6 @@ def encode_prompt( max_sequence_length (`int`, defaults to 300): Maximum sequence length to use for the prompt. """ - if "mask_feature" in kwargs: - deprecation_message = "The use of `mask_feature` is deprecated. It is no longer used in any computation and that doesn't affect the end results. It will be removed in a future version." - deprecate("mask_feature", "1.0.0", deprecation_message, standard_warn=False) - if device is None: device = self._execution_device @@ -251,16 +246,6 @@ def encode_prompt( return_tensors="pt", ) text_input_ids = text_inputs.input_ids - untruncated_ids = self.tokenizer(prompt, padding="longest", return_tensors="pt").input_ids - - if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal( - text_input_ids, untruncated_ids - ): - removed_text = self.tokenizer.batch_decode(untruncated_ids[:, max_length - 1 : -1]) - logger.warning( - "The following part of your input was truncated because T5 can only handle sequences up to" - f" {max_length} tokens: {removed_text}" - ) prompt_attention_mask = text_inputs.attention_mask prompt_attention_mask = prompt_attention_mask.to(device) @@ -568,6 +553,8 @@ def prepare_latents(self, batch_size, num_channels_latents, height, width, dtype else: latents = latents.to(device) + # scale the initial noise by the standard deviation required by the scheduler + latents = latents * self.scheduler.init_noise_sigma return latents @torch.no_grad() diff --git a/src/diffusers/pipelines/sana/pipeline_sana.py b/src/diffusers/pipelines/sana/pipeline_sana.py index f1e47e0eb255..258a779b9ce7 100644 --- a/src/diffusers/pipelines/sana/pipeline_sana.py +++ b/src/diffusers/pipelines/sana/pipeline_sana.py @@ -319,7 +319,6 @@ def prepare_extra_step_kwargs(self, generator, eta): extra_step_kwargs["generator"] = generator return extra_step_kwargs - # Copied from diffusers.pipelines.pixart_alpha.pipeline_pixart_alpha.PixArtAlphaPipeline.check_inputs def check_inputs( self, prompt, @@ -537,6 +536,8 @@ def prepare_latents(self, batch_size, num_channels_latents, height, width, dtype else: latents = latents.to(device) + # scale the initial noise by the standard deviation required by the scheduler + latents = latents * self.scheduler.init_noise_sigma return latents @torch.no_grad() From 2c828c227dd041e64a66deb5f74f2140fb2890b5 Mon Sep 17 00:00:00 2001 From: Aryan Date: Thu, 12 Dec 2024 09:57:12 +0100 Subject: [PATCH 116/141] refactor --- scripts/convert_sana_to_diffusers.py | 23 ++--- src/diffusers/models/attention_processor.py | 18 +--- .../models/autoencoders/autoencoder_dc.py | 32 +------ .../models/transformers/sana_transformer.py | 96 +++++++++---------- .../pipelines/pag/pipeline_pag_sana.py | 1 - src/diffusers/pipelines/sana/pipeline_sana.py | 10 +- 6 files changed, 66 insertions(+), 114 deletions(-) diff --git a/scripts/convert_sana_to_diffusers.py b/scripts/convert_sana_to_diffusers.py index bf068ede1d42..7a0ed1500f26 100644 --- a/scripts/convert_sana_to_diffusers.py +++ b/scripts/convert_sana_to_diffusers.py @@ -59,8 +59,8 @@ def main(args): converted_state_dict = {} # Patch embeddings. - converted_state_dict["pos_embed.proj.weight"] = state_dict.pop("x_embedder.proj.weight") - converted_state_dict["pos_embed.proj.bias"] = state_dict.pop("x_embedder.proj.bias") + converted_state_dict["patch_embed.proj.weight"] = state_dict.pop("x_embedder.proj.weight") + converted_state_dict["patch_embed.proj.bias"] = state_dict.pop("x_embedder.proj.bias") # Caption projection. converted_state_dict["caption_projection.linear_1.weight"] = state_dict.pop("y_embedder.y_proj.fc1.weight") @@ -69,18 +69,18 @@ def main(args): converted_state_dict["caption_projection.linear_2.bias"] = state_dict.pop("y_embedder.y_proj.fc2.bias") # AdaLN-single LN - converted_state_dict["adaln_single.emb.timestep_embedder.linear_1.weight"] = state_dict.pop( + converted_state_dict["time_embed.emb.timestep_embedder.linear_1.weight"] = state_dict.pop( "t_embedder.mlp.0.weight" ) - converted_state_dict["adaln_single.emb.timestep_embedder.linear_1.bias"] = state_dict.pop("t_embedder.mlp.0.bias") - converted_state_dict["adaln_single.emb.timestep_embedder.linear_2.weight"] = state_dict.pop( + converted_state_dict["time_embed.emb.timestep_embedder.linear_1.bias"] = state_dict.pop("t_embedder.mlp.0.bias") + converted_state_dict["time_embed.emb.timestep_embedder.linear_2.weight"] = state_dict.pop( "t_embedder.mlp.2.weight" ) - converted_state_dict["adaln_single.emb.timestep_embedder.linear_2.bias"] = state_dict.pop("t_embedder.mlp.2.bias") + converted_state_dict["time_embed.emb.timestep_embedder.linear_2.bias"] = state_dict.pop("t_embedder.mlp.2.bias") # Shared norm. - converted_state_dict["adaln_single.linear.weight"] = state_dict.pop("t_block.1.weight") - converted_state_dict["adaln_single.linear.bias"] = state_dict.pop("t_block.1.bias") + converted_state_dict["time_embed.linear.weight"] = state_dict.pop("t_block.1.weight") + converted_state_dict["time_embed.linear.bias"] = state_dict.pop("t_block.1.bias") # y norm converted_state_dict["caption_norm.weight"] = state_dict.pop("attention_y_norm.weight") @@ -166,18 +166,19 @@ def main(args): num_cross_attention_heads=model_kwargs[args.model_type]["num_cross_attention_heads"], cross_attention_head_dim=model_kwargs[args.model_type]["cross_attention_head_dim"], cross_attention_dim=model_kwargs[args.model_type]["cross_attention_dim"], + caption_channels=2304, + mlp_ratio=2.5, attention_bias=False, sample_size=32, patch_size=1, norm_elementwise_affine=False, norm_eps=1e-6, - caption_channels=2304, - expand_ratio=2.5, ) + if is_accelerate_available(): load_model_dict_into_meta(transformer, converted_state_dict) else: - transformer.load_state_dict(converted_state_dict, strict=True) + transformer.load_state_dict(converted_state_dict, strict=True, assign=True) try: state_dict.pop("y_embedder.y_embedding") diff --git a/src/diffusers/models/attention_processor.py b/src/diffusers/models/attention_processor.py index af803c879dd9..3336e228e499 100644 --- a/src/diffusers/models/attention_processor.py +++ b/src/diffusers/models/attention_processor.py @@ -5361,8 +5361,6 @@ def __call__( ) -> torch.Tensor: original_dtype = hidden_states.dtype - batch_size, _, _ = hidden_states.shape if encoder_hidden_states is None else encoder_hidden_states.shape - if encoder_hidden_states is None: encoder_hidden_states = hidden_states @@ -5370,12 +5368,9 @@ def __call__( key = attn.to_k(encoder_hidden_states) value = attn.to_v(encoder_hidden_states) - inner_dim = key.shape[-1] - head_dim = inner_dim // attn.heads - - query = query.transpose(-1, -2).reshape(batch_size, attn.heads, head_dim, -1) - key = key.transpose(-1, -2).reshape(batch_size, attn.heads, head_dim, -1).transpose(-1, -2) - value = value.transpose(-1, -2).reshape(batch_size, attn.heads, head_dim, -1) + query = query.transpose(1, 2).unflatten(1, (attn.heads, -1)) + key = key.transpose(1, 2).unflatten(1, (attn.heads, -1)).transpose(2, 3) + value = value.transpose(1, 2).unflatten(1, (attn.heads, -1)) query = self.kernel_func(query) key = self.kernel_func(key) @@ -5386,17 +5381,14 @@ def __call__( scores = torch.matmul(value, key) hidden_states = torch.matmul(scores, query) - if hidden_states.dtype in [torch.float16, torch.bfloat16]: - hidden_states = hidden_states.float() - hidden_states = hidden_states[:, :, :-1] / (hidden_states[:, :, -1:] + self.eps) - hidden_states = hidden_states.view(batch_size, attn.heads * head_dim, -1).permute(0, 2, 1) + hidden_states = hidden_states.flatten(1, 2).transpose(1, 2) hidden_states = hidden_states.to(original_dtype) hidden_states = attn.to_out[0](hidden_states) hidden_states = attn.to_out[1](hidden_states) - if hidden_states.dtype == torch.float16: + if original_dtype == torch.float16: hidden_states = hidden_states.clip(-65504, 65504) return hidden_states diff --git a/src/diffusers/models/autoencoders/autoencoder_dc.py b/src/diffusers/models/autoencoders/autoencoder_dc.py index 76a2f0e4fb4d..109e37c23e1b 100644 --- a/src/diffusers/models/autoencoders/autoencoder_dc.py +++ b/src/diffusers/models/autoencoders/autoencoder_dc.py @@ -26,39 +26,10 @@ from ..attention_processor import SanaMultiscaleLinearAttention from ..modeling_utils import ModelMixin from ..normalization import RMSNorm, get_normalization +from ..transformers.sana_transformer import GLUMBConv from .vae import DecoderOutput, EncoderOutput -class GLUMBConv(nn.Module): - def __init__(self, in_channels: int, out_channels: int) -> None: - super().__init__() - - hidden_channels = 4 * in_channels - - self.nonlinearity = nn.SiLU() - - self.conv_inverted = nn.Conv2d(in_channels, hidden_channels * 2, 1, 1, 0) - self.conv_depth = nn.Conv2d(hidden_channels * 2, hidden_channels * 2, 3, 1, 1, groups=hidden_channels * 2) - self.conv_point = nn.Conv2d(hidden_channels, out_channels, 1, 1, 0, bias=False) - self.norm = RMSNorm(out_channels, eps=1e-5, elementwise_affine=True, bias=True) - - def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: - residual = hidden_states - - hidden_states = self.conv_inverted(hidden_states) - hidden_states = self.nonlinearity(hidden_states) - - hidden_states = self.conv_depth(hidden_states) - hidden_states, gate = torch.chunk(hidden_states, 2, dim=1) - hidden_states = hidden_states * self.nonlinearity(gate) - - hidden_states = self.conv_point(hidden_states) - # move channel to the last dimension so we apply RMSnorm across channel dimension - hidden_states = self.norm(hidden_states.movedim(1, -1)).movedim(-1, 1) - - return hidden_states + residual - - class ResBlock(nn.Module): def __init__( self, @@ -115,6 +86,7 @@ def __init__( self.conv_out = GLUMBConv( in_channels=in_channels, out_channels=in_channels, + norm_type="rms_norm", ) def forward(self, x: torch.Tensor) -> torch.Tensor: diff --git a/src/diffusers/models/transformers/sana_transformer.py b/src/diffusers/models/transformers/sana_transformer.py index cc9d16005df1..3a3a527d9705 100644 --- a/src/diffusers/models/transformers/sana_transformer.py +++ b/src/diffusers/models/transformers/sana_transformer.py @@ -12,7 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -from typing import Dict, Optional, Union +from typing import Dict, Optional, Tuple, Union import torch from torch import nn @@ -35,13 +35,13 @@ logger = logging.get_logger(__name__) # pylint: disable=invalid-name -# Modified from diffusers.models.autoencoders.autoencoder_dc.GLUMBConv -@maybe_allow_in_graph -class SanaGLUMBConv(nn.Module): - def __init__(self, in_channels: int, out_channels: int, mlp_ratio: float = 2.5) -> None: +class GLUMBConv(nn.Module): + def __init__(self, in_channels: int, out_channels: int, expand_ratio: float = 4, norm_type: Optional[str] = None, residual_connection: bool = True) -> None: super().__init__() - hidden_channels = int(mlp_ratio * in_channels) + hidden_channels = int(expand_ratio * in_channels) + self.norm_type = norm_type + self.residual_connection = residual_connection self.nonlinearity = nn.SiLU() @@ -49,14 +49,13 @@ def __init__(self, in_channels: int, out_channels: int, mlp_ratio: float = 2.5) self.conv_depth = nn.Conv2d(hidden_channels * 2, hidden_channels * 2, 3, 1, 1, groups=hidden_channels * 2) self.conv_point = nn.Conv2d(hidden_channels, out_channels, 1, 1, 0, bias=False) - def forward(self, hidden_states: torch.Tensor, HW: Optional[tuple[int]] = None) -> torch.Tensor: - B, N, C = hidden_states.shape - if HW is None: - H = W = int(N**0.5) - else: - H, W = HW + self.norm = None + if norm_type == "rms_norm": + self.norm = RMSNorm(out_channels, eps=1e-5, elementwise_affine=True, bias=True) - hidden_states = hidden_states.reshape(B, H, W, C).permute(0, 3, 1, 2) + def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: + if self.residual_connection: + residual = hidden_states hidden_states = self.conv_inverted(hidden_states) hidden_states = self.nonlinearity(hidden_states) @@ -66,23 +65,22 @@ def forward(self, hidden_states: torch.Tensor, HW: Optional[tuple[int]] = None) hidden_states = hidden_states * self.nonlinearity(gate) hidden_states = self.conv_point(hidden_states) - hidden_states = hidden_states.reshape(B, C, N).permute(0, 2, 1) - + + if self.norm_type == "rms_norm": + # move channel to the last dimension so we apply RMSnorm across channel dimension + hidden_states = self.norm(hidden_states.movedim(1, -1)).movedim(-1, 1) + + if self.residual_connection: + hidden_states = hidden_states + residual + return hidden_states class SanaTransformerBlock(nn.Module): r""" - A Transformer block following the Linear Transformer architecture, introduced in Sana - - Reference: https://arxiv.org/abs/2410.10629 - - Parameters: - dim (`int`): The number of channels in the input and output. - num_attention_heads (`int`): The number of heads to use for multi-head attention. - attention_head_dim (`int`): The number of channels in each head. + Transformer block introduced in [Sana](https://huggingface.co/papers/2410.10629). """ - + def __init__( self, dim: int = 2240, @@ -127,11 +125,7 @@ def __init__( ) # 3. Feed-forward - self.ff = SanaGLUMBConv( - in_channels=dim, - out_channels=dim, - mlp_ratio=mlp_ratio, - ) + self.ff = GLUMBConv(dim, dim, mlp_ratio, norm_type=None, residual_connection=False) self.scale_shift_table = nn.Parameter(torch.randn(6, dim) / dim**0.5) @@ -142,7 +136,8 @@ def forward( encoder_hidden_states: Optional[torch.Tensor] = None, encoder_attention_mask: Optional[torch.Tensor] = None, timestep: Optional[torch.LongTensor] = None, - HW: Optional[tuple[int]] = None, + height: int = None, + width: int = None, ) -> torch.Tensor: batch_size = hidden_states.shape[0] @@ -171,7 +166,9 @@ def forward( norm_hidden_states = self.norm2(hidden_states) norm_hidden_states = norm_hidden_states * (1 + scale_mlp) + shift_mlp - ff_output = self.ff(norm_hidden_states, HW=HW) + norm_hidden_states = norm_hidden_states.unflatten(1, (height, width)).permute(0, 3, 1, 2) + ff_output = self.ff(norm_hidden_states) + ff_output = ff_output.flatten(2, 3).permute(0, 2, 1) hidden_states = hidden_states + gate_mlp * ff_output return hidden_states @@ -179,7 +176,7 @@ def forward( class SanaTransformer2DModel(ModelMixin, ConfigMixin): r""" - A 2D Transformer model as introduced in [Sana](https://arxiv.org/abs/2410.10629) family of models. + A 2D Transformer model introduced in [Sana](https://huggingface.co/papers/2410.10629) family of models. Args: in_channels (`int`, defaults to `32`): @@ -204,7 +201,7 @@ class SanaTransformer2DModel(ModelMixin, ConfigMixin): The expansion ratio to use in the GLUMBConv layer. dropout (`float`, defaults to `0.0`): The dropout probability. - attention_bias (`bool`, defaults to `True`): + attention_bias (`bool`, defaults to `False`): Whether to use bias in the attention layer. sample_size (`int`, defaults to `32`): The base size of the input latent. @@ -233,7 +230,7 @@ def __init__( caption_channels: int = 2304, mlp_ratio: float = 2.5, dropout: float = 0.0, - attention_bias: bool = True, + attention_bias: bool = False, sample_size: int = 32, patch_size: int = 1, norm_elementwise_affine: bool = False, @@ -245,7 +242,7 @@ def __init__( inner_dim = num_attention_heads * attention_head_dim # 1. Patch Embedding - self.pos_embed = PatchEmbed( + self.patch_embed = PatchEmbed( height=sample_size, width=sample_size, patch_size=patch_size, @@ -255,7 +252,9 @@ def __init__( pos_embed_type=None, ) - # 2. Caption Embedding + # 2. Additional condition embeddings + self.time_embed = AdaLayerNormSingle(inner_dim) + self.caption_projection = PixArtAlphaTextProjection(in_features=caption_channels, hidden_size=inner_dim) self.caption_norm = RMSNorm(inner_dim, eps=1e-5) @@ -285,8 +284,6 @@ def __init__( self.norm_out = nn.LayerNorm(inner_dim, elementwise_affine=False, eps=1e-6) self.proj_out = nn.Linear(inner_dim, patch_size * patch_size * out_channels) - self.adaln_single = AdaLayerNormSingle(inner_dim) - self.gradient_checkpointing = False def _set_gradient_checkpointing(self, module, value=False): @@ -361,7 +358,7 @@ def forward( encoder_attention_mask: Optional[torch.Tensor] = None, attention_mask: Optional[torch.Tensor] = None, return_dict: bool = True, - ): + ) -> Union[Tuple[torch.Tensor, ...], Transformer2DModelOutput]: # ensure attention_mask is a bias, and give it a singleton query_tokens dimension. # we may have done this conversion already, e.g. if we came here via UNet2DConditionModel#forward. # we can tell by counting dims; if ndim == 2: it's a mask rather than a bias. @@ -387,11 +384,12 @@ def forward( # 1. Input batch_size, num_channels, height, width = hidden_states.shape - post_patch_height = height // self.config.patch_size - post_patch_width = width // self.config.patch_size - hidden_states = self.pos_embed(hidden_states) + p = self.config.patch_size + post_patch_height, post_patch_width = height // p, width // p + + hidden_states = self.patch_embed(hidden_states) - timestep, embedded_timestep = self.adaln_single( + timestep, embedded_timestep = self.time_embed( timestep, batch_size=batch_size, hidden_dtype=hidden_states.dtype ) @@ -418,7 +416,8 @@ def create_block_forward(block): encoder_hidden_states, encoder_attention_mask, timestep, - (post_patch_height, post_patch_width), + post_patch_height, + post_patch_width, ) # 3. Normalization @@ -436,14 +435,7 @@ def create_block_forward(block): batch_size, post_patch_height, post_patch_width, self.config.patch_size, self.config.patch_size, -1 ) hidden_states = hidden_states.permute(0, 5, 1, 3, 2, 4) - output = hidden_states.reshape( - shape=( - batch_size, - -1, - post_patch_height * self.config.patch_size, - post_patch_width * self.config.patch_size, - ) - ) + output = hidden_states.reshape(batch_size, -1, post_patch_height * p, post_patch_width * p) if not return_dict: return (output,) diff --git a/src/diffusers/pipelines/pag/pipeline_pag_sana.py b/src/diffusers/pipelines/pag/pipeline_pag_sana.py index d33814473bda..b67ff29c9abe 100644 --- a/src/diffusers/pipelines/pag/pipeline_pag_sana.py +++ b/src/diffusers/pipelines/pag/pipeline_pag_sana.py @@ -27,7 +27,6 @@ from ...schedulers import FlowDPMSolverMultistepScheduler from ...utils import ( BACKENDS_MAPPING, - deprecate, is_bs4_available, is_ftfy_available, logging, diff --git a/src/diffusers/pipelines/sana/pipeline_sana.py b/src/diffusers/pipelines/sana/pipeline_sana.py index 258a779b9ce7..62a90860d5c1 100644 --- a/src/diffusers/pipelines/sana/pipeline_sana.py +++ b/src/diffusers/pipelines/sana/pipeline_sana.py @@ -731,7 +731,7 @@ def __call__( latent_channels, height, width, - prompt_embeds.dtype, + torch.float32, device, generator, latents, @@ -746,6 +746,7 @@ def __call__( with self.progress_bar(total=num_inference_steps) as progress_bar: for i, t in enumerate(timesteps): latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents + latent_model_input = latent_model_input.to(prompt_embeds.dtype) # broadcast to batch dimension in a way that's compatible with ONNX/Core ML timestep = t.expand(latent_model_input.shape[0]).to(latents.dtype) @@ -758,6 +759,7 @@ def __call__( timestep=timestep, return_dict=False, )[0] + noise_pred = noise_pred.float() # perform guidance if do_classifier_free_guidance: @@ -771,14 +773,8 @@ def __call__( noise_pred = noise_pred # compute previous image: x_t -> x_t-1 - latents_dtype = latents.dtype latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs, return_dict=False)[0] - if latents.dtype != latents_dtype: - if torch.backends.mps.is_available(): - # some platforms (eg. apple mps) misbehave due to a pytorch bug: https://github.com/pytorch/pytorch/pull/99272 - latents = latents.to(latents_dtype) - if callback_on_step_end is not None: callback_kwargs = {} for k in callback_on_step_end_tensor_inputs: From 1ab6ab292e3490cf04cd950fce2dbaa7f333a982 Mon Sep 17 00:00:00 2001 From: Aryan Date: Thu, 12 Dec 2024 10:22:43 +0100 Subject: [PATCH 117/141] udpate pipelines --- scripts/convert_sana_to_diffusers.py | 2 +- .../models/transformers/sana_transformer.py | 22 ++- .../pipelines/pag/pipeline_pag_sana.py | 178 ++++++++---------- src/diffusers/pipelines/sana/pipeline_sana.py | 78 ++++---- 4 files changed, 140 insertions(+), 140 deletions(-) diff --git a/scripts/convert_sana_to_diffusers.py b/scripts/convert_sana_to_diffusers.py index 7a0ed1500f26..d93ee38ad0cd 100644 --- a/scripts/convert_sana_to_diffusers.py +++ b/scripts/convert_sana_to_diffusers.py @@ -174,7 +174,7 @@ def main(args): norm_elementwise_affine=False, norm_eps=1e-6, ) - + if is_accelerate_available(): load_model_dict_into_meta(transformer, converted_state_dict) else: diff --git a/src/diffusers/models/transformers/sana_transformer.py b/src/diffusers/models/transformers/sana_transformer.py index 3a3a527d9705..6af0cd9b885c 100644 --- a/src/diffusers/models/transformers/sana_transformer.py +++ b/src/diffusers/models/transformers/sana_transformer.py @@ -19,7 +19,6 @@ from ...configuration_utils import ConfigMixin, register_to_config from ...utils import is_torch_version, logging -from ...utils.torch_utils import maybe_allow_in_graph from ..attention_processor import ( Attention, AttentionProcessor, @@ -36,7 +35,14 @@ class GLUMBConv(nn.Module): - def __init__(self, in_channels: int, out_channels: int, expand_ratio: float = 4, norm_type: Optional[str] = None, residual_connection: bool = True) -> None: + def __init__( + self, + in_channels: int, + out_channels: int, + expand_ratio: float = 4, + norm_type: Optional[str] = None, + residual_connection: bool = True, + ) -> None: super().__init__() hidden_channels = int(expand_ratio * in_channels) @@ -44,7 +50,6 @@ def __init__(self, in_channels: int, out_channels: int, expand_ratio: float = 4, self.residual_connection = residual_connection self.nonlinearity = nn.SiLU() - self.conv_inverted = nn.Conv2d(in_channels, hidden_channels * 2, 1, 1, 0) self.conv_depth = nn.Conv2d(hidden_channels * 2, hidden_channels * 2, 3, 1, 1, groups=hidden_channels * 2) self.conv_point = nn.Conv2d(hidden_channels, out_channels, 1, 1, 0, bias=False) @@ -55,7 +60,7 @@ def __init__(self, in_channels: int, out_channels: int, expand_ratio: float = 4, def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: if self.residual_connection: - residual = hidden_states + residual = hidden_states hidden_states = self.conv_inverted(hidden_states) hidden_states = self.nonlinearity(hidden_states) @@ -65,14 +70,14 @@ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: hidden_states = hidden_states * self.nonlinearity(gate) hidden_states = self.conv_point(hidden_states) - + if self.norm_type == "rms_norm": # move channel to the last dimension so we apply RMSnorm across channel dimension hidden_states = self.norm(hidden_states.movedim(1, -1)).movedim(-1, 1) if self.residual_connection: hidden_states = hidden_states + residual - + return hidden_states @@ -80,7 +85,7 @@ class SanaTransformerBlock(nn.Module): r""" Transformer block introduced in [Sana](https://huggingface.co/papers/2410.10629). """ - + def __init__( self, dim: int = 2240, @@ -149,6 +154,7 @@ def forward( # 2. Self Attention norm_hidden_states = self.norm1(hidden_states) norm_hidden_states = norm_hidden_states * (1 + scale_msa) + shift_msa + norm_hidden_states = norm_hidden_states.to(hidden_states.dtype) attn_output = self.attn1(norm_hidden_states) hidden_states = hidden_states + gate_msa * attn_output @@ -256,7 +262,7 @@ def __init__( self.time_embed = AdaLayerNormSingle(inner_dim) self.caption_projection = PixArtAlphaTextProjection(in_features=caption_channels, hidden_size=inner_dim) - self.caption_norm = RMSNorm(inner_dim, eps=1e-5) + self.caption_norm = RMSNorm(inner_dim, eps=1e-5, elementwise_affine=True) # 3. Transformer blocks self.transformer_blocks = nn.ModuleList( diff --git a/src/diffusers/pipelines/pag/pipeline_pag_sana.py b/src/diffusers/pipelines/pag/pipeline_pag_sana.py index b67ff29c9abe..b141806cd3aa 100644 --- a/src/diffusers/pipelines/pag/pipeline_pag_sana.py +++ b/src/diffusers/pipelines/pag/pipeline_pag_sana.py @@ -16,11 +16,12 @@ import inspect import re import urllib.parse as ul -from typing import Callable, List, Optional, Tuple, Union +from typing import Callable, Dict, List, Optional, Tuple, Union import torch from transformers import AutoModelForCausalLM, AutoTokenizer +from ...callbacks import MultiPipelineCallbacks, PipelineCallback from ...image_processor import PixArtImageProcessor from ...models import AutoencoderDC, SanaTransformer2DModel from ...models.attention_processor import PAGCFGSanaLinearAttnProcessor2_0, PAGIdentitySanaLinearAttnProcessor2_0 @@ -54,19 +55,7 @@ EXAMPLE_DOC_STRING = """ Examples: ```py - >>> import torch - >>> from diffusers import AutoPipelineForText2Image - - >>> pipe = AutoPipelineForText2Image.from_pretrained( - ... "PixArt-alpha/PixArt-Sigma-XL-2-1024-MS", - ... torch_dtype=torch.float16, - ... pag_applied_layers=["blocks.14"], - ... enable_pag=True, - ... ) - >>> pipe = pipe.to("cuda") - - >>> prompt = "A small cactus with a happy face in the Sahara desert" - >>> image = pipe(prompt, pag_scale=4.0, guidance_scale=1.0).images[0] + # TODO(aryan): once the weights are hosted ``` """ @@ -133,28 +122,18 @@ def retrieve_timesteps( class SanaPAGPipeline(DiffusionPipeline, PAGMixin): r""" - [PAG pipeline](https://huggingface.co/docs/diffusers/main/en/using-diffusers/pag) for text-to-image generation - using PixArt-Sigma. + Pipeline for text-to-image generation using [Sana](https://huggingface.co/papers/2410.10629). This pipeline + supports the use of [Perturbed Attention Guidance + (PAG)](https://huggingface.co/docs/diffusers/main/en/using-diffusers/pag). """ - bad_punct_regex = re.compile( - r"[" - + "#®•©™&@·º½¾¿¡§~" - + r"\)" - + r"\(" - + r"\]" - + r"\[" - + r"\}" - + r"\{" - + r"\|" - + "\\" - + r"\/" - + r"\*" - + r"]{1,}" - ) # noqa + # fmt: off + bad_punct_regex = re.compile(r"[" + "#®•©™&@·º½¾¿¡§~" + r"\)" + r"\(" + r"\]" + r"\[" + r"\}" + r"\{" + r"\|" + "\\" + r"\/" + r"\*" + r"]{1,}") + # fmt: on _optional_components = ["tokenizer", "text_encoder"] model_cpu_offload_seq = "text_encoder->transformer->vae" + _callback_tensor_inputs = ["latents", "prompt_embeds", "negative_prompt_embeds"] def __init__( self, @@ -163,7 +142,7 @@ def __init__( vae: AutoencoderDC, transformer: SanaTransformer2DModel, scheduler: FlowDPMSolverMultistepScheduler, - pag_applied_layers: Union[str, List[str]] = "blocks.1", # 1st transformer block + pag_applied_layers: Union[str, List[str]] = "transformer_blocks.8", ): super().__init__() @@ -325,14 +304,14 @@ def prepare_extra_step_kwargs(self, generator, eta): extra_step_kwargs["generator"] = generator return extra_step_kwargs - # Copied from diffusers.pipelines.pixart_alpha.pipeline_pixart_alpha.PixArtAlphaPipeline.check_inputs + # Copied from diffusers.pipelines.sana.pipeline_sana.SanaPipeline.check_inputs def check_inputs( self, prompt, height, width, - negative_prompt, - callback_steps, + callback_on_step_end_tensor_inputs=None, + negative_prompt=None, prompt_embeds=None, negative_prompt_embeds=None, prompt_attention_mask=None, @@ -341,12 +320,11 @@ def check_inputs( if height % 8 != 0 or width % 8 != 0: raise ValueError(f"`height` and `width` have to be divisible by 8 but are {height} and {width}.") - if (callback_steps is None) or ( - callback_steps is not None and (not isinstance(callback_steps, int) or callback_steps <= 0) + if callback_on_step_end_tensor_inputs is not None and not all( + k in self._callback_tensor_inputs for k in callback_on_step_end_tensor_inputs ): raise ValueError( - f"`callback_steps` has to be a positive integer but is {callback_steps} of type" - f" {type(callback_steps)}." + f"`callback_on_step_end_tensor_inputs` has to be in {self._callback_tensor_inputs}, but found {[k for k in callback_on_step_end_tensor_inputs if k not in self._callback_tensor_inputs]}" ) if prompt is not None and prompt_embeds is not None: @@ -393,7 +371,7 @@ def check_inputs( f" {negative_prompt_attention_mask.shape}." ) - # Copied from diffusers.pipelines.deepfloyd_if.pipeline_if.IFPipeline._text_preprocessing + # Copied from diffusers.pipelines.sana.pipeline_sana.SanaPipeline._text_preprocessing def _text_preprocessing(self, text, clean_caption=False): if clean_caption and not is_bs4_available(): logger.warning(BACKENDS_MAPPING["bs4"][-1].format("Setting `clean_caption=True`")) @@ -418,7 +396,7 @@ def process(text: str): return [process(t) for t in text] - # Copied from diffusers.pipelines.deepfloyd_if.pipeline_if.IFPipeline._clean_caption + # Copied from diffusers.pipelines.sana.pipeline_sana.SanaPipeline._clean_caption def _clean_caption(self, caption): caption = str(caption) caption = ul.unquote_plus(caption) @@ -556,6 +534,22 @@ def prepare_latents(self, batch_size, num_channels_latents, height, width, dtype latents = latents * self.scheduler.init_noise_sigma return latents + @property + def guidance_scale(self): + return self._guidance_scale + + @property + def do_classifier_free_guidance(self): + return self._guidance_scale > 1.0 + + @property + def num_timesteps(self): + return self._num_timesteps + + @property + def interrupt(self): + return self._interrupt + @torch.no_grad() @replace_example_docstring(EXAMPLE_DOC_STRING) def __call__( @@ -578,10 +572,10 @@ def __call__( negative_prompt_attention_mask: Optional[torch.Tensor] = None, output_type: Optional[str] = "pil", return_dict: bool = True, - callback: Optional[Callable[[int, int, torch.Tensor], None]] = None, - callback_steps: int = 1, clean_caption: bool = True, use_resolution_binning: bool = True, + callback_on_step_end: Optional[Callable[[int, int, Dict], None]] = None, + callback_on_step_end_tensor_inputs: List[str] = ["latents"], max_sequence_length: int = 300, pag_scale: float = 3.0, pag_adaptive_scale: float = 0.0, @@ -644,12 +638,6 @@ def __call__( [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` or `np.array`. return_dict (`bool`, *optional*, defaults to `True`): Whether or not to return a [`~pipelines.stable_diffusion.IFPipelineOutput`] instead of a plain tuple. - callback (`Callable`, *optional*): - A function that will be called every `callback_steps` steps during inference. The function will be - called with the following arguments: `callback(step: int, timestep: int, latents: torch.Tensor)`. - callback_steps (`int`, *optional*, defaults to 1): - The frequency at which the `callback` function will be called. If not specified, the callback will be - called at every step. clean_caption (`bool`, *optional*, defaults to `True`): Whether or not to clean the caption before creating embeddings. Requires `beautifulsoup4` and `ftfy` to be installed. If the dependencies are not installed, the embeddings will be created from the raw @@ -658,6 +646,15 @@ def __call__( If set to `True`, the requested height and width are first mapped to the closest resolutions using `ASPECT_RATIO_1024_BIN`. After the produced latents are decoded into images, they are resized back to the requested resolution. Useful for generating non-square images. + callback_on_step_end (`Callable`, *optional*): + A function that calls at the end of each denoising steps during the inference. The function is called + with the following arguments: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, + callback_kwargs: Dict)`. `callback_kwargs` will include a list of all tensors as specified by + `callback_on_step_end_tensor_inputs`. + callback_on_step_end_tensor_inputs (`List`, *optional*): + The list of tensor inputs for the `callback_on_step_end` function. The tensors specified in the list + will be passed as `callback_kwargs` argument. You will only be able to include variables listed in the + `._callback_tensor_inputs` attribute of your pipeline class. max_sequence_length (`int` defaults to 300): Maximum sequence length to use with the `prompt`. pag_scale (`float`, *optional*, defaults to 3.0): The scale factor for the perturbed attention guidance. If it is set to 0.0, the perturbed attention @@ -665,6 +662,7 @@ def __call__( pag_adaptive_scale (`float`, *optional*, defaults to 0.0): The adaptive scale factor for the perturbed attention guidance. If it is set to 0.0, `pag_scale` is used. + Examples: Returns: @@ -672,9 +670,10 @@ def __call__( If `return_dict` is `True`, [`~pipelines.ImagePipelineOutput`] is returned, otherwise a `tuple` is returned where the first element is a list with the generated images """ - # 1. Check inputs. Raise error if not correct - height = height or self.transformer.config.sample_size * self.vae_scale_factor - width = width or self.transformer.config.sample_size * self.vae_scale_factor + + if isinstance(callback_on_step_end, (PipelineCallback, MultiPipelineCallbacks)): + callback_on_step_end_tensor_inputs = callback_on_step_end.tensor_inputs + if use_resolution_binning: if self.transformer.config.sample_size == 64: aspect_ratio_bin = ASPECT_RATIO_2048_BIN @@ -691,15 +690,18 @@ def __call__( prompt, height, width, + callback_on_step_end_tensor_inputs, negative_prompt, - callback_steps, prompt_embeds, negative_prompt_embeds, prompt_attention_mask, negative_prompt_attention_mask, ) + self._pag_scale = pag_scale self._pag_adaptive_scale = pag_adaptive_scale + self._guidance_scale = guidance_scale + self._interrupt = False # 2. Default height and width to transformer if prompt is not None and isinstance(prompt, str): @@ -711,11 +713,6 @@ def __call__( device = self._execution_device - # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2) - # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1` - # corresponds to doing no classifier free guidance. - do_classifier_free_guidance = guidance_scale > 1.0 - # 3. Encode input prompt ( prompt_embeds, @@ -724,7 +721,7 @@ def __call__( negative_prompt_attention_mask, ) = self.encode_prompt( prompt, - do_classifier_free_guidance, + self.do_classifier_free_guidance, negative_prompt=negative_prompt, num_images_per_prompt=num_images_per_prompt, device=device, @@ -735,14 +732,15 @@ def __call__( clean_caption=clean_caption, max_sequence_length=max_sequence_length, ) + if self.do_perturbed_attention_guidance: prompt_embeds = self._prepare_perturbed_attention_guidance( - prompt_embeds, negative_prompt_embeds, do_classifier_free_guidance + prompt_embeds, negative_prompt_embeds, self.do_classifier_free_guidance ) prompt_attention_mask = self._prepare_perturbed_attention_guidance( - prompt_attention_mask, negative_prompt_attention_mask, do_classifier_free_guidance + prompt_attention_mask, negative_prompt_attention_mask, self.do_classifier_free_guidance ) - elif do_classifier_free_guidance: + elif self.do_classifier_free_guidance: prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds], dim=0) prompt_attention_mask = torch.cat([negative_prompt_attention_mask, prompt_attention_mask], dim=0) @@ -758,7 +756,7 @@ def __call__( latent_channels, height, width, - prompt_embeds.dtype, + torch.float32, device, generator, latents, @@ -767,7 +765,7 @@ def __call__( original_attn_proc = self.transformer.attn_processors self._set_pag_attn_processor( pag_applied_layers=self.pag_applied_layers, - do_classifier_free_guidance=do_classifier_free_guidance, + do_classifier_free_guidance=self.do_classifier_free_guidance, ) # 6. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline @@ -778,67 +776,57 @@ def __call__( # 7. Denoising loop num_warmup_steps = max(len(timesteps) - num_inference_steps * self.scheduler.order, 0) + self._num_timesteps = len(timesteps) with self.progress_bar(total=num_inference_steps) as progress_bar: for i, t in enumerate(timesteps): + if self.interrupt: + continue + # expand the latents if we are doing classifier free guidance, perturbed-attention guidance, or both latent_model_input = torch.cat([latents] * (prompt_embeds.shape[0] // latents.shape[0])) - latent_model_input = self.scheduler.scale_model_input(latent_model_input, t) - - current_timestep = t - if not torch.is_tensor(current_timestep): - # TODO: this requires sync between CPU and GPU. So try to pass timesteps as tensors if you can - # This would be a good case for the `match` statement (Python 3.10+) - is_mps = latent_model_input.device.type == "mps" - if isinstance(current_timestep, float): - dtype = torch.float32 if is_mps else torch.float64 - else: - dtype = torch.int32 if is_mps else torch.int64 - current_timestep = torch.tensor([current_timestep], dtype=dtype, device=latent_model_input.device) - elif len(current_timestep.shape) == 0: - current_timestep = current_timestep[None].to(latent_model_input.device) + latent_model_input = latent_model_input.to(prompt_embeds.dtype) + # broadcast to batch dimension in a way that's compatible with ONNX/Core ML - current_timestep = current_timestep.expand(latent_model_input.shape[0]) + timestep = t.expand(latent_model_input.shape[0]).to(latents.dtype) # predict noise model_output noise_pred = self.transformer( latent_model_input, encoder_hidden_states=prompt_embeds, encoder_attention_mask=prompt_attention_mask, - timestep=current_timestep, + timestep=timestep, added_cond_kwargs=added_cond_kwargs, return_dict=False, )[0] + noise_pred = noise_pred.float() # perform guidance if self.do_perturbed_attention_guidance: noise_pred = self._apply_perturbed_attention_guidance( - noise_pred, do_classifier_free_guidance, guidance_scale, current_timestep + noise_pred, self.do_classifier_free_guidance, guidance_scale, timestep ) - elif do_classifier_free_guidance: + elif self.do_classifier_free_guidance: noise_pred_uncond, noise_pred_text = noise_pred.chunk(2) noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) - # learned sigma - if self.transformer.config.out_channels // 2 == latent_channels: - noise_pred = noise_pred.chunk(2, dim=1)[0] - else: - noise_pred = noise_pred - # compute previous image: x_t -> x_t-1 latents_dtype = latents.dtype latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs, return_dict=False)[0] - if latents.dtype != latents_dtype: - if torch.backends.mps.is_available(): - # some platforms (eg. apple mps) misbehave due to a pytorch bug: https://github.com/pytorch/pytorch/pull/99272 - latents = latents.to(latents_dtype) # call the callback, if provided + if callback_on_step_end is not None: + callback_kwargs = {} + for k in callback_on_step_end_tensor_inputs: + callback_kwargs[k] = locals()[k] + callback_outputs = callback_on_step_end(self, i, t, callback_kwargs) + + latents = callback_outputs.pop("latents", latents) + prompt_embeds = callback_outputs.pop("prompt_embeds", prompt_embeds) + negative_prompt_embeds = callback_outputs.pop("negative_prompt_embeds", negative_prompt_embeds) + if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0): progress_bar.update() - if callback is not None and i % callback_steps == 0: - step_idx = i // getattr(self.scheduler, "order", 1) - callback(step_idx, t, latents) if output_type == "latent": image = latents diff --git a/src/diffusers/pipelines/sana/pipeline_sana.py b/src/diffusers/pipelines/sana/pipeline_sana.py index 62a90860d5c1..55b4c4835b7a 100644 --- a/src/diffusers/pipelines/sana/pipeline_sana.py +++ b/src/diffusers/pipelines/sana/pipeline_sana.py @@ -54,16 +54,7 @@ EXAMPLE_DOC_STRING = """ Examples: ```py - >>> import torch - >>> from diffusers import SanaPipeline - - >>> # You can replace the checkpoint id with "Sana_1600M_1024px/Sana_1600M_1024px" too. - >>> pipe = SanaPipeline.from_pretrained("Sana_1600M_1024px/Sana_1600M_1024px", torch_dtype=torch.float16) - >>> # Enable memory optimizations. - >>> # pipe.enable_model_cpu_offload() - - >>> prompt = "A small cactus with a happy face in the Sahara desert." - >>> image = pipe(prompt).images[0] + # TODO(aryan): once the weights are hosted ``` """ @@ -130,24 +121,12 @@ def retrieve_timesteps( class SanaPipeline(DiffusionPipeline): r""" - Pipeline for text-to-image generation using [SANA](https://huggingface.co/papers/2410.10629). + Pipeline for text-to-image generation using [Sana](https://huggingface.co/papers/2410.10629). """ - bad_punct_regex = re.compile( - r"[" - + "#®•©™&@·º½¾¿¡§~" - + r"\)" - + r"\(" - + r"\]" - + r"\[" - + r"\}" - + r"\{" - + r"\|" - + "\\" - + r"\/" - + r"\*" - + r"]{1,}" - ) # noqa + # fmt: off + bad_punct_regex = re.compile(r"[" + "#®•©™&@·º½¾¿¡§~" + r"\)" + r"\(" + r"\]" + r"\[" + r"\}" + r"\{" + r"\|" + "\\" + r"\/" + r"\*" + r"]{1,}") + # fmt: on _optional_components = ["tokenizer", "text_encoder"] model_cpu_offload_seq = "text_encoder->transformer->vae" @@ -324,7 +303,8 @@ def check_inputs( prompt, height, width, - negative_prompt, + callback_on_step_end_tensor_inputs=None, + negative_prompt=None, prompt_embeds=None, negative_prompt_embeds=None, prompt_attention_mask=None, @@ -333,6 +313,13 @@ def check_inputs( if height % 8 != 0 or width % 8 != 0: raise ValueError(f"`height` and `width` have to be divisible by 8 but are {height} and {width}.") + if callback_on_step_end_tensor_inputs is not None and not all( + k in self._callback_tensor_inputs for k in callback_on_step_end_tensor_inputs + ): + raise ValueError( + f"`callback_on_step_end_tensor_inputs` has to be in {self._callback_tensor_inputs}, but found {[k for k in callback_on_step_end_tensor_inputs if k not in self._callback_tensor_inputs]}" + ) + if prompt is not None and prompt_embeds is not None: raise ValueError( f"Cannot forward both `prompt`: {prompt} and `prompt_embeds`: {prompt_embeds}. Please make sure to" @@ -540,6 +527,22 @@ def prepare_latents(self, batch_size, num_channels_latents, height, width, dtype latents = latents * self.scheduler.init_noise_sigma return latents + @property + def guidance_scale(self): + return self._guidance_scale + + @property + def do_classifier_free_guidance(self): + return self._guidance_scale > 1.0 + + @property + def num_timesteps(self): + return self._num_timesteps + + @property + def interrupt(self): + return self._interrupt + @torch.no_grad() @replace_example_docstring(EXAMPLE_DOC_STRING) def __call__( @@ -674,6 +677,7 @@ def __call__( prompt, height, width, + callback_on_step_end_tensor_inputs, negative_prompt, prompt_embeds, negative_prompt_embeds, @@ -681,6 +685,9 @@ def __call__( negative_prompt_attention_mask, ) + self._guidance_scale = guidance_scale + self._interrupt = False + # 2. Default height and width to transformer if prompt is not None and isinstance(prompt, str): batch_size = 1 @@ -691,11 +698,6 @@ def __call__( device = self._execution_device - # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2) - # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1` - # corresponds to doing no classifier free guidance. - do_classifier_free_guidance = guidance_scale > 1.0 - # 3. Encode input prompt ( prompt_embeds, @@ -704,7 +706,7 @@ def __call__( negative_prompt_attention_mask, ) = self.encode_prompt( prompt, - do_classifier_free_guidance, + self.do_classifier_free_guidance, negative_prompt=negative_prompt, num_images_per_prompt=num_images_per_prompt, device=device, @@ -715,7 +717,7 @@ def __call__( clean_caption=clean_caption, max_sequence_length=max_sequence_length, ) - if do_classifier_free_guidance: + if self.do_classifier_free_guidance: prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds], dim=0) prompt_attention_mask = torch.cat([negative_prompt_attention_mask, prompt_attention_mask], dim=0) @@ -742,10 +744,14 @@ def __call__( # 7. Denoising loop num_warmup_steps = max(len(timesteps) - num_inference_steps * self.scheduler.order, 0) + self._num_timesteps = len(timesteps) with self.progress_bar(total=num_inference_steps) as progress_bar: for i, t in enumerate(timesteps): - latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents + if self.interrupt: + continue + + latent_model_input = torch.cat([latents] * 2) if self.do_classifier_free_guidance else latents latent_model_input = latent_model_input.to(prompt_embeds.dtype) # broadcast to batch dimension in a way that's compatible with ONNX/Core ML @@ -762,7 +768,7 @@ def __call__( noise_pred = noise_pred.float() # perform guidance - if do_classifier_free_guidance: + if self.do_classifier_free_guidance: noise_pred_uncond, noise_pred_text = noise_pred.chunk(2) noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) From 3ab6db76db08fccadebacb0a71acf9bca27c2fd5 Mon Sep 17 00:00:00 2001 From: Aryan Date: Thu, 12 Dec 2024 10:48:32 +0100 Subject: [PATCH 118/141] pag tests and refactor --- src/diffusers/models/attention_processor.py | 142 +++--------------- .../pipelines/pag/pipeline_pag_sana.py | 23 +-- src/diffusers/pipelines/sana/pipeline_sana.py | 12 +- 3 files changed, 35 insertions(+), 142 deletions(-) diff --git a/src/diffusers/models/attention_processor.py b/src/diffusers/models/attention_processor.py index 3336e228e499..b9add82b8434 100644 --- a/src/diffusers/models/attention_processor.py +++ b/src/diffusers/models/attention_processor.py @@ -5410,95 +5410,45 @@ def __call__( hidden_states: torch.Tensor, encoder_hidden_states: Optional[torch.Tensor] = None, attention_mask: Optional[torch.Tensor] = None, - temb: Optional[torch.Tensor] = None, - *args, - **kwargs, ) -> torch.Tensor: - if len(args) > 0 or kwargs.get("scale", None) is not None: - deprecation_message = "The `scale` argument is deprecated and will be ignored. Please remove it, as passing it will raise an error in the future. `scale` should directly be passed while calling the underlying pipeline component i.e., via `cross_attention_kwargs`." - deprecate("scale", "1.0.0", deprecation_message) - - residual = hidden_states - if attn.spatial_norm is not None: - hidden_states = attn.spatial_norm(hidden_states, temb) - - input_ndim = hidden_states.ndim - - if input_ndim == 4: - batch_size, channel, height, width = hidden_states.shape - hidden_states = hidden_states.view(batch_size, channel, height * width).transpose(1, 2) + original_dtype = hidden_states.dtype - # chunk hidden_states_uncond, hidden_states_org, hidden_states_ptb = hidden_states.chunk(3) hidden_states_org = torch.cat([hidden_states_uncond, hidden_states_org]) - # original path - batch_size, sequence_length, _ = ( - hidden_states_org.shape if encoder_hidden_states is None else encoder_hidden_states.shape - ) - query = attn.to_q(hidden_states_org) key = attn.to_k(hidden_states_org) value = attn.to_v(hidden_states_org) - inner_dim = key.shape[-1] - head_dim = inner_dim // attn.heads - - dtype = query.dtype - - query = query.transpose(-1, -2).reshape(batch_size, attn.heads, head_dim, -1) - key = key.transpose(-1, -2).reshape(batch_size, attn.heads, head_dim, -1).transpose(-1, -2) - value = value.transpose(-1, -2).reshape(batch_size, attn.heads, head_dim, -1) + query = query.transpose(1, 2).unflatten(1, (attn.heads, -1)) + key = key.transpose(1, 2).unflatten(1, (attn.heads, -1)).transpose(2, 3) + value = value.transpose(1, 2).unflatten(1, (attn.heads, -1)) - query = self.kernel_func(query) # B, h, h_d, N + query = self.kernel_func(query) key = self.kernel_func(key) - # need torch.float query, key, value = query.float(), key.float(), value.float() value = F.pad(value, (0, 0, 0, 1), mode="constant", value=self.pad_val) - vk = torch.matmul(value, key) - hidden_states_org = torch.matmul(vk, query) + scores = torch.matmul(value, key) + hidden_states_org = torch.matmul(scores, query) - if hidden_states_org.dtype in [torch.float16, torch.bfloat16]: - hidden_states_org = hidden_states_org.float() hidden_states_org = hidden_states_org[:, :, :-1] / (hidden_states_org[:, :, -1:] + self.eps) + hidden_states_org = hidden_states_org.flatten(1, 2).transpose(1, 2) + hidden_states_org = hidden_states_org.to(original_dtype) - hidden_states_org = hidden_states_org.view(batch_size, attn.heads * head_dim, -1).permute(0, 2, 1) - hidden_states_org = hidden_states_org.to(dtype) - - # linear proj hidden_states_org = attn.to_out[0](hidden_states_org) - # dropout hidden_states_org = attn.to_out[1](hidden_states_org) - if input_ndim == 4: - hidden_states_org = hidden_states_org.transpose(-1, -2).reshape(batch_size, channel, height, width) - # perturbed path (identity attention) - batch_size, sequence_length, _ = hidden_states_ptb.shape + hidden_states_ptb = attn.to_v(hidden_states_ptb).to(original_dtype) - value = attn.to_v(hidden_states_ptb) - hidden_states_ptb = value - hidden_states_ptb = hidden_states_ptb.to(dtype) - - # linear proj hidden_states_ptb = attn.to_out[0](hidden_states_ptb) - # dropout hidden_states_ptb = attn.to_out[1](hidden_states_ptb) - if input_ndim == 4: - hidden_states_ptb = hidden_states_ptb.transpose(-1, -2).reshape(batch_size, channel, height, width) - - # cat hidden_states = torch.cat([hidden_states_org, hidden_states_ptb]) - if attn.residual_connection: - hidden_states = hidden_states + residual - - hidden_states = hidden_states / attn.rescale_output_factor - - if hidden_states.dtype == torch.float16: + if original_dtype == torch.float16: hidden_states = hidden_states.clip(-65504, 65504) return hidden_states @@ -5520,93 +5470,47 @@ def __call__( hidden_states: torch.Tensor, encoder_hidden_states: Optional[torch.Tensor] = None, attention_mask: Optional[torch.Tensor] = None, - temb: Optional[torch.Tensor] = None, - *args, - **kwargs, ) -> torch.Tensor: - if len(args) > 0 or kwargs.get("scale", None) is not None: - deprecation_message = "The `scale` argument is deprecated and will be ignored. Please remove it, as passing it will raise an error in the future. `scale` should directly be passed while calling the underlying pipeline component i.e., via `cross_attention_kwargs`." - deprecate("scale", "1.0.0", deprecation_message) - - residual = hidden_states - if attn.spatial_norm is not None: - hidden_states = attn.spatial_norm(hidden_states, temb) - - input_ndim = hidden_states.ndim - - if input_ndim == 4: - batch_size, channel, height, width = hidden_states.shape - hidden_states = hidden_states.view(batch_size, channel, height * width).transpose(1, 2) + original_dtype = hidden_states.dtype - # chunk hidden_states_org, hidden_states_ptb = hidden_states.chunk(2) - # original path - batch_size, sequence_length, _ = ( - hidden_states_org.shape if encoder_hidden_states is None else encoder_hidden_states.shape - ) - query = attn.to_q(hidden_states_org) key = attn.to_k(hidden_states_org) value = attn.to_v(hidden_states_org) - inner_dim = key.shape[-1] - head_dim = inner_dim // attn.heads - - dtype = query.dtype - - query = query.transpose(-1, -2).reshape(batch_size, attn.heads, head_dim, -1) - key = key.transpose(-1, -2).reshape(batch_size, attn.heads, head_dim, -1).transpose(-1, -2) - value = value.transpose(-1, -2).reshape(batch_size, attn.heads, head_dim, -1) + query = query.transpose(1, 2).unflatten(1, (attn.heads, -1)) + key = key.transpose(1, 2).unflatten(1, (attn.heads, -1)).transpose(2, 3) + value = value.transpose(1, 2).unflatten(1, (attn.heads, -1)) - query = self.kernel_func(query) # B, h, h_d, N + query = self.kernel_func(query) key = self.kernel_func(key) - # need torch.float query, key, value = query.float(), key.float(), value.float() value = F.pad(value, (0, 0, 0, 1), mode="constant", value=self.pad_val) - vk = torch.matmul(value, key) - hidden_states_org = torch.matmul(vk, query) + scores = torch.matmul(value, key) + hidden_states_org = torch.matmul(scores, query) if hidden_states_org.dtype in [torch.float16, torch.bfloat16]: hidden_states_org = hidden_states_org.float() - hidden_states_org = hidden_states_org[:, :, :-1] / (hidden_states_org[:, :, -1:] + self.eps) - hidden_states_org = hidden_states_org.view(batch_size, attn.heads * head_dim, -1).permute(0, 2, 1) - hidden_states_org = hidden_states_org.to(dtype) + hidden_states_org = hidden_states_org[:, :, :-1] / (hidden_states_org[:, :, -1:] + self.eps) + hidden_states_org = hidden_states_org.flatten(1, 2).transpose(1, 2) + hidden_states_org = hidden_states_org.to(original_dtype) - # linear proj hidden_states_org = attn.to_out[0](hidden_states_org) - # dropout hidden_states_org = attn.to_out[1](hidden_states_org) - if input_ndim == 4: - hidden_states_org = hidden_states_org.transpose(-1, -2).reshape(batch_size, channel, height, width) - # perturbed path (identity attention) - batch_size, sequence_length, _ = hidden_states_ptb.shape + hidden_states_ptb = attn.to_v(hidden_states_ptb).to(original_dtype) - hidden_states_ptb = attn.to_v(hidden_states_ptb) - hidden_states_ptb = hidden_states_ptb.to(dtype) - - # linear proj hidden_states_ptb = attn.to_out[0](hidden_states_ptb) - # dropout hidden_states_ptb = attn.to_out[1](hidden_states_ptb) - if input_ndim == 4: - hidden_states_ptb = hidden_states_ptb.transpose(-1, -2).reshape(batch_size, channel, height, width) - - # cat hidden_states = torch.cat([hidden_states_org, hidden_states_ptb]) - if attn.residual_connection: - hidden_states = hidden_states + residual - - hidden_states = hidden_states / attn.rescale_output_factor - - if hidden_states.dtype == torch.float16: + if original_dtype == torch.float16: hidden_states = hidden_states.clip(-65504, 65504) return hidden_states diff --git a/src/diffusers/pipelines/pag/pipeline_pag_sana.py b/src/diffusers/pipelines/pag/pipeline_pag_sana.py index b141806cd3aa..91055c26a690 100644 --- a/src/diffusers/pipelines/pag/pipeline_pag_sana.py +++ b/src/diffusers/pipelines/pag/pipeline_pag_sana.py @@ -142,7 +142,7 @@ def __init__( vae: AutoencoderDC, transformer: SanaTransformer2DModel, scheduler: FlowDPMSolverMultistepScheduler, - pag_applied_layers: Union[str, List[str]] = "transformer_blocks.8", + pag_applied_layers: Union[str, List[str]] = "transformer_blocks.0", ): super().__init__() @@ -511,8 +511,11 @@ def _clean_caption(self, caption): return caption.strip() - # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.prepare_latents + # Copied from diffusers.pipelines.sana.pipeline_sana.SanaPipeline.prepare_latents def prepare_latents(self, batch_size, num_channels_latents, height, width, dtype, device, generator, latents=None): + if latents is not None: + return latents.to(device=device, dtype=dtype) + shape = ( batch_size, num_channels_latents, @@ -525,13 +528,7 @@ def prepare_latents(self, batch_size, num_channels_latents, height, width, dtype f" size of {batch_size}. Make sure the batch size matches the length of the generators." ) - if latents is None: - latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype) - else: - latents = latents.to(device) - - # scale the initial noise by the standard deviation required by the scheduler - latents = latents * self.scheduler.init_noise_sigma + latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype) return latents @property @@ -561,8 +558,8 @@ def __call__( sigmas: List[float] = None, guidance_scale: float = 4.5, num_images_per_prompt: Optional[int] = 1, - height: Optional[int] = None, - width: Optional[int] = None, + height: int = 1024, + width: int = 1024, eta: float = 0.0, generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None, latents: Optional[torch.Tensor] = None, @@ -771,9 +768,6 @@ def __call__( # 6. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta) - # 6.1 Prepare micro-conditions. - added_cond_kwargs = {"resolution": None, "aspect_ratio": None} - # 7. Denoising loop num_warmup_steps = max(len(timesteps) - num_inference_steps * self.scheduler.order, 0) self._num_timesteps = len(timesteps) @@ -796,7 +790,6 @@ def __call__( encoder_hidden_states=prompt_embeds, encoder_attention_mask=prompt_attention_mask, timestep=timestep, - added_cond_kwargs=added_cond_kwargs, return_dict=False, )[0] noise_pred = noise_pred.float() diff --git a/src/diffusers/pipelines/sana/pipeline_sana.py b/src/diffusers/pipelines/sana/pipeline_sana.py index 55b4c4835b7a..3276feb5b71b 100644 --- a/src/diffusers/pipelines/sana/pipeline_sana.py +++ b/src/diffusers/pipelines/sana/pipeline_sana.py @@ -504,8 +504,10 @@ def _clean_caption(self, caption): return caption.strip() - # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.prepare_latents def prepare_latents(self, batch_size, num_channels_latents, height, width, dtype, device, generator, latents=None): + if latents is not None: + return latents.to(device=device, dtype=dtype) + shape = ( batch_size, num_channels_latents, @@ -518,13 +520,7 @@ def prepare_latents(self, batch_size, num_channels_latents, height, width, dtype f" size of {batch_size}. Make sure the batch size matches the length of the generators." ) - if latents is None: - latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype) - else: - latents = latents.to(device) - - # scale the initial noise by the standard deviation required by the scheduler - latents = latents * self.scheduler.init_noise_sigma + latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype) return latents @property From 2841ad282e63c6ec1f9d644417686f456e3507f5 Mon Sep 17 00:00:00 2001 From: Aryan Date: Thu, 12 Dec 2024 10:59:11 +0100 Subject: [PATCH 119/141] remove sana pag conversion script --- scripts/convert_sana_pag_to_diffusers.py | 310 ----------------------- 1 file changed, 310 deletions(-) delete mode 100644 scripts/convert_sana_pag_to_diffusers.py diff --git a/scripts/convert_sana_pag_to_diffusers.py b/scripts/convert_sana_pag_to_diffusers.py deleted file mode 100644 index ec6d4d692f0f..000000000000 --- a/scripts/convert_sana_pag_to_diffusers.py +++ /dev/null @@ -1,310 +0,0 @@ -#!/usr/bin/env python -from __future__ import annotations - -import argparse -import os -from contextlib import nullcontext - -import torch -from accelerate import init_empty_weights -from huggingface_hub import hf_hub_download, snapshot_download -from termcolor import colored -from transformers import AutoModelForCausalLM, AutoTokenizer - -from diffusers import ( - AutoencoderDC, - DPMSolverMultistepScheduler, - FlowMatchEulerDiscreteScheduler, - SanaPAGPipeline, - SanaTransformer2DModel, -) -from diffusers.models.modeling_utils import load_model_dict_into_meta -from diffusers.utils.import_utils import is_accelerate_available - - -CTX = init_empty_weights if is_accelerate_available else nullcontext - -ckpt_ids = [ - "Efficient-Large-Model/Sana_1600M_1024px_MultiLing", - "Efficient-Large-Model/Sana_1600M_512px_MultiLing", - "Efficient-Large-Model/Sana_1600M_1024px", - "Efficient-Large-Model/Sana_1600M_512px", - "Efficient-Large-Model/Sana_600M_1024px", - "Efficient-Large-Model/Sana_600M_512px", -] -# https://github.com/NVlabs/Sana/blob/main/scripts/inference.py - - -def main(args): - ckpt_id = ckpt_ids[0] - cache_dir_path = os.path.expanduser("~/.cache/huggingface/hub") - if args.orig_ckpt_path is None: - snapshot_download( - repo_id=ckpt_id, - cache_dir=cache_dir_path, - repo_type="model", - ) - file_path = hf_hub_download( - repo_id=ckpt_id, - filename=f"checkpoints/{ckpt_id.split('/')[-1]}.pth", - cache_dir=cache_dir_path, - repo_type="model", - ) - else: - file_path = args.orig_ckpt_path - all_state_dict = torch.load(file_path, weights_only=True) - state_dict = all_state_dict.pop("state_dict") - converted_state_dict = {} - - # Patch embeddings. - converted_state_dict["pos_embed.proj.weight"] = state_dict.pop("x_embedder.proj.weight") - converted_state_dict["pos_embed.proj.bias"] = state_dict.pop("x_embedder.proj.bias") - - # Caption projection. - converted_state_dict["caption_projection.linear_1.weight"] = state_dict.pop("y_embedder.y_proj.fc1.weight") - converted_state_dict["caption_projection.linear_1.bias"] = state_dict.pop("y_embedder.y_proj.fc1.bias") - converted_state_dict["caption_projection.linear_2.weight"] = state_dict.pop("y_embedder.y_proj.fc2.weight") - converted_state_dict["caption_projection.linear_2.bias"] = state_dict.pop("y_embedder.y_proj.fc2.bias") - - # AdaLN-single LN - converted_state_dict["adaln_single.emb.timestep_embedder.linear_1.weight"] = state_dict.pop( - "t_embedder.mlp.0.weight" - ) - converted_state_dict["adaln_single.emb.timestep_embedder.linear_1.bias"] = state_dict.pop("t_embedder.mlp.0.bias") - converted_state_dict["adaln_single.emb.timestep_embedder.linear_2.weight"] = state_dict.pop( - "t_embedder.mlp.2.weight" - ) - converted_state_dict["adaln_single.emb.timestep_embedder.linear_2.bias"] = state_dict.pop("t_embedder.mlp.2.bias") - - # Shared norm. - converted_state_dict["adaln_single.linear.weight"] = state_dict.pop("t_block.1.weight") - converted_state_dict["adaln_single.linear.bias"] = state_dict.pop("t_block.1.bias") - - # y norm - converted_state_dict["caption_norm.weight"] = state_dict.pop("attention_y_norm.weight") - - flow_shift = 3.0 - if args.model_type == "SanaMS_1600M_P1_D20": - layer_num = 20 - elif args.model_type == "SanaMS_600M_P1_D28": - layer_num = 28 - else: - raise ValueError(f"{args.model_type} is not supported.") - - for depth in range(layer_num): - # Transformer blocks. - converted_state_dict[f"transformer_blocks.{depth}.scale_shift_table"] = state_dict.pop( - f"blocks.{depth}.scale_shift_table" - ) - # Linear Attention is all you need 🤘 - - # Self attention. - q, k, v = torch.chunk(state_dict.pop(f"blocks.{depth}.attn.qkv.weight"), 3, dim=0) - converted_state_dict[f"transformer_blocks.{depth}.attn1.to_q.weight"] = q - converted_state_dict[f"transformer_blocks.{depth}.attn1.to_k.weight"] = k - converted_state_dict[f"transformer_blocks.{depth}.attn1.to_v.weight"] = v - # Projection. - converted_state_dict[f"transformer_blocks.{depth}.attn1.to_out.0.weight"] = state_dict.pop( - f"blocks.{depth}.attn.proj.weight" - ) - converted_state_dict[f"transformer_blocks.{depth}.attn1.to_out.0.bias"] = state_dict.pop( - f"blocks.{depth}.attn.proj.bias" - ) - - # Feed-forward. - converted_state_dict[f"transformer_blocks.{depth}.ff.conv_inverted.weight"] = state_dict.pop( - f"blocks.{depth}.mlp.inverted_conv.conv.weight" - ) - converted_state_dict[f"transformer_blocks.{depth}.ff.conv_inverted.bias"] = state_dict.pop( - f"blocks.{depth}.mlp.inverted_conv.conv.bias" - ) - converted_state_dict[f"transformer_blocks.{depth}.ff.conv_depth.weight"] = state_dict.pop( - f"blocks.{depth}.mlp.depth_conv.conv.weight" - ) - converted_state_dict[f"transformer_blocks.{depth}.ff.conv_depth.bias"] = state_dict.pop( - f"blocks.{depth}.mlp.depth_conv.conv.bias" - ) - converted_state_dict[f"transformer_blocks.{depth}.ff.conv_point.weight"] = state_dict.pop( - f"blocks.{depth}.mlp.point_conv.conv.weight" - ) - - # Cross-attention. - q = state_dict.pop(f"blocks.{depth}.cross_attn.q_linear.weight") - q_bias = state_dict.pop(f"blocks.{depth}.cross_attn.q_linear.bias") - k, v = torch.chunk(state_dict.pop(f"blocks.{depth}.cross_attn.kv_linear.weight"), 2, dim=0) - k_bias, v_bias = torch.chunk(state_dict.pop(f"blocks.{depth}.cross_attn.kv_linear.bias"), 2, dim=0) - - converted_state_dict[f"transformer_blocks.{depth}.attn2.to_q.weight"] = q - converted_state_dict[f"transformer_blocks.{depth}.attn2.to_q.bias"] = q_bias - converted_state_dict[f"transformer_blocks.{depth}.attn2.to_k.weight"] = k - converted_state_dict[f"transformer_blocks.{depth}.attn2.to_k.bias"] = k_bias - converted_state_dict[f"transformer_blocks.{depth}.attn2.to_v.weight"] = v - converted_state_dict[f"transformer_blocks.{depth}.attn2.to_v.bias"] = v_bias - - converted_state_dict[f"transformer_blocks.{depth}.attn2.to_out.0.weight"] = state_dict.pop( - f"blocks.{depth}.cross_attn.proj.weight" - ) - converted_state_dict[f"transformer_blocks.{depth}.attn2.to_out.0.bias"] = state_dict.pop( - f"blocks.{depth}.cross_attn.proj.bias" - ) - - # Final block. - converted_state_dict["proj_out.weight"] = state_dict.pop("final_layer.linear.weight") - converted_state_dict["proj_out.bias"] = state_dict.pop("final_layer.linear.bias") - converted_state_dict["scale_shift_table"] = state_dict.pop("final_layer.scale_shift_table") - - # Transformer - with CTX(): - transformer = SanaTransformer2DModel( - num_attention_heads=model_kwargs[args.model_type]["num_attention_heads"], - attention_head_dim=model_kwargs[args.model_type]["attention_head_dim"], - num_cross_attention_heads=model_kwargs[args.model_type]["num_cross_attention_heads"], - cross_attention_head_dim=model_kwargs[args.model_type]["cross_attention_head_dim"], - in_channels=32, - out_channels=32, - num_layers=model_kwargs[args.model_type]["num_layers"], - cross_attention_dim=model_kwargs[args.model_type]["cross_attention_dim"], - attention_bias=False, - sample_size=32, - patch_size=1, - upcast_attention=False, - norm_type="ada_norm_single", - norm_elementwise_affine=False, - norm_eps=1e-6, - use_additional_conditions=False, - caption_channels=2304, - use_caption_norm=True, - caption_norm_scale_factor=0.1, - attention_type="default", - use_pe=False, - expand_ratio=2.5, - ) - if is_accelerate_available(): - load_model_dict_into_meta(transformer, converted_state_dict) - else: - transformer.load_state_dict(converted_state_dict, strict=True) - - try: - state_dict.pop("y_embedder.y_embedding") - state_dict.pop("pos_embed") - except KeyError: - print("y_embedder.y_embedding or pos_embed not found in the state_dict") - - assert len(state_dict) == 0, f"State dict is not empty, {state_dict.keys()}" - - num_model_params = sum(p.numel() for p in transformer.parameters()) - print(f"Total number of transformer parameters: {num_model_params}") - - if not args.save_full_pipeline: - print( - colored( - f"Only saving transformer model of {args.model_type}. " - f"Set --save_full_pipeline to save the whole SanaPAGPipeline", - "green", - attrs=["bold"], - ) - ) - transformer.to(weight_dtype).save_pretrained(os.path.join(args.dump_path, "transformer")) - else: - print(colored(f"Saving the whole SanaPAGPipeline containing {args.model_type}", "green", attrs=["bold"])) - # VAE - ae = AutoencoderDC.from_pretrained( - "mit-han-lab/dc-ae-f32c32-sana-1.0-diffusers", - torch_dtype=torch.bfloat16, - ).to(device) - - # Text Encoder - text_encoder_model_path = "google/gemma-2-2b-it" - tokenizer = AutoTokenizer.from_pretrained(text_encoder_model_path) - tokenizer.padding_side = "right" - text_encoder = ( - AutoModelForCausalLM.from_pretrained(text_encoder_model_path, torch_dtype=torch.bfloat16) - .get_decoder() - .to(device) - ) - - # Scheduler - if args.scheduler_type == "flow-dpm_solver": - scheduler = DPMSolverMultistepScheduler( - flow_shift=flow_shift, - use_flow_sigmas=True, - prediction_type="flow_prediction", - ) - elif args.scheduler_type == "flow-euler": - scheduler = FlowMatchEulerDiscreteScheduler(shift=flow_shift) - else: - raise ValueError(f"Scheduler type {args.scheduler_type} is not supported") - - # transformer - transformer.to(device).to(weight_dtype) - - pipe = SanaPAGPipeline( - tokenizer=tokenizer, - text_encoder=text_encoder, - transformer=transformer, - vae=ae, - scheduler=scheduler, - pag_applied_layers="blocks.8", - ) - - image = pipe( - "a dog", - height=1024, - width=1024, - guidance_scale=5.0, - pag_scale=2.0, - )[0] - - image[0].save("sana_pag.png") - - pipe.save_pretrained(args.dump_path) - - -if __name__ == "__main__": - parser = argparse.ArgumentParser() - - parser.add_argument( - "--orig_ckpt_path", default=None, type=str, required=False, help="Path to the checkpoint to convert." - ) - parser.add_argument( - "--image_size", - default=1024, - type=int, - choices=[512, 1024], - required=False, - help="Image size of pretrained model, 512 or 1024.", - ) - parser.add_argument( - "--model_type", default="SanaMS_1600M_P1_D20", type=str, choices=["SanaMS_1600M_P1_D20", "SanaMS_600M_P1_D28"] - ) - parser.add_argument( - "--scheduler_type", default="flow-dpm_solver", type=str, choices=["flow-dpm_solver", "flow-euler"] - ) - parser.add_argument("--dump_path", default=None, type=str, required=True, help="Path to the output pipeline.") - parser.add_argument("--save_full_pipeline", action="store_true", help="save all the pipelien elemets in one.") - - args = parser.parse_args() - - model_kwargs = { - "SanaMS_1600M_P1_D20": { - "num_attention_heads": 70, - "attention_head_dim": 32, - "num_cross_attention_heads": 20, - "cross_attention_head_dim": 112, - "cross_attention_dim": 2240, - "num_layers": 20, - }, - "SanaMS_600M_P1_D28": { - "num_attention_heads": 36, - "attention_head_dim": 32, - "num_cross_attention_heads": 16, - "cross_attention_head_dim": 72, - "cross_attention_dim": 1152, - "num_layers": 28, - }, - } - - device = "cuda" if torch.cuda.is_available() else "cpu" - weight_dtype = torch.float16 - - main(args) From 2a363a38b6deafc5ddecee603dc8ef293f5b6999 Mon Sep 17 00:00:00 2001 From: Aryan Date: Thu, 12 Dec 2024 11:01:25 +0100 Subject: [PATCH 120/141] handle weight casting in conversion script --- scripts/convert_sana_to_diffusers.py | 1 + 1 file changed, 1 insertion(+) diff --git a/scripts/convert_sana_to_diffusers.py b/scripts/convert_sana_to_diffusers.py index d93ee38ad0cd..0436713d8955 100644 --- a/scripts/convert_sana_to_diffusers.py +++ b/scripts/convert_sana_to_diffusers.py @@ -200,6 +200,7 @@ def main(args): attrs=["bold"], ) ) + transformer = transformer.to(weight_dtype) transformer.save_pretrained( os.path.join(args.dump_path, "transformer"), safe_serialization=True, max_shard_size="5GB", variant=variant ) From b0d5cf69fb36e647c4ce9a6600c3e5ec20766041 Mon Sep 17 00:00:00 2001 From: Aryan Date: Thu, 12 Dec 2024 15:24:02 +0100 Subject: [PATCH 121/141] update conversion script --- scripts/convert_sana_to_diffusers.py | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/scripts/convert_sana_to_diffusers.py b/scripts/convert_sana_to_diffusers.py index 0436713d8955..0900fa61f8f9 100644 --- a/scripts/convert_sana_to_diffusers.py +++ b/scripts/convert_sana_to_diffusers.py @@ -207,15 +207,13 @@ def main(args): else: print(colored(f"Saving the whole SanaPipeline containing {args.model_type}", "green", attrs=["bold"])) # VAE - ae = AutoencoderDC.from_pretrained( - "mit-han-lab/dc-ae-f32c32-sana-1.0-diffusers", - ) + ae = AutoencoderDC.from_pretrained("mit-han-lab/dc-ae-f32c32-sana-1.0-diffusers", torch_dtype=torch.float32) # Text Encoder text_encoder_model_path = "google/gemma-2-2b-it" tokenizer = AutoTokenizer.from_pretrained(text_encoder_model_path) tokenizer.padding_side = "right" - text_encoder = AutoModelForCausalLM.from_pretrained(text_encoder_model_path).get_decoder() + text_encoder = AutoModelForCausalLM.from_pretrained(text_encoder_model_path, torch_dtype=torch.bfloat16).get_decoder() # Scheduler if args.scheduler_type == "flow-dpm_solver": From 34c5880e6788d396d629e3ab7236d4999d384b88 Mon Sep 17 00:00:00 2001 From: junsong Date: Thu, 12 Dec 2024 04:32:03 -0800 Subject: [PATCH 122/141] add a processor --- src/diffusers/models/attention_processor.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/diffusers/models/attention_processor.py b/src/diffusers/models/attention_processor.py index b17866564e47..036953bd3819 100644 --- a/src/diffusers/models/attention_processor.py +++ b/src/diffusers/models/attention_processor.py @@ -5668,10 +5668,11 @@ def __call__( SlicedAttnProcessor, SlicedAttnAddedKVProcessor, SanaLinearAttnProcessor2_0, + PAGCFGSanaLinearAttnProcessor2_0, + PAGIdentitySanaLinearAttnProcessor2_0, SanaMultiscaleLinearAttention, SanaMultiscaleAttnProcessor2_0, SanaMultiscaleAttentionProjection, - PAGCFGSanaLinearAttnProcessor2_0, IPAdapterAttnProcessor, IPAdapterAttnProcessor2_0, IPAdapterXFormersAttnProcessor, From 47cc04638b15ab6c0c3ead61529effa9f862ebcd Mon Sep 17 00:00:00 2001 From: junsong Date: Thu, 12 Dec 2024 06:23:44 -0800 Subject: [PATCH 123/141] 1. add bf16 pth file path; 2. add complex human instruct in pipeline; --- scripts/convert_sana_to_diffusers.py | 8 +++-- src/diffusers/pipelines/sana/pipeline_sana.py | 31 +++++++++++++++++-- 2 files changed, 34 insertions(+), 5 deletions(-) diff --git a/scripts/convert_sana_to_diffusers.py b/scripts/convert_sana_to_diffusers.py index 0900fa61f8f9..84397ff4a11d 100644 --- a/scripts/convert_sana_to_diffusers.py +++ b/scripts/convert_sana_to_diffusers.py @@ -26,6 +26,7 @@ ckpt_ids = [ "Efficient-Large-Model/Sana_1600M_1024px_MultiLing", + "Efficient-Large-Model/Sana_1600M_1024px_BF16", "Efficient-Large-Model/Sana_1600M_512px_MultiLing", "Efficient-Large-Model/Sana_1600M_1024px", "Efficient-Large-Model/Sana_1600M_512px", @@ -39,7 +40,7 @@ def main(args): ckpt_id = ckpt_ids[0] cache_dir_path = os.path.expanduser("~/.cache/huggingface/hub") - if args.orig_ckpt_path is None: + if args.orig_ckpt_path is None or args.orig_ckpt_path in ckpt_ids: snapshot_download( repo_id=ckpt_id, cache_dir=cache_dir_path, @@ -169,7 +170,7 @@ def main(args): caption_channels=2304, mlp_ratio=2.5, attention_bias=False, - sample_size=32, + sample_size=args.image_size // 32, patch_size=1, norm_elementwise_affine=False, norm_eps=1e-6, @@ -191,6 +192,8 @@ def main(args): num_model_params = sum(p.numel() for p in transformer.parameters()) print(f"Total number of transformer parameters: {num_model_params}") + transformer = transformer.to(weight_dtype) + if not args.save_full_pipeline: print( colored( @@ -200,7 +203,6 @@ def main(args): attrs=["bold"], ) ) - transformer = transformer.to(weight_dtype) transformer.save_pretrained( os.path.join(args.dump_path, "transformer"), safe_serialization=True, max_shard_size="5GB", variant=variant ) diff --git a/src/diffusers/pipelines/sana/pipeline_sana.py b/src/diffusers/pipelines/sana/pipeline_sana.py index 3276feb5b71b..206e67c1c069 100644 --- a/src/diffusers/pipelines/sana/pipeline_sana.py +++ b/src/diffusers/pipelines/sana/pipeline_sana.py @@ -166,6 +166,7 @@ def encode_prompt( negative_prompt_attention_mask: Optional[torch.Tensor] = None, clean_caption: bool = False, max_sequence_length: int = 300, + complex_huamen_instruction: list[str] = [], ): r""" Encodes the prompt into text encoder hidden states. @@ -192,6 +193,8 @@ def encode_prompt( clean_caption (`bool`, defaults to `False`): If `True`, the function will preprocess and clean the provided caption before encoding. max_sequence_length (`int`, defaults to 300): Maximum sequence length to use for the prompt. + use_complex_huamen_instruction (`list[str]`, defaults to `complex_huamen_instruction`): + If `complex_huamen_instruction` is not empty, the function will use the complex Huamen instruction for the prompt. """ if device is None: @@ -206,13 +209,24 @@ def encode_prompt( # See Section 3.1. of the paper. max_length = max_sequence_length + select_index = [0] + list(range(-max_length + 1, 0)) if prompt_embeds is None: prompt = self._text_preprocessing(prompt, clean_caption=clean_caption) + + # prepare complex huamen instruction + if not complex_huamen_instruction: + max_length_all = max_length + else: + chi_prompt = "\n".join(complex_huamen_instruction) + prompt = [chi_prompt + p for p in prompt] + num_chi_prompt_tokens = len(self.tokenizer.encode(chi_prompt)) + max_length_all = num_chi_prompt_tokens + max_length - 2 + text_inputs = self.tokenizer( prompt, padding="max_length", - max_length=max_length, + max_length=max_length_all, truncation=True, add_special_tokens=True, return_tensors="pt", @@ -223,7 +237,8 @@ def encode_prompt( prompt_attention_mask = prompt_attention_mask.to(device) prompt_embeds = self.text_encoder(text_input_ids.to(device), attention_mask=prompt_attention_mask) - prompt_embeds = prompt_embeds[0] + prompt_embeds = prompt_embeds[0][:, select_index] + prompt_attention_mask = prompt_attention_mask[:, select_index] if self.transformer is not None: dtype = self.transformer.dtype @@ -566,6 +581,16 @@ def __call__( callback_on_step_end: Optional[Callable[[int, int, Dict], None]] = None, callback_on_step_end_tensor_inputs: List[str] = ["latents"], max_sequence_length: int = 300, + complex_human_attention: list[str] = [ + 'Given a user prompt, generate an "Enhanced prompt" that provides detailed visual descriptions suitable for image generation. Evaluate the level of detail in the user prompt:', + '- If the prompt is simple, focus on adding specifics about colors, shapes, sizes, textures, and spatial relationships to create vivid and concrete scenes.', + '- If the prompt is already detailed, refine and enhance the existing details slightly without overcomplicating.', + 'Here are examples of how to transform or refine prompts:', + '- User Prompt: A cat sleeping -> Enhanced: A small, fluffy white cat curled up in a round shape, sleeping peacefully on a warm sunny windowsill, surrounded by pots of blooming red flowers.', + '- User Prompt: A busy city street -> Enhanced: A bustling city street scene at dusk, featuring glowing street lamps, a diverse crowd of people in colorful clothing, and a double-decker bus passing by towering glass skyscrapers.', + 'Please generate only the enhanced description for the prompt below and avoid including any additional commentary or evaluations:', + 'User Prompt: ' + ], ) -> Union[SanaPipelineOutput, Tuple]: """ Function invoked when calling the pipeline for generation. @@ -644,6 +669,8 @@ def __call__( `._callback_tensor_inputs` attribute of your pipeline class. max_sequence_length (`int` defaults to `300`): Maximum sequence length to use with the `prompt`. + complex_human_attention (`list[str]`, *optional*): + Instructions for complex human attention: https://github.com/NVlabs/Sana/blob/main/configs/sana_app_config/Sana_1600M_app.yaml#L55. Examples: From de2c5f496ead33843b70a0be97c07fe1ad410837 Mon Sep 17 00:00:00 2001 From: Aryan Date: Thu, 12 Dec 2024 15:42:38 +0100 Subject: [PATCH 124/141] fix fast \tests --- .../pipelines/pag/pipeline_pag_sana.py | 1 - src/diffusers/pipelines/sana/pipeline_sana.py | 1 - tests/pipelines/pag/test_pag_sana.py | 337 ++++++++++++++++++ tests/pipelines/sana/test_sana.py | 13 + 4 files changed, 350 insertions(+), 2 deletions(-) create mode 100644 tests/pipelines/pag/test_pag_sana.py diff --git a/src/diffusers/pipelines/pag/pipeline_pag_sana.py b/src/diffusers/pipelines/pag/pipeline_pag_sana.py index 91055c26a690..983fea63fc99 100644 --- a/src/diffusers/pipelines/pag/pipeline_pag_sana.py +++ b/src/diffusers/pipelines/pag/pipeline_pag_sana.py @@ -131,7 +131,6 @@ class SanaPAGPipeline(DiffusionPipeline, PAGMixin): bad_punct_regex = re.compile(r"[" + "#®•©™&@·º½¾¿¡§~" + r"\)" + r"\(" + r"\]" + r"\[" + r"\}" + r"\{" + r"\|" + "\\" + r"\/" + r"\*" + r"]{1,}") # fmt: on - _optional_components = ["tokenizer", "text_encoder"] model_cpu_offload_seq = "text_encoder->transformer->vae" _callback_tensor_inputs = ["latents", "prompt_embeds", "negative_prompt_embeds"] diff --git a/src/diffusers/pipelines/sana/pipeline_sana.py b/src/diffusers/pipelines/sana/pipeline_sana.py index 206e67c1c069..a1b434dbbed0 100644 --- a/src/diffusers/pipelines/sana/pipeline_sana.py +++ b/src/diffusers/pipelines/sana/pipeline_sana.py @@ -128,7 +128,6 @@ class SanaPipeline(DiffusionPipeline): bad_punct_regex = re.compile(r"[" + "#®•©™&@·º½¾¿¡§~" + r"\)" + r"\(" + r"\]" + r"\[" + r"\}" + r"\{" + r"\|" + "\\" + r"\/" + r"\*" + r"]{1,}") # fmt: on - _optional_components = ["tokenizer", "text_encoder"] model_cpu_offload_seq = "text_encoder->transformer->vae" _callback_tensor_inputs = ["latents", "prompt_embeds", "negative_prompt_embeds"] diff --git a/tests/pipelines/pag/test_pag_sana.py b/tests/pipelines/pag/test_pag_sana.py new file mode 100644 index 000000000000..ebada6b009b2 --- /dev/null +++ b/tests/pipelines/pag/test_pag_sana.py @@ -0,0 +1,337 @@ +# Copyright 2024 The HuggingFace Team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import inspect +import unittest + +import numpy as np +import torch +from transformers import Gemma2Config, Gemma2ForCausalLM, GemmaTokenizer + +from diffusers import ( + AutoencoderDC, + FlowMatchEulerDiscreteScheduler, + SanaPAGPipeline, + SanaPipeline, + SanaTransformer2DModel, +) +from diffusers.utils.testing_utils import enable_full_determinism, torch_device + +from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS +from ..test_pipelines_common import PipelineTesterMixin, to_np + + +enable_full_determinism() + + +class SanaPAGPipelineFastTests(PipelineTesterMixin, unittest.TestCase): + pipeline_class = SanaPAGPipeline + params = TEXT_TO_IMAGE_PARAMS - {"cross_attention_kwargs"} + batch_params = TEXT_TO_IMAGE_BATCH_PARAMS + image_params = TEXT_TO_IMAGE_IMAGE_PARAMS + image_latents_params = TEXT_TO_IMAGE_IMAGE_PARAMS + required_optional_params = frozenset( + [ + "num_inference_steps", + "generator", + "latents", + "return_dict", + "callback_on_step_end", + "callback_on_step_end_tensor_inputs", + ] + ) + test_xformers_attention = False + + def get_dummy_components(self): + torch.manual_seed(0) + transformer = SanaTransformer2DModel( + patch_size=1, + in_channels=4, + out_channels=4, + num_layers=2, + num_attention_heads=2, + attention_head_dim=4, + num_cross_attention_heads=2, + cross_attention_head_dim=4, + cross_attention_dim=8, + caption_channels=8, + sample_size=32, + ) + + torch.manual_seed(0) + vae = AutoencoderDC( + in_channels=3, + latent_channels=4, + attention_head_dim=2, + encoder_block_types=( + "ResBlock", + "EfficientViTBlock", + ), + decoder_block_types=( + "ResBlock", + "EfficientViTBlock", + ), + encoder_block_out_channels=(8, 8), + decoder_block_out_channels=(8, 8), + encoder_qkv_multiscales=((), (5,)), + decoder_qkv_multiscales=((), (5,)), + encoder_layers_per_block=(1, 1), + decoder_layers_per_block=[1, 1], + downsample_block_type="conv", + upsample_block_type="interpolate", + decoder_norm_types="rms_norm", + decoder_act_fns="silu", + scaling_factor=0.41407, + ) + + torch.manual_seed(0) + scheduler = FlowMatchEulerDiscreteScheduler(shift=7.0) + + torch.manual_seed(0) + text_encoder_config = Gemma2Config( + head_dim=16, + hidden_size=32, + initializer_range=0.02, + intermediate_size=64, + max_position_embeddings=8192, + model_type="gemma2", + num_attention_heads=2, + num_hidden_layers=1, + num_key_value_heads=2, + vocab_size=8, + attn_implementation="eager", + ) + text_encoder = Gemma2ForCausalLM(text_encoder_config) + tokenizer = GemmaTokenizer.from_pretrained("hf-internal-testing/dummy-gemma") + + components = { + "transformer": transformer, + "vae": vae, + "scheduler": scheduler, + "text_encoder": text_encoder, + "tokenizer": tokenizer, + } + return components + + def get_dummy_inputs(self, device, seed=0): + if str(device).startswith("mps"): + generator = torch.manual_seed(seed) + else: + generator = torch.Generator(device=device).manual_seed(seed) + inputs = { + "prompt": "", + "negative_prompt": "", + "generator": generator, + "num_inference_steps": 2, + "guidance_scale": 6.0, + "pag_scale": 3.0, + "height": 32, + "width": 32, + "max_sequence_length": 16, + "output_type": "pt", + } + return inputs + + def test_inference(self): + device = "cpu" + + components = self.get_dummy_components() + pipe = self.pipeline_class(**components) + pipe.to(device) + pipe.set_progress_bar_config(disable=None) + + inputs = self.get_dummy_inputs(device) + image = pipe(**inputs)[0] + generated_image = image[0] + + self.assertEqual(generated_image.shape, (3, 32, 32)) + expected_image = torch.randn(3, 32, 32) + max_diff = np.abs(generated_image - expected_image).max() + self.assertLessEqual(max_diff, 1e10) + + def test_callback_inputs(self): + sig = inspect.signature(self.pipeline_class.__call__) + has_callback_tensor_inputs = "callback_on_step_end_tensor_inputs" in sig.parameters + has_callback_step_end = "callback_on_step_end" in sig.parameters + + if not (has_callback_tensor_inputs and has_callback_step_end): + return + + components = self.get_dummy_components() + pipe = self.pipeline_class(**components) + pipe = pipe.to(torch_device) + pipe.set_progress_bar_config(disable=None) + self.assertTrue( + hasattr(pipe, "_callback_tensor_inputs"), + f" {self.pipeline_class} should have `_callback_tensor_inputs` that defines a list of tensor variables its callback function can use as inputs", + ) + + def callback_inputs_subset(pipe, i, t, callback_kwargs): + # iterate over callback args + for tensor_name, tensor_value in callback_kwargs.items(): + # check that we're only passing in allowed tensor inputs + assert tensor_name in pipe._callback_tensor_inputs + + return callback_kwargs + + def callback_inputs_all(pipe, i, t, callback_kwargs): + for tensor_name in pipe._callback_tensor_inputs: + assert tensor_name in callback_kwargs + + # iterate over callback args + for tensor_name, tensor_value in callback_kwargs.items(): + # check that we're only passing in allowed tensor inputs + assert tensor_name in pipe._callback_tensor_inputs + + return callback_kwargs + + inputs = self.get_dummy_inputs(torch_device) + + # Test passing in a subset + inputs["callback_on_step_end"] = callback_inputs_subset + inputs["callback_on_step_end_tensor_inputs"] = ["latents"] + output = pipe(**inputs)[0] + + # Test passing in a everything + inputs["callback_on_step_end"] = callback_inputs_all + inputs["callback_on_step_end_tensor_inputs"] = pipe._callback_tensor_inputs + output = pipe(**inputs)[0] + + def callback_inputs_change_tensor(pipe, i, t, callback_kwargs): + is_last = i == (pipe.num_timesteps - 1) + if is_last: + callback_kwargs["latents"] = torch.zeros_like(callback_kwargs["latents"]) + return callback_kwargs + + inputs["callback_on_step_end"] = callback_inputs_change_tensor + inputs["callback_on_step_end_tensor_inputs"] = pipe._callback_tensor_inputs + output = pipe(**inputs)[0] + assert output.abs().sum() < 1e10 + + def test_inference_batch_single_identical(self): + self._test_inference_batch_single_identical(batch_size=3, expected_max_diff=1e-3) + + def test_attention_slicing_forward_pass( + self, test_max_difference=True, test_mean_pixel_difference=True, expected_max_diff=1e-3 + ): + if not self.test_attention_slicing: + return + + components = self.get_dummy_components() + pipe = self.pipeline_class(**components) + for component in pipe.components.values(): + if hasattr(component, "set_default_attn_processor"): + component.set_default_attn_processor() + pipe.to(torch_device) + pipe.set_progress_bar_config(disable=None) + + generator_device = "cpu" + inputs = self.get_dummy_inputs(generator_device) + output_without_slicing = pipe(**inputs)[0] + + pipe.enable_attention_slicing(slice_size=1) + inputs = self.get_dummy_inputs(generator_device) + output_with_slicing1 = pipe(**inputs)[0] + + pipe.enable_attention_slicing(slice_size=2) + inputs = self.get_dummy_inputs(generator_device) + output_with_slicing2 = pipe(**inputs)[0] + + if test_max_difference: + max_diff1 = np.abs(to_np(output_with_slicing1) - to_np(output_without_slicing)).max() + max_diff2 = np.abs(to_np(output_with_slicing2) - to_np(output_without_slicing)).max() + self.assertLess( + max(max_diff1, max_diff2), + expected_max_diff, + "Attention slicing should not affect the inference results", + ) + + def test_pag_disable_enable(self): + device = "cpu" # ensure determinism for the device-dependent torch.Generator + components = self.get_dummy_components() + + # base pipeline (expect same output when pag is disabled) + pipe_sd = SanaPipeline(**components) + pipe_sd = pipe_sd.to(device) + pipe_sd.set_progress_bar_config(disable=None) + + inputs = self.get_dummy_inputs(device) + del inputs["pag_scale"] + assert ( + "pag_scale" not in inspect.signature(pipe_sd.__call__).parameters + ), f"`pag_scale` should not be a call parameter of the base pipeline {pipe_sd.__class__.__name__}." + out = pipe_sd(**inputs).images[0, -3:, -3:, -1] + + components = self.get_dummy_components() + + # pag disabled with pag_scale=0.0 + pipe_pag = self.pipeline_class(**components) + pipe_pag = pipe_pag.to(device) + pipe_pag.set_progress_bar_config(disable=None) + + inputs = self.get_dummy_inputs(device) + inputs["pag_scale"] = 0.0 + out_pag_disabled = pipe_pag(**inputs).images[0, -3:, -3:, -1] + + assert np.abs(out.flatten() - out_pag_disabled.flatten()).max() < 1e-3 + + def test_pag_applied_layers(self): + device = "cpu" # ensure determinism for the device-dependent torch.Generator + components = self.get_dummy_components() + + # base pipeline + pipe = self.pipeline_class(**components) + pipe = pipe.to(device) + pipe.set_progress_bar_config(disable=None) + + all_self_attn_layers = [k for k in pipe.transformer.attn_processors.keys() if "attn1" in k] + original_attn_procs = pipe.transformer.attn_processors + pag_layers = ["blocks.0", "blocks.1"] + pipe._set_pag_attn_processor(pag_applied_layers=pag_layers, do_classifier_free_guidance=False) + assert set(pipe.pag_attn_processors) == set(all_self_attn_layers) + + # blocks.0 + block_0_self_attn = ["transformer_blocks.0.attn1.processor"] + pipe.transformer.set_attn_processor(original_attn_procs.copy()) + pag_layers = ["blocks.0"] + pipe._set_pag_attn_processor(pag_applied_layers=pag_layers, do_classifier_free_guidance=False) + assert set(pipe.pag_attn_processors) == set(block_0_self_attn) + + pipe.transformer.set_attn_processor(original_attn_procs.copy()) + pag_layers = ["blocks.0.attn1"] + pipe._set_pag_attn_processor(pag_applied_layers=pag_layers, do_classifier_free_guidance=False) + assert set(pipe.pag_attn_processors) == set(block_0_self_attn) + + pipe.transformer.set_attn_processor(original_attn_procs.copy()) + pag_layers = ["blocks.(0|1)"] + pipe._set_pag_attn_processor(pag_applied_layers=pag_layers, do_classifier_free_guidance=False) + assert (len(pipe.pag_attn_processors)) == 2 + + pipe.transformer.set_attn_processor(original_attn_procs.copy()) + pag_layers = ["blocks.0", r"blocks\.1"] + pipe._set_pag_attn_processor(pag_applied_layers=pag_layers, do_classifier_free_guidance=False) + assert len(pipe.pag_attn_processors) == 2 + + # TODO(aryan): Create a dummy gemma model with smol vocab size + @unittest.skip("A very small vocab size is used for fast tests. So, any kind of prompt other than the empty default used in other tests will lead to a embedding lookup error. This test uses a long prompt that causes the error.") + def test_inference_batch_consistent(self): + pass + + @unittest.skip("A very small vocab size is used for fast tests. So, any kind of prompt other than the empty default used in other tests will lead to a embedding lookup error. This test uses a long prompt that causes the error.") + def test_inference_batch_single_identical(self): + pass + + def test_float16_inference(self): + # Requires higher tolerance as model seems very sensitive to dtype + super().test_float16_inference(expected_max_diff=0.08) diff --git a/tests/pipelines/sana/test_sana.py b/tests/pipelines/sana/test_sana.py index c75c038f4be3..56ca7d0e3ee5 100644 --- a/tests/pipelines/sana/test_sana.py +++ b/tests/pipelines/sana/test_sana.py @@ -249,3 +249,16 @@ def test_attention_slicing_forward_pass( expected_max_diff, "Attention slicing should not affect the inference results", ) + + # TODO(aryan): Create a dummy gemma model with smol vocab size + @unittest.skip("A very small vocab size is used for fast tests. So, any kind of prompt other than the empty default used in other tests will lead to a embedding lookup error. This test uses a long prompt that causes the error.") + def test_inference_batch_consistent(self): + pass + + @unittest.skip("A very small vocab size is used for fast tests. So, any kind of prompt other than the empty default used in other tests will lead to a embedding lookup error. This test uses a long prompt that causes the error.") + def test_inference_batch_single_identical(self): + pass + + def test_float16_inference(self): + # Requires higher tolerance as model seems very sensitive to dtype + super().test_float16_inference(expected_max_diff=0.08) From 9f11659fe6913abd21a9f657b2ceb3b5322c34b1 Mon Sep 17 00:00:00 2001 From: junsong Date: Thu, 12 Dec 2024 09:03:57 -0800 Subject: [PATCH 125/141] change gemma-2-2b-it ckpt to a non-gated repo; --- scripts/convert_sana_to_diffusers.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/convert_sana_to_diffusers.py b/scripts/convert_sana_to_diffusers.py index 84397ff4a11d..0b844ff0abfc 100644 --- a/scripts/convert_sana_to_diffusers.py +++ b/scripts/convert_sana_to_diffusers.py @@ -212,7 +212,7 @@ def main(args): ae = AutoencoderDC.from_pretrained("mit-han-lab/dc-ae-f32c32-sana-1.0-diffusers", torch_dtype=torch.float32) # Text Encoder - text_encoder_model_path = "google/gemma-2-2b-it" + text_encoder_model_path = "Efficient-Large-Model/gemma-2-2b-it" tokenizer = AutoTokenizer.from_pretrained(text_encoder_model_path) tokenizer.padding_side = "right" text_encoder = AutoModelForCausalLM.from_pretrained(text_encoder_model_path, torch_dtype=torch.bfloat16).get_decoder() From d3312ccec73ff753338792a3e8dc8fc39168ce49 Mon Sep 17 00:00:00 2001 From: junsong Date: Thu, 12 Dec 2024 09:53:16 -0800 Subject: [PATCH 126/141] fix the pth path bug in conversion script; --- scripts/convert_sana_to_diffusers.py | 25 +++++++++++++------------ 1 file changed, 13 insertions(+), 12 deletions(-) diff --git a/scripts/convert_sana_to_diffusers.py b/scripts/convert_sana_to_diffusers.py index 0b844ff0abfc..a241bb264b9d 100644 --- a/scripts/convert_sana_to_diffusers.py +++ b/scripts/convert_sana_to_diffusers.py @@ -25,36 +25,37 @@ CTX = init_empty_weights if is_accelerate_available else nullcontext ckpt_ids = [ - "Efficient-Large-Model/Sana_1600M_1024px_MultiLing", - "Efficient-Large-Model/Sana_1600M_1024px_BF16", - "Efficient-Large-Model/Sana_1600M_512px_MultiLing", - "Efficient-Large-Model/Sana_1600M_1024px", - "Efficient-Large-Model/Sana_1600M_512px", - "Efficient-Large-Model/Sana_600M_1024px", - "Efficient-Large-Model/Sana_600M_512px", + "Efficient-Large-Model/Sana_1600M_1024px_MultiLing/checkpoints/Sana_1600M_1024px_MultiLing.pth", + "Efficient-Large-Model/Sana_1600M_1024px_BF16/checkpoints/Sana_1600M_1024px_BF16.pth", + "Efficient-Large-Model/Sana_1600M_512px_MultiLing/checkpoints/Sana_1600M_512px_MultiLing.pth", + "Efficient-Large-Model/Sana_1600M_1024px/checkpoints/Sana_1600M_1024px.pth", + "Efficient-Large-Model/Sana_1600M_512px/checkpoints/Sana_1600M_512px.pth", + "Efficient-Large-Model/Sana_600M_1024px/checkpoints/Sana_600M_1024px_MultiLing.pth", + "Efficient-Large-Model/Sana_600M_512px/checkpoints/Sana_600M_512px_MultiLing.pth", ] # https://github.com/NVlabs/Sana/blob/main/scripts/inference.py def main(args): - ckpt_id = ckpt_ids[0] cache_dir_path = os.path.expanduser("~/.cache/huggingface/hub") if args.orig_ckpt_path is None or args.orig_ckpt_path in ckpt_ids: + ckpt_id = args.orig_ckpt_path or ckpt_ids[0] snapshot_download( - repo_id=ckpt_id, + repo_id=f"{'/'.join(ckpt_id.split('/')[:2])}", cache_dir=cache_dir_path, repo_type="model", ) file_path = hf_hub_download( - repo_id=ckpt_id, - filename=f"checkpoints/{ckpt_id.split('/')[-1]}.pth", + repo_id=f"{'/'.join(ckpt_id.split('/')[:2])}", + filename=f"{'/'.join(ckpt_id.split('/')[2:])}", cache_dir=cache_dir_path, repo_type="model", ) else: file_path = args.orig_ckpt_path + print(colored(f"Loading checkpoint from {file_path}", "green", attrs=["bold"])) all_state_dict = torch.load(file_path, weights_only=True) state_dict = all_state_dict.pop("state_dict") converted_state_dict = {} @@ -212,7 +213,7 @@ def main(args): ae = AutoencoderDC.from_pretrained("mit-han-lab/dc-ae-f32c32-sana-1.0-diffusers", torch_dtype=torch.float32) # Text Encoder - text_encoder_model_path = "Efficient-Large-Model/gemma-2-2b-it" + text_encoder_model_path = "google/gemma-2-2b-it" tokenizer = AutoTokenizer.from_pretrained(text_encoder_model_path) tokenizer.padding_side = "right" text_encoder = AutoModelForCausalLM.from_pretrained(text_encoder_model_path, torch_dtype=torch.bfloat16).get_decoder() From 3c107e885c9ea12a6e41a885955be0b8f9265d66 Mon Sep 17 00:00:00 2001 From: Aryan Date: Fri, 13 Dec 2024 00:15:11 +0100 Subject: [PATCH 127/141] change grad ckpt to original; make style --- scripts/convert_sana_to_diffusers.py | 4 +- .../models/transformers/sana_transformer.py | 55 ++++++++++++------- src/diffusers/pipelines/sana/pipeline_sana.py | 20 ++++--- tests/pipelines/pag/test_pag_sana.py | 13 +++-- tests/pipelines/sana/test_sana.py | 13 +++-- 5 files changed, 64 insertions(+), 41 deletions(-) diff --git a/scripts/convert_sana_to_diffusers.py b/scripts/convert_sana_to_diffusers.py index a241bb264b9d..c1045a98a51a 100644 --- a/scripts/convert_sana_to_diffusers.py +++ b/scripts/convert_sana_to_diffusers.py @@ -216,7 +216,9 @@ def main(args): text_encoder_model_path = "google/gemma-2-2b-it" tokenizer = AutoTokenizer.from_pretrained(text_encoder_model_path) tokenizer.padding_side = "right" - text_encoder = AutoModelForCausalLM.from_pretrained(text_encoder_model_path, torch_dtype=torch.bfloat16).get_decoder() + text_encoder = AutoModelForCausalLM.from_pretrained( + text_encoder_model_path, torch_dtype=torch.bfloat16 + ).get_decoder() # Scheduler if args.scheduler_type == "flow-dpm_solver": diff --git a/src/diffusers/models/transformers/sana_transformer.py b/src/diffusers/models/transformers/sana_transformer.py index 6af0cd9b885c..dba67f45fce9 100644 --- a/src/diffusers/models/transformers/sana_transformer.py +++ b/src/diffusers/models/transformers/sana_transformer.py @@ -12,7 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -from typing import Dict, Optional, Tuple, Union +from typing import Any, Dict, Optional, Tuple, Union import torch from torch import nn @@ -405,26 +405,43 @@ def forward( encoder_hidden_states = self.caption_norm(encoder_hidden_states) # 2. Transformer blocks - use_reentrant = is_torch_version("<=", "1.11.0") - - def create_block_forward(block): - if torch.is_grad_enabled() and self.gradient_checkpointing: - return lambda *inputs: torch.utils.checkpoint.checkpoint( - lambda *x: block(*x), *inputs, use_reentrant=use_reentrant + if torch.is_grad_enabled() and self.gradient_checkpointing: + + def create_custom_forward(module, return_dict=None): + def custom_forward(*inputs): + if return_dict is not None: + return module(*inputs, return_dict=return_dict) + else: + return module(*inputs) + + return custom_forward + + ckpt_kwargs: Dict[str, Any] = {"use_reentrant": False} if is_torch_version(">=", "1.11.0") else {} + + for block in self.transformer_blocks: + hidden_states = torch.utils.checkpoint.checkpoint( + create_custom_forward(block), + hidden_states, + attention_mask, + encoder_hidden_states, + encoder_attention_mask, + timestep, + post_patch_height, + post_patch_width, + **ckpt_kwargs, ) - else: - return block - for block in self.transformer_blocks: - hidden_states = create_block_forward(block)( - hidden_states, - attention_mask, - encoder_hidden_states, - encoder_attention_mask, - timestep, - post_patch_height, - post_patch_width, - ) + else: + for block in self.transformer_blocks: + hidden_states = block( + hidden_states, + attention_mask, + encoder_hidden_states, + encoder_attention_mask, + timestep, + post_patch_height, + post_patch_width, + ) # 3. Normalization shift, scale = ( diff --git a/src/diffusers/pipelines/sana/pipeline_sana.py b/src/diffusers/pipelines/sana/pipeline_sana.py index a1b434dbbed0..fba814e1627c 100644 --- a/src/diffusers/pipelines/sana/pipeline_sana.py +++ b/src/diffusers/pipelines/sana/pipeline_sana.py @@ -193,7 +193,8 @@ def encode_prompt( If `True`, the function will preprocess and clean the provided caption before encoding. max_sequence_length (`int`, defaults to 300): Maximum sequence length to use for the prompt. use_complex_huamen_instruction (`list[str]`, defaults to `complex_huamen_instruction`): - If `complex_huamen_instruction` is not empty, the function will use the complex Huamen instruction for the prompt. + If `complex_huamen_instruction` is not empty, the function will use the complex Huamen instruction for + the prompt. """ if device is None: @@ -582,13 +583,13 @@ def __call__( max_sequence_length: int = 300, complex_human_attention: list[str] = [ 'Given a user prompt, generate an "Enhanced prompt" that provides detailed visual descriptions suitable for image generation. Evaluate the level of detail in the user prompt:', - '- If the prompt is simple, focus on adding specifics about colors, shapes, sizes, textures, and spatial relationships to create vivid and concrete scenes.', - '- If the prompt is already detailed, refine and enhance the existing details slightly without overcomplicating.', - 'Here are examples of how to transform or refine prompts:', - '- User Prompt: A cat sleeping -> Enhanced: A small, fluffy white cat curled up in a round shape, sleeping peacefully on a warm sunny windowsill, surrounded by pots of blooming red flowers.', - '- User Prompt: A busy city street -> Enhanced: A bustling city street scene at dusk, featuring glowing street lamps, a diverse crowd of people in colorful clothing, and a double-decker bus passing by towering glass skyscrapers.', - 'Please generate only the enhanced description for the prompt below and avoid including any additional commentary or evaluations:', - 'User Prompt: ' + "- If the prompt is simple, focus on adding specifics about colors, shapes, sizes, textures, and spatial relationships to create vivid and concrete scenes.", + "- If the prompt is already detailed, refine and enhance the existing details slightly without overcomplicating.", + "Here are examples of how to transform or refine prompts:", + "- User Prompt: A cat sleeping -> Enhanced: A small, fluffy white cat curled up in a round shape, sleeping peacefully on a warm sunny windowsill, surrounded by pots of blooming red flowers.", + "- User Prompt: A busy city street -> Enhanced: A bustling city street scene at dusk, featuring glowing street lamps, a diverse crowd of people in colorful clothing, and a double-decker bus passing by towering glass skyscrapers.", + "Please generate only the enhanced description for the prompt below and avoid including any additional commentary or evaluations:", + "User Prompt: ", ], ) -> Union[SanaPipelineOutput, Tuple]: """ @@ -669,7 +670,8 @@ def __call__( max_sequence_length (`int` defaults to `300`): Maximum sequence length to use with the `prompt`. complex_human_attention (`list[str]`, *optional*): - Instructions for complex human attention: https://github.com/NVlabs/Sana/blob/main/configs/sana_app_config/Sana_1600M_app.yaml#L55. + Instructions for complex human attention: + https://github.com/NVlabs/Sana/blob/main/configs/sana_app_config/Sana_1600M_app.yaml#L55. Examples: diff --git a/tests/pipelines/pag/test_pag_sana.py b/tests/pipelines/pag/test_pag_sana.py index ebada6b009b2..227ad16f468d 100644 --- a/tests/pipelines/pag/test_pag_sana.py +++ b/tests/pipelines/pag/test_pag_sana.py @@ -219,9 +219,6 @@ def callback_inputs_change_tensor(pipe, i, t, callback_kwargs): output = pipe(**inputs)[0] assert output.abs().sum() < 1e10 - def test_inference_batch_single_identical(self): - self._test_inference_batch_single_identical(batch_size=3, expected_max_diff=1e-3) - def test_attention_slicing_forward_pass( self, test_max_difference=True, test_mean_pixel_difference=True, expected_max_diff=1e-3 ): @@ -322,13 +319,17 @@ def test_pag_applied_layers(self): pag_layers = ["blocks.0", r"blocks\.1"] pipe._set_pag_attn_processor(pag_applied_layers=pag_layers, do_classifier_free_guidance=False) assert len(pipe.pag_attn_processors) == 2 - + # TODO(aryan): Create a dummy gemma model with smol vocab size - @unittest.skip("A very small vocab size is used for fast tests. So, any kind of prompt other than the empty default used in other tests will lead to a embedding lookup error. This test uses a long prompt that causes the error.") + @unittest.skip( + "A very small vocab size is used for fast tests. So, any kind of prompt other than the empty default used in other tests will lead to a embedding lookup error. This test uses a long prompt that causes the error." + ) def test_inference_batch_consistent(self): pass - @unittest.skip("A very small vocab size is used for fast tests. So, any kind of prompt other than the empty default used in other tests will lead to a embedding lookup error. This test uses a long prompt that causes the error.") + @unittest.skip( + "A very small vocab size is used for fast tests. So, any kind of prompt other than the empty default used in other tests will lead to a embedding lookup error. This test uses a long prompt that causes the error." + ) def test_inference_batch_single_identical(self): pass diff --git a/tests/pipelines/sana/test_sana.py b/tests/pipelines/sana/test_sana.py index 56ca7d0e3ee5..ae2883225a04 100644 --- a/tests/pipelines/sana/test_sana.py +++ b/tests/pipelines/sana/test_sana.py @@ -212,9 +212,6 @@ def callback_inputs_change_tensor(pipe, i, t, callback_kwargs): output = pipe(**inputs)[0] assert output.abs().sum() < 1e10 - def test_inference_batch_single_identical(self): - self._test_inference_batch_single_identical(batch_size=3, expected_max_diff=1e-3) - def test_attention_slicing_forward_pass( self, test_max_difference=True, test_mean_pixel_difference=True, expected_max_diff=1e-3 ): @@ -249,13 +246,17 @@ def test_attention_slicing_forward_pass( expected_max_diff, "Attention slicing should not affect the inference results", ) - + # TODO(aryan): Create a dummy gemma model with smol vocab size - @unittest.skip("A very small vocab size is used for fast tests. So, any kind of prompt other than the empty default used in other tests will lead to a embedding lookup error. This test uses a long prompt that causes the error.") + @unittest.skip( + "A very small vocab size is used for fast tests. So, any kind of prompt other than the empty default used in other tests will lead to a embedding lookup error. This test uses a long prompt that causes the error." + ) def test_inference_batch_consistent(self): pass - @unittest.skip("A very small vocab size is used for fast tests. So, any kind of prompt other than the empty default used in other tests will lead to a embedding lookup error. This test uses a long prompt that causes the error.") + @unittest.skip( + "A very small vocab size is used for fast tests. So, any kind of prompt other than the empty default used in other tests will lead to a embedding lookup error. This test uses a long prompt that causes the error." + ) def test_inference_batch_single_identical(self): pass From 7c23fcc1a02be89b0fbeb2e5ef44b6ff4025ed4f Mon Sep 17 00:00:00 2001 From: lawrence-cj Date: Fri, 13 Dec 2024 16:44:26 +0800 Subject: [PATCH 128/141] fix the complex_human_instruct bug and typo; --- src/diffusers/pipelines/sana/pipeline_sana.py | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/src/diffusers/pipelines/sana/pipeline_sana.py b/src/diffusers/pipelines/sana/pipeline_sana.py index fba814e1627c..14b576327a9a 100644 --- a/src/diffusers/pipelines/sana/pipeline_sana.py +++ b/src/diffusers/pipelines/sana/pipeline_sana.py @@ -165,7 +165,7 @@ def encode_prompt( negative_prompt_attention_mask: Optional[torch.Tensor] = None, clean_caption: bool = False, max_sequence_length: int = 300, - complex_huamen_instruction: list[str] = [], + complex_human_instruction=None, ): r""" Encodes the prompt into text encoder hidden states. @@ -187,13 +187,13 @@ def encode_prompt( Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not provided, text embeddings will be generated from `prompt` input argument. negative_prompt_embeds (`torch.Tensor`, *optional*): - Pre-generated negative text embeddings. For PixArt-Alpha, it's should be the embeddings of the "" + Pre-generated negative text embeddings. For Sana, it's should be the embeddings of the "" string. clean_caption (`bool`, defaults to `False`): If `True`, the function will preprocess and clean the provided caption before encoding. max_sequence_length (`int`, defaults to 300): Maximum sequence length to use for the prompt. - use_complex_huamen_instruction (`list[str]`, defaults to `complex_huamen_instruction`): - If `complex_huamen_instruction` is not empty, the function will use the complex Huamen instruction for + complex_human_instruction (`list[str]`, defaults to `complex_human_instruction`): + If `complex_human_instruction` is not empty, the function will use the complex Human instruction for the prompt. """ @@ -214,11 +214,11 @@ def encode_prompt( if prompt_embeds is None: prompt = self._text_preprocessing(prompt, clean_caption=clean_caption) - # prepare complex huamen instruction - if not complex_huamen_instruction: + # prepare complex human instruction + if not complex_human_instruction: max_length_all = max_length else: - chi_prompt = "\n".join(complex_huamen_instruction) + chi_prompt = "\n".join(complex_human_instruction) prompt = [chi_prompt + p for p in prompt] num_chi_prompt_tokens = len(self.tokenizer.encode(chi_prompt)) max_length_all = num_chi_prompt_tokens + max_length - 2 @@ -581,7 +581,7 @@ def __call__( callback_on_step_end: Optional[Callable[[int, int, Dict], None]] = None, callback_on_step_end_tensor_inputs: List[str] = ["latents"], max_sequence_length: int = 300, - complex_human_attention: list[str] = [ + complex_human_instruction: list[str] = [ 'Given a user prompt, generate an "Enhanced prompt" that provides detailed visual descriptions suitable for image generation. Evaluate the level of detail in the user prompt:', "- If the prompt is simple, focus on adding specifics about colors, shapes, sizes, textures, and spatial relationships to create vivid and concrete scenes.", "- If the prompt is already detailed, refine and enhance the existing details slightly without overcomplicating.", @@ -669,7 +669,7 @@ def __call__( `._callback_tensor_inputs` attribute of your pipeline class. max_sequence_length (`int` defaults to `300`): Maximum sequence length to use with the `prompt`. - complex_human_attention (`list[str]`, *optional*): + complex_human_instruction (`list[str]`, *optional*): Instructions for complex human attention: https://github.com/NVlabs/Sana/blob/main/configs/sana_app_config/Sana_1600M_app.yaml#L55. @@ -740,6 +740,7 @@ def __call__( negative_prompt_attention_mask=negative_prompt_attention_mask, clean_caption=clean_caption, max_sequence_length=max_sequence_length, + complex_human_instruction=complex_human_instruction, ) if self.do_classifier_free_guidance: prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds], dim=0) From eee08ad55171757c382cae78deb1e165395587dc Mon Sep 17 00:00:00 2001 From: Aryan Date: Fri, 13 Dec 2024 10:00:53 +0100 Subject: [PATCH 129/141] remove dpmsolver flow scheduler --- src/diffusers/schedulers/__init__.py | 2 - .../scheduling_dpmsolver_multistep_flow.py | 809 ------------------ 2 files changed, 811 deletions(-) delete mode 100644 src/diffusers/schedulers/scheduling_dpmsolver_multistep_flow.py diff --git a/src/diffusers/schedulers/__init__.py b/src/diffusers/schedulers/__init__.py index c64a20c43974..bb9088538653 100644 --- a/src/diffusers/schedulers/__init__.py +++ b/src/diffusers/schedulers/__init__.py @@ -52,7 +52,6 @@ _import_structure["scheduling_deis_multistep"] = ["DEISMultistepScheduler"] _import_structure["scheduling_dpm_cogvideox"] = ["CogVideoXDPMScheduler"] _import_structure["scheduling_dpmsolver_multistep"] = ["DPMSolverMultistepScheduler"] - _import_structure["scheduling_dpmsolver_multistep_flow"] = ["FlowDPMSolverMultistepScheduler"] _import_structure["scheduling_dpmsolver_multistep_inverse"] = ["DPMSolverMultistepInverseScheduler"] _import_structure["scheduling_dpmsolver_singlestep"] = ["DPMSolverSinglestepScheduler"] _import_structure["scheduling_edm_dpmsolver_multistep"] = ["EDMDPMSolverMultistepScheduler"] @@ -153,7 +152,6 @@ from .scheduling_deis_multistep import DEISMultistepScheduler from .scheduling_dpm_cogvideox import CogVideoXDPMScheduler from .scheduling_dpmsolver_multistep import DPMSolverMultistepScheduler - from .scheduling_dpmsolver_multistep_flow import FlowDPMSolverMultistepScheduler from .scheduling_dpmsolver_multistep_inverse import DPMSolverMultistepInverseScheduler from .scheduling_dpmsolver_singlestep import DPMSolverSinglestepScheduler from .scheduling_edm_dpmsolver_multistep import EDMDPMSolverMultistepScheduler diff --git a/src/diffusers/schedulers/scheduling_dpmsolver_multistep_flow.py b/src/diffusers/schedulers/scheduling_dpmsolver_multistep_flow.py deleted file mode 100644 index 955ecf514167..000000000000 --- a/src/diffusers/schedulers/scheduling_dpmsolver_multistep_flow.py +++ /dev/null @@ -1,809 +0,0 @@ -# Copyright 2024 TSAIL Team and The HuggingFace Team. All rights reserved. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -# DISCLAIMER: This file is strongly influenced by https://github.com/LuChengTHU/dpm-solver - -import math -from typing import List, Optional, Tuple, Union - -import numpy as np -import torch - -from ..configuration_utils import ConfigMixin, register_to_config -from ..utils import deprecate, is_scipy_available -from ..utils.torch_utils import randn_tensor -from .scheduling_utils import KarrasDiffusionSchedulers, SchedulerMixin, SchedulerOutput - - -if is_scipy_available(): - pass - - -class FlowDPMSolverMultistepScheduler(SchedulerMixin, ConfigMixin): - """ - `FlowDPMSolverMultistepScheduler` is a fast dedicated high-order solver for diffusion ODEs. - - This model inherits from [`SchedulerMixin`] and [`ConfigMixin`]. Check the superclass documentation for the generic - methods the library implements for all schedulers such as loading and saving. - - Args: - num_train_timesteps (`int`, defaults to 1000): - The number of diffusion steps to train the model. This determines the resolution of the diffusion process. - solver_order (`int`, defaults to 2): - The DPMSolver order which can be `1`, `2`, or `3`. It is recommended to use `solver_order=2` for guided - sampling, and `solver_order=3` for unconditional sampling. This affects the number of model outputs stored - and used in multistep updates. - prediction_type (`str`, defaults to "flow_prediction"): - Prediction type of the scheduler function; must be `flow_prediction` for this scheduler, which predicts the - flow of the diffusion process. - flow_shift (`float`, *optional*, defaults to 1.0): - A factor used to adjust the sigmas in the noise schedule. It modifies the step sizes during the sampling - process. - use_dynamic_shifting (`bool`, defaults to `False`): - Whether to apply dynamic shifting to the timesteps based on image resolution. If `True`, the shifting is - applied on the fly. - thresholding (`bool`, defaults to `False`): - Whether to use the "dynamic thresholding" method. This method adjusts the predicted sample to prevent - saturation and improve photorealism. - dynamic_thresholding_ratio (`float`, defaults to 0.995): - The ratio for the dynamic thresholding method. Valid only when `thresholding=True`. - sample_max_value (`float`, defaults to 1.0): - The threshold value for dynamic thresholding. Valid only when `thresholding=True` and - `algorithm_type="dpmsolver++"`. - algorithm_type (`str`, defaults to `dpmsolver++`): - Algorithm type for the solver; can be `dpmsolver`, `dpmsolver++`, `sde-dpmsolver` or `sde-dpmsolver++`. The - `dpmsolver` type implements the algorithms in the [DPMSolver](https://huggingface.co/papers/2206.00927) - paper, and the `dpmsolver++` type implements the algorithms in the - [DPMSolver++](https://huggingface.co/papers/2211.01095) paper. It is recommended to use `dpmsolver++` or - `sde-dpmsolver++` with `solver_order=2` for guided sampling like in Stable Diffusion. - solver_type (`str`, defaults to `midpoint`): - Solver type for the second-order solver; can be `midpoint` or `heun`. The solver type slightly affects the - sample quality, especially for a small number of steps. It is recommended to use `midpoint` solvers. - lower_order_final (`bool`, defaults to `True`): - Whether to use lower-order solvers in the final steps. Only valid for < 15 inference steps. This can - stabilize the sampling of DPMSolver for steps < 15, especially for steps <= 10. - euler_at_final (`bool`, defaults to `False`): - Whether to use Euler's method in the final step. It is a trade-off between numerical stability and detail - richness. This can stabilize the sampling of the SDE variant of DPMSolver for small number of inference - steps, but sometimes may result in blurring. - final_sigmas_type (`str`, *optional*, defaults to "zero"): - The final `sigma` value for the noise schedule during the sampling process. If `"sigma_min"`, the final - sigma is the same as the last sigma in the training schedule. If `zero`, the final sigma is set to 0. - lambda_min_clipped (`float`, defaults to `-inf`): - Clipping threshold for the minimum value of `lambda(t)` for numerical stability. This is critical for the - cosine (`squaredcos_cap_v2`) noise schedule. - variance_type (`str`, *optional*): - Set to "learned" or "learned_range" for diffusion models that predict variance. If set, the model's output - contains the predicted Gaussian variance. - """ - - _compatibles = [e.name for e in KarrasDiffusionSchedulers] - order = 1 - - @register_to_config - def __init__( - self, - num_train_timesteps: int = 1000, - solver_order: int = 2, - prediction_type: str = "flow_prediction", - flow_shift: Optional[float] = 1.0, - use_dynamic_shifting=False, - thresholding: bool = False, - dynamic_thresholding_ratio: float = 0.995, - sample_max_value: float = 1.0, - algorithm_type: str = "dpmsolver++", - solver_type: str = "midpoint", - lower_order_final: bool = True, - euler_at_final: bool = False, - final_sigmas_type: Optional[str] = "zero", # "zero", "sigma_min" - lambda_min_clipped: float = -float("inf"), - variance_type: Optional[str] = None, - invert_sigmas: bool = False, - ): - if algorithm_type in ["dpmsolver", "sde-dpmsolver"]: - deprecation_message = f"algorithm_type {algorithm_type} is deprecated and will be removed in a future version. Choose from `dpmsolver++` or `sde-dpmsolver++` instead" - deprecate("algorithm_types dpmsolver and sde-dpmsolver", "1.0.0", deprecation_message) - - # settings for DPM-Solver - if algorithm_type not in ["dpmsolver", "dpmsolver++", "sde-dpmsolver", "sde-dpmsolver++"]: - if algorithm_type == "deis": - self.register_to_config(algorithm_type="dpmsolver++") - else: - raise NotImplementedError(f"{algorithm_type} is not implemented for {self.__class__}") - - if solver_type not in ["midpoint", "heun"]: - if solver_type in ["logrho", "bh1", "bh2"]: - self.register_to_config(solver_type="midpoint") - else: - raise NotImplementedError(f"{solver_type} is not implemented for {self.__class__}") - - if algorithm_type not in ["dpmsolver++", "sde-dpmsolver++"] and final_sigmas_type == "zero": - raise ValueError( - f"`final_sigmas_type` {final_sigmas_type} is not supported for `algorithm_type` {algorithm_type}. Please choose `sigma_min` instead." - ) - - # setable values - self.num_inference_steps = None - alphas = np.linspace(1, 1 / num_train_timesteps, num_train_timesteps)[::-1].copy() - sigmas = 1.0 - alphas - sigmas = torch.from_numpy(sigmas).to(dtype=torch.float32) - - if not use_dynamic_shifting: - # when use_dynamic_shifting is True, we apply the timestep shifting on the fly based on the image resolution - sigmas = flow_shift * sigmas / (1 + (flow_shift - 1) * sigmas) - - self.sigmas = sigmas - self.timesteps = sigmas * num_train_timesteps - - self.model_outputs = [None] * solver_order - self.lower_order_nums = 0 - self._step_index = None - self._begin_index = None - - self.sigmas = self.sigmas.to("cpu") # to avoid too much CPU/GPU communication - self.sigma_min = self.sigmas[-1].item() - self.sigma_max = self.sigmas[0].item() - - @property - def step_index(self): - """ - The index counter for current timestep. It will increase 1 after each scheduler step. - """ - return self._step_index - - @property - def begin_index(self): - """ - The index for the first timestep. It should be set from pipeline with `set_begin_index` method. - """ - return self._begin_index - - # Copied from diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler.set_begin_index - def set_begin_index(self, begin_index: int = 0): - """ - Sets the begin index for the scheduler. This function should be run from pipeline before the inference. - - Args: - begin_index (`int`): - The begin index for the scheduler. - """ - self._begin_index = begin_index - - # Modified from diffusers.schedulers.scheduling_flow_match_euler_discrete.FlowMatchEulerDiscreteScheduler.set_timesteps - def set_timesteps( - self, - num_inference_steps: int = None, - device: Union[str, torch.device] = None, - sigmas: Optional[List[float]] = None, - mu: Optional[float] = None, - ): - """ - Sets the discrete timesteps used for the diffusion chain (to be run before inference). - - Args: - num_inference_steps (`int`): - Total number of the spacing of the time steps. - device (`str` or `torch.device`, *optional*): - The device to which the timesteps should be moved to. If `None`, the timesteps are not moved. - """ - - if self.config.use_dynamic_shifting and mu is None: - raise ValueError(" you have a pass a value for `mu` when `use_dynamic_shifting` is set to be `True`") - - if sigmas is None: - sigmas = np.linspace(self.sigma_max, self.sigma_min, num_inference_steps + 1).copy()[:-1] - - if self.config.use_dynamic_shifting: - sigmas = self.time_shift(mu, 1.0, sigmas) - else: - sigmas = self.config.flow_shift * sigmas / (1 + (self.config.flow_shift - 1) * sigmas) - - if self.config.final_sigmas_type == "sigma_min": - sigma_last = ((1 - self.alphas_cumprod[0]) / self.alphas_cumprod[0]) ** 0.5 - elif self.config.final_sigmas_type == "zero": - sigma_last = 0 - else: - raise ValueError( - f"`final_sigmas_type` must be one of 'zero', or 'sigma_min', but got {self.config.final_sigmas_type}" - ) - - timesteps = sigmas * self.config.num_train_timesteps - sigmas = np.concatenate([sigmas, [sigma_last]]).astype(np.float32) - - self.sigmas = torch.from_numpy(sigmas) - self.timesteps = torch.from_numpy(timesteps).to(device=device, dtype=torch.int64) - - self.num_inference_steps = len(timesteps) - - self.model_outputs = [ - None, - ] * self.config.solver_order - self.lower_order_nums = 0 - - self._step_index = None - self._begin_index = None - self.sigmas = self.sigmas.to("cpu") # to avoid too much CPU/GPU communication - - # Copied from diffusers.schedulers.scheduling_ddpm.DDPMScheduler._threshold_sample - def _threshold_sample(self, sample: torch.Tensor) -> torch.Tensor: - """ - "Dynamic thresholding: At each sampling step we set s to a certain percentile absolute pixel value in xt0 (the - prediction of x_0 at timestep t), and if s > 1, then we threshold xt0 to the range [-s, s] and then divide by - s. Dynamic thresholding pushes saturated pixels (those near -1 and 1) inwards, thereby actively preventing - pixels from saturation at each step. We find that dynamic thresholding results in significantly better - photorealism as well as better image-text alignment, especially when using very large guidance weights." - - https://arxiv.org/abs/2205.11487 - """ - dtype = sample.dtype - batch_size, channels, *remaining_dims = sample.shape - - if dtype not in (torch.float32, torch.float64): - sample = sample.float() # upcast for quantile calculation, and clamp not implemented for cpu half - - # Flatten sample for doing quantile calculation along each image - sample = sample.reshape(batch_size, channels * np.prod(remaining_dims)) - - abs_sample = sample.abs() # "a certain percentile absolute pixel value" - - s = torch.quantile(abs_sample, self.config.dynamic_thresholding_ratio, dim=1) - s = torch.clamp( - s, min=1, max=self.config.sample_max_value - ) # When clamped to min=1, equivalent to standard clipping to [-1, 1] - s = s.unsqueeze(1) # (batch_size, 1) because clamp will broadcast along dim=0 - sample = torch.clamp(sample, -s, s) / s # "we threshold xt0 to the range [-s, s] and then divide by s" - - sample = sample.reshape(batch_size, channels, *remaining_dims) - sample = sample.to(dtype) - - return sample - - # Copied from diffusers.schedulers.scheduling_flow_match_euler_discrete.FlowMatchEulerDiscreteScheduler._sigma_to_t - def _sigma_to_t(self, sigma): - return sigma * self.config.num_train_timesteps - - def _sigma_to_alpha_sigma_t(self, sigma): - return 1 - sigma, sigma - - # Copied from diffusers.schedulers.scheduling_flow_match_euler_discrete.set_timesteps - def time_shift(self, mu: float, sigma: float, t: torch.Tensor): - return math.exp(mu) / (math.exp(mu) + (1 / t - 1) ** sigma) - - # Copied from diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler.convert_model_output - def convert_model_output( - self, - model_output: torch.Tensor, - *args, - sample: torch.Tensor = None, - **kwargs, - ) -> torch.Tensor: - """ - Convert the model output to the corresponding type the DPMSolver/DPMSolver++ algorithm needs. DPM-Solver is - designed to discretize an integral of the noise prediction model, and DPM-Solver++ is designed to discretize an - integral of the data prediction model. - - - - The algorithm and model type are decoupled. You can use either DPMSolver or DPMSolver++ for both noise - prediction and data prediction models. - - - - Args: - model_output (`torch.Tensor`): - The direct output from the learned diffusion model. - sample (`torch.Tensor`): - A current instance of a sample created by the diffusion process. - - Returns: - `torch.Tensor`: - The converted model output. - """ - timestep = args[0] if len(args) > 0 else kwargs.pop("timestep", None) - if sample is None: - if len(args) > 1: - sample = args[1] - else: - raise ValueError("missing `sample` as a required keyward argument") - if timestep is not None: - deprecate( - "timesteps", - "1.0.0", - "Passing `timesteps` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`", - ) - - # DPM-Solver++ needs to solve an integral of the data prediction model. - if self.config.algorithm_type in ["dpmsolver++", "sde-dpmsolver++"]: - if self.config.prediction_type == "flow_prediction": - sigma_t = self.sigmas[self.step_index] - x0_pred = sample - sigma_t * model_output - else: - raise ValueError( - f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`," - " `v_prediction`, or `flow_prediction` for the FlowDPMSolverMultistepScheduler." - ) - - if self.config.thresholding: - x0_pred = self._threshold_sample(x0_pred) - - return x0_pred - - # DPM-Solver needs to solve an integral of the noise prediction model. - elif self.config.algorithm_type in ["dpmsolver", "sde-dpmsolver"]: - if self.config.prediction_type == "flow_prediction": - sigma_t = self.sigmas[self.step_index] - epsilon = sample - (1 - sigma_t) * model_output - else: - raise ValueError( - f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`," - " `v_prediction` or `flow_prediction` for the FlowDPMSolverMultistepScheduler." - ) - - if self.config.thresholding: - sigma_t = self.sigmas[self.step_index] - x0_pred = sample - sigma_t * model_output - x0_pred = self._threshold_sample(x0_pred) - epsilon = model_output + x0_pred - - return epsilon - - # Copied from diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler.dpm_solver_first_order_update - def dpm_solver_first_order_update( - self, - model_output: torch.Tensor, - *args, - sample: torch.Tensor = None, - noise: Optional[torch.Tensor] = None, - **kwargs, - ) -> torch.Tensor: - """ - One step for the first-order DPMSolver (equivalent to DDIM). - - Args: - model_output (`torch.Tensor`): - The direct output from the learned diffusion model. - sample (`torch.Tensor`): - A current instance of a sample created by the diffusion process. - - Returns: - `torch.Tensor`: - The sample tensor at the previous timestep. - """ - timestep = args[0] if len(args) > 0 else kwargs.pop("timestep", None) - prev_timestep = args[1] if len(args) > 1 else kwargs.pop("prev_timestep", None) - if sample is None: - if len(args) > 2: - sample = args[2] - else: - raise ValueError(" missing `sample` as a required keyward argument") - if timestep is not None: - deprecate( - "timesteps", - "1.0.0", - "Passing `timesteps` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`", - ) - - if prev_timestep is not None: - deprecate( - "prev_timestep", - "1.0.0", - "Passing `prev_timestep` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`", - ) - - sigma_t, sigma_s = self.sigmas[self.step_index + 1], self.sigmas[self.step_index] - alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma_t) - alpha_s, sigma_s = self._sigma_to_alpha_sigma_t(sigma_s) - lambda_t = torch.log(alpha_t) - torch.log(sigma_t) - lambda_s = torch.log(alpha_s) - torch.log(sigma_s) - - h = lambda_t - lambda_s - if self.config.algorithm_type == "dpmsolver++": - x_t = (sigma_t / sigma_s) * sample - (alpha_t * (torch.exp(-h) - 1.0)) * model_output - elif self.config.algorithm_type == "dpmsolver": - x_t = (alpha_t / alpha_s) * sample - (sigma_t * (torch.exp(h) - 1.0)) * model_output - elif self.config.algorithm_type == "sde-dpmsolver++": - assert noise is not None - x_t = ( - (sigma_t / sigma_s * torch.exp(-h)) * sample - + (alpha_t * (1 - torch.exp(-2.0 * h))) * model_output - + sigma_t * torch.sqrt(1.0 - torch.exp(-2 * h)) * noise - ) - elif self.config.algorithm_type == "sde-dpmsolver": - assert noise is not None - x_t = ( - (alpha_t / alpha_s) * sample - - 2.0 * (sigma_t * (torch.exp(h) - 1.0)) * model_output - + sigma_t * torch.sqrt(torch.exp(2 * h) - 1.0) * noise - ) - return x_t - - # Copied from diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler.multistep_dpm_solver_second_order_update - def multistep_dpm_solver_second_order_update( - self, - model_output_list: List[torch.Tensor], - *args, - sample: torch.Tensor = None, - noise: Optional[torch.Tensor] = None, - **kwargs, - ) -> torch.Tensor: - """ - One step for the second-order multistep DPMSolver. - - Args: - model_output_list (`List[torch.Tensor]`): - The direct outputs from learned diffusion model at current and latter timesteps. - sample (`torch.Tensor`): - A current instance of a sample created by the diffusion process. - - Returns: - `torch.Tensor`: - The sample tensor at the previous timestep. - """ - timestep_list = args[0] if len(args) > 0 else kwargs.pop("timestep_list", None) - prev_timestep = args[1] if len(args) > 1 else kwargs.pop("prev_timestep", None) - if sample is None: - if len(args) > 2: - sample = args[2] - else: - raise ValueError(" missing `sample` as a required keyward argument") - if timestep_list is not None: - deprecate( - "timestep_list", - "1.0.0", - "Passing `timestep_list` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`", - ) - - if prev_timestep is not None: - deprecate( - "prev_timestep", - "1.0.0", - "Passing `prev_timestep` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`", - ) - - sigma_t, sigma_s0, sigma_s1 = ( - self.sigmas[self.step_index + 1], - self.sigmas[self.step_index], - self.sigmas[self.step_index - 1], - ) - - alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma_t) - alpha_s0, sigma_s0 = self._sigma_to_alpha_sigma_t(sigma_s0) - alpha_s1, sigma_s1 = self._sigma_to_alpha_sigma_t(sigma_s1) - - lambda_t = torch.log(alpha_t) - torch.log(sigma_t) - lambda_s0 = torch.log(alpha_s0) - torch.log(sigma_s0) - lambda_s1 = torch.log(alpha_s1) - torch.log(sigma_s1) - - m0, m1 = model_output_list[-1], model_output_list[-2] - - h, h_0 = lambda_t - lambda_s0, lambda_s0 - lambda_s1 - r0 = h_0 / h - D0, D1 = m0, (1.0 / r0) * (m0 - m1) - if self.config.algorithm_type == "dpmsolver++": - # See https://arxiv.org/abs/2211.01095 for detailed derivations - if self.config.solver_type == "midpoint": - x_t = ( - (sigma_t / sigma_s0) * sample - - (alpha_t * (torch.exp(-h) - 1.0)) * D0 - - 0.5 * (alpha_t * (torch.exp(-h) - 1.0)) * D1 - ) - elif self.config.solver_type == "heun": - x_t = ( - (sigma_t / sigma_s0) * sample - - (alpha_t * (torch.exp(-h) - 1.0)) * D0 - + (alpha_t * ((torch.exp(-h) - 1.0) / h + 1.0)) * D1 - ) - elif self.config.algorithm_type == "dpmsolver": - # See https://arxiv.org/abs/2206.00927 for detailed derivations - if self.config.solver_type == "midpoint": - x_t = ( - (alpha_t / alpha_s0) * sample - - (sigma_t * (torch.exp(h) - 1.0)) * D0 - - 0.5 * (sigma_t * (torch.exp(h) - 1.0)) * D1 - ) - elif self.config.solver_type == "heun": - x_t = ( - (alpha_t / alpha_s0) * sample - - (sigma_t * (torch.exp(h) - 1.0)) * D0 - - (sigma_t * ((torch.exp(h) - 1.0) / h - 1.0)) * D1 - ) - elif self.config.algorithm_type == "sde-dpmsolver++": - assert noise is not None - if self.config.solver_type == "midpoint": - x_t = ( - (sigma_t / sigma_s0 * torch.exp(-h)) * sample - + (alpha_t * (1 - torch.exp(-2.0 * h))) * D0 - + 0.5 * (alpha_t * (1 - torch.exp(-2.0 * h))) * D1 - + sigma_t * torch.sqrt(1.0 - torch.exp(-2 * h)) * noise - ) - elif self.config.solver_type == "heun": - x_t = ( - (sigma_t / sigma_s0 * torch.exp(-h)) * sample - + (alpha_t * (1 - torch.exp(-2.0 * h))) * D0 - + (alpha_t * ((1.0 - torch.exp(-2.0 * h)) / (-2.0 * h) + 1.0)) * D1 - + sigma_t * torch.sqrt(1.0 - torch.exp(-2 * h)) * noise - ) - elif self.config.algorithm_type == "sde-dpmsolver": - assert noise is not None - if self.config.solver_type == "midpoint": - x_t = ( - (alpha_t / alpha_s0) * sample - - 2.0 * (sigma_t * (torch.exp(h) - 1.0)) * D0 - - (sigma_t * (torch.exp(h) - 1.0)) * D1 - + sigma_t * torch.sqrt(torch.exp(2 * h) - 1.0) * noise - ) - elif self.config.solver_type == "heun": - x_t = ( - (alpha_t / alpha_s0) * sample - - 2.0 * (sigma_t * (torch.exp(h) - 1.0)) * D0 - - 2.0 * (sigma_t * ((torch.exp(h) - 1.0) / h - 1.0)) * D1 - + sigma_t * torch.sqrt(torch.exp(2 * h) - 1.0) * noise - ) - return x_t - - # Copied from diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler.multistep_dpm_solver_third_order_update - def multistep_dpm_solver_third_order_update( - self, - model_output_list: List[torch.Tensor], - *args, - sample: torch.Tensor = None, - **kwargs, - ) -> torch.Tensor: - """ - One step for the third-order multistep DPMSolver. - - Args: - model_output_list (`List[torch.Tensor]`): - The direct outputs from learned diffusion model at current and latter timesteps. - sample (`torch.Tensor`): - A current instance of a sample created by diffusion process. - - Returns: - `torch.Tensor`: - The sample tensor at the previous timestep. - """ - - timestep_list = args[0] if len(args) > 0 else kwargs.pop("timestep_list", None) - prev_timestep = args[1] if len(args) > 1 else kwargs.pop("prev_timestep", None) - if sample is None: - if len(args) > 2: - sample = args[2] - else: - raise ValueError(" missing`sample` as a required keyward argument") - if timestep_list is not None: - deprecate( - "timestep_list", - "1.0.0", - "Passing `timestep_list` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`", - ) - - if prev_timestep is not None: - deprecate( - "prev_timestep", - "1.0.0", - "Passing `prev_timestep` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`", - ) - - sigma_t, sigma_s0, sigma_s1, sigma_s2 = ( - self.sigmas[self.step_index + 1], - self.sigmas[self.step_index], - self.sigmas[self.step_index - 1], - self.sigmas[self.step_index - 2], - ) - - alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma_t) - alpha_s0, sigma_s0 = self._sigma_to_alpha_sigma_t(sigma_s0) - alpha_s1, sigma_s1 = self._sigma_to_alpha_sigma_t(sigma_s1) - alpha_s2, sigma_s2 = self._sigma_to_alpha_sigma_t(sigma_s2) - - lambda_t = torch.log(alpha_t) - torch.log(sigma_t) - lambda_s0 = torch.log(alpha_s0) - torch.log(sigma_s0) - lambda_s1 = torch.log(alpha_s1) - torch.log(sigma_s1) - lambda_s2 = torch.log(alpha_s2) - torch.log(sigma_s2) - - m0, m1, m2 = model_output_list[-1], model_output_list[-2], model_output_list[-3] - - h, h_0, h_1 = lambda_t - lambda_s0, lambda_s0 - lambda_s1, lambda_s1 - lambda_s2 - r0, r1 = h_0 / h, h_1 / h - D0 = m0 - D1_0, D1_1 = (1.0 / r0) * (m0 - m1), (1.0 / r1) * (m1 - m2) - D1 = D1_0 + (r0 / (r0 + r1)) * (D1_0 - D1_1) - D2 = (1.0 / (r0 + r1)) * (D1_0 - D1_1) - if self.config.algorithm_type == "dpmsolver++": - # See https://arxiv.org/abs/2206.00927 for detailed derivations - x_t = ( - (sigma_t / sigma_s0) * sample - - (alpha_t * (torch.exp(-h) - 1.0)) * D0 - + (alpha_t * ((torch.exp(-h) - 1.0) / h + 1.0)) * D1 - - (alpha_t * ((torch.exp(-h) - 1.0 + h) / h**2 - 0.5)) * D2 - ) - elif self.config.algorithm_type == "dpmsolver": - # See https://arxiv.org/abs/2206.00927 for detailed derivations - x_t = ( - (alpha_t / alpha_s0) * sample - - (sigma_t * (torch.exp(h) - 1.0)) * D0 - - (sigma_t * ((torch.exp(h) - 1.0) / h - 1.0)) * D1 - - (sigma_t * ((torch.exp(h) - 1.0 - h) / h**2 - 0.5)) * D2 - ) - return x_t - - def index_for_timestep(self, timestep, schedule_timesteps=None): - if schedule_timesteps is None: - schedule_timesteps = self.timesteps - - indices = (schedule_timesteps == timestep).nonzero() - - # The sigma index that is taken for the **very** first `step` - # is always the second index (or the last index if there is only 1) - # This way we can ensure we don't accidentally skip a sigma in - # case we start in the middle of the denoising schedule (e.g. for image-to-image) - pos = 1 if len(indices) > 1 else 0 - - return indices[pos].item() - - def _init_step_index(self, timestep): - """ - Initialize the step_index counter for the scheduler. - """ - - if self.begin_index is None: - if isinstance(timestep, torch.Tensor): - timestep = timestep.to(self.timesteps.device) - self._step_index = self.index_for_timestep(timestep) - else: - self._step_index = self._begin_index - - # Modified from diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler.step - def step( - self, - model_output: torch.Tensor, - timestep: Union[int, torch.Tensor], - sample: torch.Tensor, - generator=None, - variance_noise: Optional[torch.Tensor] = None, - return_dict: bool = True, - ) -> Union[SchedulerOutput, Tuple]: - """ - Predict the sample from the previous timestep by reversing the SDE. This function propagates the sample with - the multistep DPMSolver. - - Args: - model_output (`torch.Tensor`): - The direct output from learned diffusion model. - timestep (`int`): - The current discrete timestep in the diffusion chain. - sample (`torch.Tensor`): - A current instance of a sample created by the diffusion process. - generator (`torch.Generator`, *optional*): - A random number generator. - variance_noise (`torch.Tensor`): - Alternative to generating noise with `generator` by directly providing the noise for the variance - itself. Useful for methods such as [`LEdits++`]. - return_dict (`bool`): - Whether or not to return a [`~schedulers.scheduling_utils.SchedulerOutput`] or `tuple`. - - Returns: - [`~schedulers.scheduling_utils.SchedulerOutput`] or `tuple`: - If return_dict is `True`, [`~schedulers.scheduling_utils.SchedulerOutput`] is returned, otherwise a - tuple is returned where the first element is the sample tensor. - - """ - if self.num_inference_steps is None: - raise ValueError( - "Number of inference steps is 'None', you need to run 'set_timesteps' after creating the scheduler" - ) - - if self.step_index is None: - self._init_step_index(timestep) - - # Improve numerical stability for small number of steps - lower_order_final = (self.step_index == len(self.timesteps) - 1) and ( - self.config.euler_at_final - or (self.config.lower_order_final and len(self.timesteps) < 15) - or self.config.final_sigmas_type == "zero" - ) - lower_order_second = ( - (self.step_index == len(self.timesteps) - 2) and self.config.lower_order_final and len(self.timesteps) < 15 - ) - - model_output = self.convert_model_output(model_output, sample=sample) - for i in range(self.config.solver_order - 1): - self.model_outputs[i] = self.model_outputs[i + 1] - self.model_outputs[-1] = model_output - - # Upcast to avoid precision issues when computing prev_sample - sample = sample.to(torch.float32) - if self.config.algorithm_type in ["sde-dpmsolver", "sde-dpmsolver++"] and variance_noise is None: - noise = randn_tensor( - model_output.shape, generator=generator, device=model_output.device, dtype=torch.float32 - ) - elif self.config.algorithm_type in ["sde-dpmsolver", "sde-dpmsolver++"]: - noise = variance_noise.to(device=model_output.device, dtype=torch.float32) - else: - noise = None - - if self.config.solver_order == 1 or self.lower_order_nums < 1 or lower_order_final: - prev_sample = self.dpm_solver_first_order_update(model_output, sample=sample, noise=noise) - elif self.config.solver_order == 2 or self.lower_order_nums < 2 or lower_order_second: - prev_sample = self.multistep_dpm_solver_second_order_update(self.model_outputs, sample=sample, noise=noise) - else: - prev_sample = self.multistep_dpm_solver_third_order_update(self.model_outputs, sample=sample) - - if self.lower_order_nums < self.config.solver_order: - self.lower_order_nums += 1 - - # Cast sample back to expected dtype - prev_sample = prev_sample.to(model_output.dtype) - - # upon completion increase step index by one - self._step_index += 1 - - if not return_dict: - return (prev_sample,) - - return SchedulerOutput(prev_sample=prev_sample) - - # Copied from diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler.scale_model_input - def scale_model_input(self, sample: torch.Tensor, *args, **kwargs) -> torch.Tensor: - """ - Ensures interchangeability with schedulers that need to scale the denoising model input depending on the - current timestep. - - Args: - sample (`torch.Tensor`): - The input sample. - - Returns: - `torch.Tensor`: - A scaled input sample. - """ - return sample - - # Copied from diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler.scale_model_input - def add_noise( - self, - original_samples: torch.Tensor, - noise: torch.Tensor, - timesteps: torch.IntTensor, - ) -> torch.Tensor: - # Make sure sigmas and timesteps have the same device and dtype as original_samples - sigmas = self.sigmas.to(device=original_samples.device, dtype=original_samples.dtype) - if original_samples.device.type == "mps" and torch.is_floating_point(timesteps): - # mps does not support float64 - schedule_timesteps = self.timesteps.to(original_samples.device, dtype=torch.float32) - timesteps = timesteps.to(original_samples.device, dtype=torch.float32) - else: - schedule_timesteps = self.timesteps.to(original_samples.device) - timesteps = timesteps.to(original_samples.device) - - # begin_index is None when the scheduler is used for training or pipeline does not implement set_begin_index - if self.begin_index is None: - step_indices = [self.index_for_timestep(t, schedule_timesteps) for t in timesteps] - elif self.step_index is not None: - # add_noise is called after first denoising step (for inpainting) - step_indices = [self.step_index] * timesteps.shape[0] - else: - # add noise is called before first denoising step to create initial latent(img2img) - step_indices = [self.begin_index] * timesteps.shape[0] - - sigma = sigmas[step_indices].flatten() - while len(sigma.shape) < len(original_samples.shape): - sigma = sigma.unsqueeze(-1) - - alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma) - noisy_samples = alpha_t * original_samples + sigma_t * noise - return noisy_samples - - def __len__(self): - return self.config.num_train_timesteps From 9e0ca0b72f6effe345af9686c0cc5ff31218714e Mon Sep 17 00:00:00 2001 From: Aryan Date: Fri, 13 Dec 2024 10:13:39 +0100 Subject: [PATCH 130/141] apply review suggestions --- src/diffusers/__init__.py | 2 -- src/diffusers/models/attention_processor.py | 35 ++++++------------- .../pipelines/pag/pipeline_pag_sana.py | 6 ++-- src/diffusers/pipelines/sana/pipeline_sana.py | 9 +++-- 4 files changed, 17 insertions(+), 35 deletions(-) diff --git a/src/diffusers/__init__.py b/src/diffusers/__init__.py index 9ffc93e82c3e..20914442b84a 100644 --- a/src/diffusers/__init__.py +++ b/src/diffusers/__init__.py @@ -187,7 +187,6 @@ "EDMEulerScheduler", "EulerAncestralDiscreteScheduler", "EulerDiscreteScheduler", - "FlowDPMSolverMultistepScheduler", "FlowMatchEulerDiscreteScheduler", "FlowMatchHeunDiscreteScheduler", "HeunDiscreteScheduler", @@ -692,7 +691,6 @@ EDMEulerScheduler, EulerAncestralDiscreteScheduler, EulerDiscreteScheduler, - FlowDPMSolverMultistepScheduler, FlowMatchEulerDiscreteScheduler, FlowMatchHeunDiscreteScheduler, HeunDiscreteScheduler, diff --git a/src/diffusers/models/attention_processor.py b/src/diffusers/models/attention_processor.py index 036953bd3819..8328baf6c000 100644 --- a/src/diffusers/models/attention_processor.py +++ b/src/diffusers/models/attention_processor.py @@ -5446,11 +5446,6 @@ class SanaLinearAttnProcessor2_0: Processor for implementing scaled dot-product linear attention. """ - def __init__(self, pad_val=1.0, eps=1e-15): - self.pad_val = pad_val - self.eps = eps - self.kernel_func = nn.ReLU(inplace=False) - def __call__( self, attn: Attention, @@ -5471,16 +5466,16 @@ def __call__( key = key.transpose(1, 2).unflatten(1, (attn.heads, -1)).transpose(2, 3) value = value.transpose(1, 2).unflatten(1, (attn.heads, -1)) - query = self.kernel_func(query) - key = self.kernel_func(key) + query = F.relu(query) + key = F.relu(key) query, key, value = query.float(), key.float(), value.float() - value = F.pad(value, (0, 0, 0, 1), mode="constant", value=self.pad_val) + value = F.pad(value, (0, 0, 0, 1), mode="constant", value=1.0) scores = torch.matmul(value, key) hidden_states = torch.matmul(scores, query) - hidden_states = hidden_states[:, :, :-1] / (hidden_states[:, :, -1:] + self.eps) + hidden_states = hidden_states[:, :, :-1] / (hidden_states[:, :, -1:] + 1e-15) hidden_states = hidden_states.flatten(1, 2).transpose(1, 2) hidden_states = hidden_states.to(original_dtype) @@ -5498,11 +5493,6 @@ class PAGCFGSanaLinearAttnProcessor2_0: Processor for implementing scaled dot-product linear attention. """ - def __init__(self, pad_val=1.0, eps=1e-15): - self.pad_val = pad_val - self.eps = eps - self.kernel_func = nn.ReLU(inplace=False) - def __call__( self, attn: Attention, @@ -5523,16 +5513,16 @@ def __call__( key = key.transpose(1, 2).unflatten(1, (attn.heads, -1)).transpose(2, 3) value = value.transpose(1, 2).unflatten(1, (attn.heads, -1)) - query = self.kernel_func(query) - key = self.kernel_func(key) + query = F.relu(query) + key = F.relu(key) query, key, value = query.float(), key.float(), value.float() - value = F.pad(value, (0, 0, 0, 1), mode="constant", value=self.pad_val) + value = F.pad(value, (0, 0, 0, 1), mode="constant", value=1.0) scores = torch.matmul(value, key) hidden_states_org = torch.matmul(scores, query) - hidden_states_org = hidden_states_org[:, :, :-1] / (hidden_states_org[:, :, -1:] + self.eps) + hidden_states_org = hidden_states_org[:, :, :-1] / (hidden_states_org[:, :, -1:] + 1e-15) hidden_states_org = hidden_states_org.flatten(1, 2).transpose(1, 2) hidden_states_org = hidden_states_org.to(original_dtype) @@ -5558,11 +5548,6 @@ class PAGIdentitySanaLinearAttnProcessor2_0: Processor for implementing scaled dot-product linear attention. """ - def __init__(self, pad_val=1.0, eps=1e-15): - self.pad_val = pad_val - self.eps = eps - self.kernel_func = nn.ReLU(inplace=False) - def __call__( self, attn: Attention, @@ -5587,14 +5572,14 @@ def __call__( query, key, value = query.float(), key.float(), value.float() - value = F.pad(value, (0, 0, 0, 1), mode="constant", value=self.pad_val) + value = F.pad(value, (0, 0, 0, 1), mode="constant", value=1.0) scores = torch.matmul(value, key) hidden_states_org = torch.matmul(scores, query) if hidden_states_org.dtype in [torch.float16, torch.bfloat16]: hidden_states_org = hidden_states_org.float() - hidden_states_org = hidden_states_org[:, :, :-1] / (hidden_states_org[:, :, -1:] + self.eps) + hidden_states_org = hidden_states_org[:, :, :-1] / (hidden_states_org[:, :, -1:] + 1e-15) hidden_states_org = hidden_states_org.flatten(1, 2).transpose(1, 2) hidden_states_org = hidden_states_org.to(original_dtype) diff --git a/src/diffusers/pipelines/pag/pipeline_pag_sana.py b/src/diffusers/pipelines/pag/pipeline_pag_sana.py index 983fea63fc99..e3d4173e5d8e 100644 --- a/src/diffusers/pipelines/pag/pipeline_pag_sana.py +++ b/src/diffusers/pipelines/pag/pipeline_pag_sana.py @@ -25,7 +25,7 @@ from ...image_processor import PixArtImageProcessor from ...models import AutoencoderDC, SanaTransformer2DModel from ...models.attention_processor import PAGCFGSanaLinearAttnProcessor2_0, PAGIdentitySanaLinearAttnProcessor2_0 -from ...schedulers import FlowDPMSolverMultistepScheduler +from ...schedulers import FlowMatchEulerDiscreteScheduler from ...utils import ( BACKENDS_MAPPING, is_bs4_available, @@ -140,7 +140,7 @@ def __init__( text_encoder: AutoModelForCausalLM, vae: AutoencoderDC, transformer: SanaTransformer2DModel, - scheduler: FlowDPMSolverMultistepScheduler, + scheduler: FlowMatchEulerDiscreteScheduler, pag_applied_layers: Union[str, List[str]] = "transformer_blocks.0", ): super().__init__() @@ -316,7 +316,7 @@ def check_inputs( prompt_attention_mask=None, negative_prompt_attention_mask=None, ): - if height % 8 != 0 or width % 8 != 0: + if height % 32 != 0 or width % 32 != 0: raise ValueError(f"`height` and `width` have to be divisible by 8 but are {height} and {width}.") if callback_on_step_end_tensor_inputs is not None and not all( diff --git a/src/diffusers/pipelines/sana/pipeline_sana.py b/src/diffusers/pipelines/sana/pipeline_sana.py index 14b576327a9a..9d5959b9e1ce 100644 --- a/src/diffusers/pipelines/sana/pipeline_sana.py +++ b/src/diffusers/pipelines/sana/pipeline_sana.py @@ -24,7 +24,7 @@ from ...callbacks import MultiPipelineCallbacks, PipelineCallback from ...image_processor import PixArtImageProcessor from ...models import AutoencoderDC, SanaTransformer2DModel -from ...schedulers import FlowDPMSolverMultistepScheduler +from ...schedulers import FlowMatchEulerDiscreteScheduler from ...utils import ( BACKENDS_MAPPING, is_bs4_available, @@ -137,7 +137,7 @@ def __init__( text_encoder: AutoModelForCausalLM, vae: AutoencoderDC, transformer: SanaTransformer2DModel, - scheduler: FlowDPMSolverMultistepScheduler, + scheduler: FlowMatchEulerDiscreteScheduler, ): super().__init__() @@ -187,8 +187,7 @@ def encode_prompt( Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not provided, text embeddings will be generated from `prompt` input argument. negative_prompt_embeds (`torch.Tensor`, *optional*): - Pre-generated negative text embeddings. For Sana, it's should be the embeddings of the "" - string. + Pre-generated negative text embeddings. For Sana, it's should be the embeddings of the "" string. clean_caption (`bool`, defaults to `False`): If `True`, the function will preprocess and clean the provided caption before encoding. max_sequence_length (`int`, defaults to 300): Maximum sequence length to use for the prompt. @@ -325,7 +324,7 @@ def check_inputs( prompt_attention_mask=None, negative_prompt_attention_mask=None, ): - if height % 8 != 0 or width % 8 != 0: + if height % 32 != 0 or width % 32 != 0: raise ValueError(f"`height` and `width` have to be divisible by 8 but are {height} and {width}.") if callback_on_step_end_tensor_inputs is not None and not all( From b3f721247a38173956419cd486791d21256a54a2 Mon Sep 17 00:00:00 2001 From: lawrence-cj Date: Fri, 13 Dec 2024 18:07:58 +0800 Subject: [PATCH 131/141] change the `FlowMatchEulerDiscreteScheduler` to default `DPMSolverMultistepScheduler` with flow matching scheduler. --- src/diffusers/pipelines/sana/pipeline_sana.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/diffusers/pipelines/sana/pipeline_sana.py b/src/diffusers/pipelines/sana/pipeline_sana.py index 9d5959b9e1ce..24d25dfe9300 100644 --- a/src/diffusers/pipelines/sana/pipeline_sana.py +++ b/src/diffusers/pipelines/sana/pipeline_sana.py @@ -24,7 +24,7 @@ from ...callbacks import MultiPipelineCallbacks, PipelineCallback from ...image_processor import PixArtImageProcessor from ...models import AutoencoderDC, SanaTransformer2DModel -from ...schedulers import FlowMatchEulerDiscreteScheduler +from ...schedulers import DPMSolverMultistepScheduler from ...utils import ( BACKENDS_MAPPING, is_bs4_available, @@ -137,7 +137,7 @@ def __init__( text_encoder: AutoModelForCausalLM, vae: AutoencoderDC, transformer: SanaTransformer2DModel, - scheduler: FlowMatchEulerDiscreteScheduler, + scheduler: DPMSolverMultistepScheduler, ): super().__init__() From b4af50d67f83a893420496ad1382186df8e91688 Mon Sep 17 00:00:00 2001 From: junsong Date: Fri, 13 Dec 2024 02:10:32 -0800 Subject: [PATCH 132/141] fix the tokenizer.padding_side='right' bug; --- src/diffusers/pipelines/sana/pipeline_sana.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/diffusers/pipelines/sana/pipeline_sana.py b/src/diffusers/pipelines/sana/pipeline_sana.py index 24d25dfe9300..9abe6139f8c3 100644 --- a/src/diffusers/pipelines/sana/pipeline_sana.py +++ b/src/diffusers/pipelines/sana/pipeline_sana.py @@ -165,7 +165,7 @@ def encode_prompt( negative_prompt_attention_mask: Optional[torch.Tensor] = None, clean_caption: bool = False, max_sequence_length: int = 300, - complex_human_instruction=None, + complex_human_instruction: Optional[List[str]] = None, ): r""" Encodes the prompt into text encoder hidden states. @@ -206,6 +206,8 @@ def encode_prompt( else: batch_size = prompt_embeds.shape[0] + self.tokenizer.padding_side = "right" + # See Section 3.1. of the paper. max_length = max_sequence_length select_index = [0] + list(range(-max_length + 1, 0)) @@ -325,7 +327,7 @@ def check_inputs( negative_prompt_attention_mask=None, ): if height % 32 != 0 or width % 32 != 0: - raise ValueError(f"`height` and `width` have to be divisible by 8 but are {height} and {width}.") + raise ValueError(f"`height` and `width` have to be divisible by 32 but are {height} and {width}.") if callback_on_step_end_tensor_inputs is not None and not all( k in self._callback_tensor_inputs for k in callback_on_step_end_tensor_inputs @@ -581,7 +583,7 @@ def __call__( callback_on_step_end_tensor_inputs: List[str] = ["latents"], max_sequence_length: int = 300, complex_human_instruction: list[str] = [ - 'Given a user prompt, generate an "Enhanced prompt" that provides detailed visual descriptions suitable for image generation. Evaluate the level of detail in the user prompt:', + "Given a user prompt, generate an 'Enhanced prompt' that provides detailed visual descriptions suitable for image generation. Evaluate the level of detail in the user prompt:", "- If the prompt is simple, focus on adding specifics about colors, shapes, sizes, textures, and spatial relationships to create vivid and concrete scenes.", "- If the prompt is already detailed, refine and enhance the existing details slightly without overcomplicating.", "Here are examples of how to transform or refine prompts:", From b7837c059ba69edc910f0b275f236d24d258fb72 Mon Sep 17 00:00:00 2001 From: Aryan Date: Sun, 15 Dec 2024 15:43:45 +0100 Subject: [PATCH 133/141] update docs --- .../en/api/models/sana_transformer2d.md | 4 +++- docs/source/en/api/pipelines/sana.md | 20 +++++++++++++++++++ 2 files changed, 23 insertions(+), 1 deletion(-) diff --git a/docs/source/en/api/models/sana_transformer2d.md b/docs/source/en/api/models/sana_transformer2d.md index b0550dd6b7d4..7fb8cdf5f7a7 100644 --- a/docs/source/en/api/models/sana_transformer2d.md +++ b/docs/source/en/api/models/sana_transformer2d.md @@ -20,7 +20,9 @@ The abstract from the paper is: The model can be loaded with the following code snippet. ```python -TODO(aryan) +from diffusers import SanaTransformer2DModel + +transformer = SanaTransformer2DModel.from_pretrained("Efficient-Large-Model/Sana_1600M_1024px_diffusers", subfolder="transformer", torch_dtype=torch.float16) ``` ## SanaTransformer2DModel diff --git a/docs/source/en/api/pipelines/sana.md b/docs/source/en/api/pipelines/sana.md index 153696f04c17..08ee497d9137 100644 --- a/docs/source/en/api/pipelines/sana.md +++ b/docs/source/en/api/pipelines/sana.md @@ -28,12 +28,32 @@ Make sure to check out the Schedulers [guide](../../using-diffusers/schedulers.m This pipeline was contributed by [lawrence-cj](https://github.com/lawrence-cj). The original codebase can be found [here](https://github.com/NVlabs/Sana). The original weights can be found under [hf.co/Efficient-Large-Model]https://huggingface.co/Efficient-Large-Model). +Available models: + +| Model | Recommended dtype | +|:-----:|:-----------------:| +| [`Efficient-Large-Model/Sana_1600M_1024px_diffusers`](https://huggingface.co/Efficient-Large-Model/Sana_1600M_1024px_diffusers) | `torch.float16` | +| [`Efficient-Large-Model/Sana_1600M_1024px_MultiLing_diffusers`](https://huggingface.co/Efficient-Large-Model/Sana_1600M_1024px_MultiLing_diffusers) | `torch.float16` | +| [`Efficient-Large-Model/Sana_1600M_1024px_BF16_diffusers`](https://huggingface.co/Efficient-Large-Model/Sana_1600M_1024px_BF16_diffusers) | `torch.bfloat16` | +| [`Efficient-Large-Model/Sana_1600M_512px_diffusers`](https://huggingface.co/Efficient-Large-Model/Sana_1600M_512px_diffusers) | `torch.float16` | +| [`Efficient-Large-Model/Sana_1600M_512px_MultiLing_diffusers`](https://huggingface.co/Efficient-Large-Model/Sana_1600M_512px_MultiLing_diffusers) | `torch.float16` | +| [`Efficient-Large-Model/Sana_600M_1024px_diffusers`](https://huggingface.co/Efficient-Large-Model/Sana_600M_1024px_diffusers) | `torch.float16` | +| [`Efficient-Large-Model/Sana_600M_512px_diffusers`](https://huggingface.co/Efficient-Large-Model/Sana_600M_512px_diffusers) | `torch.float16` | + +Refer to [this](https://huggingface.co/collections/Efficient-Large-Model/sana-673efba2a57ed99843f11f9e) collection for more information. + ## SanaPipeline [[autodoc]] SanaPipeline - all - __call__ +## SanaPAGPipeline + +[[autodoc]] SanaPAGPipeline + - all + - __call__ + ## SanaPipelineOutput [[autodoc]] pipelines.sana.pipeline_output.SanaPipelineOutput From 5fb973c4a3a22cf279a3c53a2730cce37a2d10d0 Mon Sep 17 00:00:00 2001 From: Aryan Date: Sun, 15 Dec 2024 15:52:41 +0100 Subject: [PATCH 134/141] make fix-copies --- .../pipelines/pag/pipeline_pag_sana.py | 41 ++++++++++++++++--- src/diffusers/pipelines/sana/pipeline_sana.py | 4 +- .../schedulers/scheduling_deis_multistep.py | 15 ++++++- .../scheduling_dpmsolver_multistep_inverse.py | 22 ++++++++-- .../scheduling_dpmsolver_singlestep.py | 15 ++++++- .../schedulers/scheduling_sasolver.py | 15 ++++++- .../schedulers/scheduling_unipc_multistep.py | 15 ++++++- src/diffusers/utils/dummy_pt_objects.py | 15 +++++++ .../dummy_torch_and_transformers_objects.py | 30 ++++++++++++++ 9 files changed, 153 insertions(+), 19 deletions(-) diff --git a/src/diffusers/pipelines/pag/pipeline_pag_sana.py b/src/diffusers/pipelines/pag/pipeline_pag_sana.py index e3d4173e5d8e..f965da34dc2e 100644 --- a/src/diffusers/pipelines/pag/pipeline_pag_sana.py +++ b/src/diffusers/pipelines/pag/pipeline_pag_sana.py @@ -171,6 +171,7 @@ def encode_prompt( negative_prompt_attention_mask: Optional[torch.Tensor] = None, clean_caption: bool = False, max_sequence_length: int = 300, + complex_human_instruction: Optional[List[str]] = None, ): r""" Encodes the prompt into text encoder hidden states. @@ -192,11 +193,13 @@ def encode_prompt( Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not provided, text embeddings will be generated from `prompt` input argument. negative_prompt_embeds (`torch.Tensor`, *optional*): - Pre-generated negative text embeddings. For PixArt-Alpha, it's should be the embeddings of the "" - string. + Pre-generated negative text embeddings. For Sana, it's should be the embeddings of the "" string. clean_caption (`bool`, defaults to `False`): If `True`, the function will preprocess and clean the provided caption before encoding. max_sequence_length (`int`, defaults to 300): Maximum sequence length to use for the prompt. + complex_human_instruction (`list[str]`, defaults to `complex_human_instruction`): + If `complex_human_instruction` is not empty, the function will use the complex Human instruction for + the prompt. """ if device is None: @@ -209,15 +212,28 @@ def encode_prompt( else: batch_size = prompt_embeds.shape[0] + self.tokenizer.padding_side = "right" + # See Section 3.1. of the paper. max_length = max_sequence_length + select_index = [0] + list(range(-max_length + 1, 0)) if prompt_embeds is None: prompt = self._text_preprocessing(prompt, clean_caption=clean_caption) + + # prepare complex human instruction + if not complex_human_instruction: + max_length_all = max_length + else: + chi_prompt = "\n".join(complex_human_instruction) + prompt = [chi_prompt + p for p in prompt] + num_chi_prompt_tokens = len(self.tokenizer.encode(chi_prompt)) + max_length_all = num_chi_prompt_tokens + max_length - 2 + text_inputs = self.tokenizer( prompt, padding="max_length", - max_length=max_length, + max_length=max_length_all, truncation=True, add_special_tokens=True, return_tensors="pt", @@ -228,7 +244,8 @@ def encode_prompt( prompt_attention_mask = prompt_attention_mask.to(device) prompt_embeds = self.text_encoder(text_input_ids.to(device), attention_mask=prompt_attention_mask) - prompt_embeds = prompt_embeds[0] + prompt_embeds = prompt_embeds[0][:, select_index] + prompt_attention_mask = prompt_attention_mask[:, select_index] if self.transformer is not None: dtype = self.transformer.dtype @@ -317,7 +334,7 @@ def check_inputs( negative_prompt_attention_mask=None, ): if height % 32 != 0 or width % 32 != 0: - raise ValueError(f"`height` and `width` have to be divisible by 8 but are {height} and {width}.") + raise ValueError(f"`height` and `width` have to be divisible by 32 but are {height} and {width}.") if callback_on_step_end_tensor_inputs is not None and not all( k in self._callback_tensor_inputs for k in callback_on_step_end_tensor_inputs @@ -573,6 +590,16 @@ def __call__( callback_on_step_end: Optional[Callable[[int, int, Dict], None]] = None, callback_on_step_end_tensor_inputs: List[str] = ["latents"], max_sequence_length: int = 300, + complex_human_instruction: List[str] = [ + "Given a user prompt, generate an 'Enhanced prompt' that provides detailed visual descriptions suitable for image generation. Evaluate the level of detail in the user prompt:", + "- If the prompt is simple, focus on adding specifics about colors, shapes, sizes, textures, and spatial relationships to create vivid and concrete scenes.", + "- If the prompt is already detailed, refine and enhance the existing details slightly without overcomplicating.", + "Here are examples of how to transform or refine prompts:", + "- User Prompt: A cat sleeping -> Enhanced: A small, fluffy white cat curled up in a round shape, sleeping peacefully on a warm sunny windowsill, surrounded by pots of blooming red flowers.", + "- User Prompt: A busy city street -> Enhanced: A bustling city street scene at dusk, featuring glowing street lamps, a diverse crowd of people in colorful clothing, and a double-decker bus passing by towering glass skyscrapers.", + "Please generate only the enhanced description for the prompt below and avoid including any additional commentary or evaluations:", + "User Prompt: ", + ], pag_scale: float = 3.0, pag_adaptive_scale: float = 0.0, ) -> Union[ImagePipelineOutput, Tuple]: @@ -652,6 +679,9 @@ def __call__( will be passed as `callback_kwargs` argument. You will only be able to include variables listed in the `._callback_tensor_inputs` attribute of your pipeline class. max_sequence_length (`int` defaults to 300): Maximum sequence length to use with the `prompt`. + complex_human_instruction (`List[str]`, *optional*): + Instructions for complex human attention: + https://github.com/NVlabs/Sana/blob/main/configs/sana_app_config/Sana_1600M_app.yaml#L55. pag_scale (`float`, *optional*, defaults to 3.0): The scale factor for the perturbed attention guidance. If it is set to 0.0, the perturbed attention guidance will not be used. @@ -727,6 +757,7 @@ def __call__( negative_prompt_attention_mask=negative_prompt_attention_mask, clean_caption=clean_caption, max_sequence_length=max_sequence_length, + complex_human_instruction=complex_human_instruction, ) if self.do_perturbed_attention_guidance: diff --git a/src/diffusers/pipelines/sana/pipeline_sana.py b/src/diffusers/pipelines/sana/pipeline_sana.py index 9abe6139f8c3..a4d0b2bced12 100644 --- a/src/diffusers/pipelines/sana/pipeline_sana.py +++ b/src/diffusers/pipelines/sana/pipeline_sana.py @@ -582,7 +582,7 @@ def __call__( callback_on_step_end: Optional[Callable[[int, int, Dict], None]] = None, callback_on_step_end_tensor_inputs: List[str] = ["latents"], max_sequence_length: int = 300, - complex_human_instruction: list[str] = [ + complex_human_instruction: List[str] = [ "Given a user prompt, generate an 'Enhanced prompt' that provides detailed visual descriptions suitable for image generation. Evaluate the level of detail in the user prompt:", "- If the prompt is simple, focus on adding specifics about colors, shapes, sizes, textures, and spatial relationships to create vivid and concrete scenes.", "- If the prompt is already detailed, refine and enhance the existing details slightly without overcomplicating.", @@ -670,7 +670,7 @@ def __call__( `._callback_tensor_inputs` attribute of your pipeline class. max_sequence_length (`int` defaults to `300`): Maximum sequence length to use with the `prompt`. - complex_human_instruction (`list[str]`, *optional*): + complex_human_instruction (`List[str]`, *optional*): Instructions for complex human attention: https://github.com/NVlabs/Sana/blob/main/configs/sana_app_config/Sana_1600M_app.yaml#L55. diff --git a/src/diffusers/schedulers/scheduling_deis_multistep.py b/src/diffusers/schedulers/scheduling_deis_multistep.py index 5aaecff780ee..31b374f72967 100644 --- a/src/diffusers/schedulers/scheduling_deis_multistep.py +++ b/src/diffusers/schedulers/scheduling_deis_multistep.py @@ -149,6 +149,8 @@ def __init__( use_karras_sigmas: Optional[bool] = False, use_exponential_sigmas: Optional[bool] = False, use_beta_sigmas: Optional[bool] = False, + use_flow_sigmas: Optional[bool] = False, + flow_shift: Optional[float] = 1.0, timestep_spacing: str = "linspace", steps_offset: int = 0, ): @@ -282,6 +284,11 @@ def set_timesteps(self, num_inference_steps: int, device: Union[str, torch.devic sigmas = self._convert_to_beta(in_sigmas=sigmas, num_inference_steps=num_inference_steps) timesteps = np.array([self._sigma_to_t(sigma, log_sigmas) for sigma in sigmas]) sigmas = np.concatenate([sigmas, sigmas[-1:]]).astype(np.float32) + elif self.config.use_flow_sigmas: + alphas = np.linspace(1, 1 / self.config.num_train_timesteps, num_inference_steps + 1) + sigmas = 1.0 - alphas + sigmas = np.flip(self.config.flow_shift * sigmas / (1 + (self.config.flow_shift - 1) * sigmas))[:-1] + timesteps = (sigmas * self.config.num_train_timesteps).copy() else: sigmas = np.interp(timesteps, np.arange(0, len(sigmas)), sigmas) sigma_last = ((1 - self.alphas_cumprod[0]) / self.alphas_cumprod[0]) ** 0.5 @@ -362,8 +369,12 @@ def _sigma_to_t(self, sigma, log_sigmas): # Copied from diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler._sigma_to_alpha_sigma_t def _sigma_to_alpha_sigma_t(self, sigma): - alpha_t = 1 / ((sigma**2 + 1) ** 0.5) - sigma_t = sigma * alpha_t + if self.config.use_flow_sigmas: + alpha_t = 1 - sigma + sigma_t = sigma + else: + alpha_t = 1 / ((sigma**2 + 1) ** 0.5) + sigma_t = sigma * alpha_t return alpha_t, sigma_t diff --git a/src/diffusers/schedulers/scheduling_dpmsolver_multistep_inverse.py b/src/diffusers/schedulers/scheduling_dpmsolver_multistep_inverse.py index 2968d0ef7b8e..fa49634ba9ee 100644 --- a/src/diffusers/schedulers/scheduling_dpmsolver_multistep_inverse.py +++ b/src/diffusers/schedulers/scheduling_dpmsolver_multistep_inverse.py @@ -169,6 +169,8 @@ def __init__( use_karras_sigmas: Optional[bool] = False, use_exponential_sigmas: Optional[bool] = False, use_beta_sigmas: Optional[bool] = False, + use_flow_sigmas: Optional[bool] = False, + flow_shift: Optional[float] = 1.0, lambda_min_clipped: float = -float("inf"), variance_type: Optional[str] = None, timestep_spacing: str = "linspace", @@ -292,6 +294,11 @@ def set_timesteps(self, num_inference_steps: int = None, device: Union[str, torc elif self.config.use_beta_sigmas: sigmas = self._convert_to_beta(in_sigmas=sigmas, num_inference_steps=num_inference_steps) timesteps = np.array([self._sigma_to_t(sigma, log_sigmas) for sigma in sigmas]) + elif self.config.use_flow_sigmas: + alphas = np.linspace(1, 1 / self.config.num_train_timesteps, num_inference_steps + 1) + sigmas = 1.0 - alphas + sigmas = np.flip(self.config.flow_shift * sigmas / (1 + (self.config.flow_shift - 1) * sigmas))[:-1] + timesteps = (sigmas * self.config.num_train_timesteps).copy() else: sigmas = np.interp(timesteps, np.arange(0, len(sigmas)), sigmas) sigma_max = ( @@ -379,8 +386,12 @@ def _sigma_to_t(self, sigma, log_sigmas): # Copied from diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler._sigma_to_alpha_sigma_t def _sigma_to_alpha_sigma_t(self, sigma): - alpha_t = 1 / ((sigma**2 + 1) ** 0.5) - sigma_t = sigma * alpha_t + if self.config.use_flow_sigmas: + alpha_t = 1 - sigma + sigma_t = sigma + else: + alpha_t = 1 / ((sigma**2 + 1) ** 0.5) + sigma_t = sigma * alpha_t return alpha_t, sigma_t @@ -522,10 +533,13 @@ def convert_model_output( sigma = self.sigmas[self.step_index] alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma) x0_pred = alpha_t * sample - sigma_t * model_output + elif self.config.prediction_type == "flow_prediction": + sigma_t = self.sigmas[self.step_index] + x0_pred = sample - sigma_t * model_output else: raise ValueError( - f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`, or" - " `v_prediction` for the DPMSolverMultistepScheduler." + f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`," + " `v_prediction`, or `flow_prediction` for the DPMSolverMultistepScheduler." ) if self.config.thresholding: diff --git a/src/diffusers/schedulers/scheduling_dpmsolver_singlestep.py b/src/diffusers/schedulers/scheduling_dpmsolver_singlestep.py index 02af15ae5c6a..ec5df84db789 100644 --- a/src/diffusers/schedulers/scheduling_dpmsolver_singlestep.py +++ b/src/diffusers/schedulers/scheduling_dpmsolver_singlestep.py @@ -164,6 +164,8 @@ def __init__( use_karras_sigmas: Optional[bool] = False, use_exponential_sigmas: Optional[bool] = False, use_beta_sigmas: Optional[bool] = False, + use_flow_sigmas: Optional[bool] = False, + flow_shift: Optional[float] = 1.0, final_sigmas_type: Optional[str] = "zero", # "zero", "sigma_min" lambda_min_clipped: float = -float("inf"), variance_type: Optional[str] = None, @@ -356,6 +358,11 @@ def set_timesteps( sigmas = np.flip(sigmas).copy() sigmas = self._convert_to_beta(in_sigmas=sigmas, num_inference_steps=num_inference_steps) timesteps = np.array([self._sigma_to_t(sigma, log_sigmas) for sigma in sigmas]) + elif self.config.use_flow_sigmas: + alphas = np.linspace(1, 1 / self.config.num_train_timesteps, num_inference_steps + 1) + sigmas = 1.0 - alphas + sigmas = np.flip(self.config.flow_shift * sigmas / (1 + (self.config.flow_shift - 1) * sigmas))[:-1] + timesteps = (sigmas * self.config.num_train_timesteps).copy() else: sigmas = np.interp(timesteps, np.arange(0, len(sigmas)), sigmas) @@ -454,8 +461,12 @@ def _sigma_to_t(self, sigma, log_sigmas): # Copied from diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler._sigma_to_alpha_sigma_t def _sigma_to_alpha_sigma_t(self, sigma): - alpha_t = 1 / ((sigma**2 + 1) ** 0.5) - sigma_t = sigma * alpha_t + if self.config.use_flow_sigmas: + alpha_t = 1 - sigma + sigma_t = sigma + else: + alpha_t = 1 / ((sigma**2 + 1) ** 0.5) + sigma_t = sigma * alpha_t return alpha_t, sigma_t diff --git a/src/diffusers/schedulers/scheduling_sasolver.py b/src/diffusers/schedulers/scheduling_sasolver.py index edccb245b6aa..1ddd35295169 100644 --- a/src/diffusers/schedulers/scheduling_sasolver.py +++ b/src/diffusers/schedulers/scheduling_sasolver.py @@ -167,6 +167,8 @@ def __init__( use_karras_sigmas: Optional[bool] = False, use_exponential_sigmas: Optional[bool] = False, use_beta_sigmas: Optional[bool] = False, + use_flow_sigmas: Optional[bool] = False, + flow_shift: Optional[float] = 1.0, lambda_min_clipped: float = -float("inf"), variance_type: Optional[str] = None, timestep_spacing: str = "linspace", @@ -311,6 +313,11 @@ def set_timesteps(self, num_inference_steps: int = None, device: Union[str, torc sigmas = self._convert_to_beta(in_sigmas=sigmas, num_inference_steps=num_inference_steps) timesteps = np.array([self._sigma_to_t(sigma, log_sigmas) for sigma in sigmas]) sigmas = np.concatenate([sigmas, sigmas[-1:]]).astype(np.float32) + elif self.config.use_flow_sigmas: + alphas = np.linspace(1, 1 / self.config.num_train_timesteps, num_inference_steps + 1) + sigmas = 1.0 - alphas + sigmas = np.flip(self.config.flow_shift * sigmas / (1 + (self.config.flow_shift - 1) * sigmas))[:-1] + timesteps = (sigmas * self.config.num_train_timesteps).copy() else: sigmas = np.interp(timesteps, np.arange(0, len(sigmas)), sigmas) sigma_last = ((1 - self.alphas_cumprod[0]) / self.alphas_cumprod[0]) ** 0.5 @@ -391,8 +398,12 @@ def _sigma_to_t(self, sigma, log_sigmas): # Copied from diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler._sigma_to_alpha_sigma_t def _sigma_to_alpha_sigma_t(self, sigma): - alpha_t = 1 / ((sigma**2 + 1) ** 0.5) - sigma_t = sigma * alpha_t + if self.config.use_flow_sigmas: + alpha_t = 1 - sigma + sigma_t = sigma + else: + alpha_t = 1 / ((sigma**2 + 1) ** 0.5) + sigma_t = sigma * alpha_t return alpha_t, sigma_t diff --git a/src/diffusers/schedulers/scheduling_unipc_multistep.py b/src/diffusers/schedulers/scheduling_unipc_multistep.py index 1cc83a4dac28..60587400e9b7 100644 --- a/src/diffusers/schedulers/scheduling_unipc_multistep.py +++ b/src/diffusers/schedulers/scheduling_unipc_multistep.py @@ -206,6 +206,8 @@ def __init__( use_karras_sigmas: Optional[bool] = False, use_exponential_sigmas: Optional[bool] = False, use_beta_sigmas: Optional[bool] = False, + use_flow_sigmas: Optional[bool] = False, + flow_shift: Optional[float] = 1.0, timestep_spacing: str = "linspace", steps_offset: int = 0, final_sigmas_type: Optional[str] = "zero", # "zero", "sigma_min" @@ -374,6 +376,11 @@ def set_timesteps(self, num_inference_steps: int, device: Union[str, torch.devic f"`final_sigmas_type` must be one of 'zero', or 'sigma_min', but got {self.config.final_sigmas_type}" ) sigmas = np.concatenate([sigmas, [sigma_last]]).astype(np.float32) + elif self.config.use_flow_sigmas: + alphas = np.linspace(1, 1 / self.config.num_train_timesteps, num_inference_steps + 1) + sigmas = 1.0 - alphas + sigmas = np.flip(self.config.flow_shift * sigmas / (1 + (self.config.flow_shift - 1) * sigmas))[:-1] + timesteps = (sigmas * self.config.num_train_timesteps).copy() else: sigmas = np.interp(timesteps, np.arange(0, len(sigmas)), sigmas) if self.config.final_sigmas_type == "sigma_min": @@ -464,8 +471,12 @@ def _sigma_to_t(self, sigma, log_sigmas): # Copied from diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler._sigma_to_alpha_sigma_t def _sigma_to_alpha_sigma_t(self, sigma): - alpha_t = 1 / ((sigma**2 + 1) ** 0.5) - sigma_t = sigma * alpha_t + if self.config.use_flow_sigmas: + alpha_t = 1 - sigma + sigma_t = sigma + else: + alpha_t = 1 / ((sigma**2 + 1) ** 0.5) + sigma_t = sigma * alpha_t return alpha_t, sigma_t diff --git a/src/diffusers/utils/dummy_pt_objects.py b/src/diffusers/utils/dummy_pt_objects.py index 1c3a6123a469..0f2aad5c5000 100644 --- a/src/diffusers/utils/dummy_pt_objects.py +++ b/src/diffusers/utils/dummy_pt_objects.py @@ -557,6 +557,21 @@ def from_pretrained(cls, *args, **kwargs): requires_backends(cls, ["torch"]) +class SanaTransformer2DModel(metaclass=DummyObject): + _backends = ["torch"] + + def __init__(self, *args, **kwargs): + requires_backends(self, ["torch"]) + + @classmethod + def from_config(cls, *args, **kwargs): + requires_backends(cls, ["torch"]) + + @classmethod + def from_pretrained(cls, *args, **kwargs): + requires_backends(cls, ["torch"]) + + class SD3ControlNetModel(metaclass=DummyObject): _backends = ["torch"] diff --git a/src/diffusers/utils/dummy_torch_and_transformers_objects.py b/src/diffusers/utils/dummy_torch_and_transformers_objects.py index 55a2a3df7572..8aefce9d624e 100644 --- a/src/diffusers/utils/dummy_torch_and_transformers_objects.py +++ b/src/diffusers/utils/dummy_torch_and_transformers_objects.py @@ -1262,6 +1262,36 @@ def from_pretrained(cls, *args, **kwargs): requires_backends(cls, ["torch", "transformers"]) +class SanaPAGPipeline(metaclass=DummyObject): + _backends = ["torch", "transformers"] + + def __init__(self, *args, **kwargs): + requires_backends(self, ["torch", "transformers"]) + + @classmethod + def from_config(cls, *args, **kwargs): + requires_backends(cls, ["torch", "transformers"]) + + @classmethod + def from_pretrained(cls, *args, **kwargs): + requires_backends(cls, ["torch", "transformers"]) + + +class SanaPipeline(metaclass=DummyObject): + _backends = ["torch", "transformers"] + + def __init__(self, *args, **kwargs): + requires_backends(self, ["torch", "transformers"]) + + @classmethod + def from_config(cls, *args, **kwargs): + requires_backends(cls, ["torch", "transformers"]) + + @classmethod + def from_pretrained(cls, *args, **kwargs): + requires_backends(cls, ["torch", "transformers"]) + + class SemanticStableDiffusionPipeline(metaclass=DummyObject): _backends = ["torch", "transformers"] From 168a0af7967488d38f96bf3a42542d2e83f8e277 Mon Sep 17 00:00:00 2001 From: Aryan Date: Sun, 15 Dec 2024 16:09:36 +0100 Subject: [PATCH 135/141] fix imports --- src/diffusers/pipelines/sana/__init__.py | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/src/diffusers/pipelines/sana/__init__.py b/src/diffusers/pipelines/sana/__init__.py index 0cbbcb048120..53b6ba762466 100644 --- a/src/diffusers/pipelines/sana/__init__.py +++ b/src/diffusers/pipelines/sana/__init__.py @@ -32,13 +32,7 @@ except OptionalDependencyNotAvailable: from ...utils.dummy_torch_and_transformers_objects import * else: - from .pipeline_sana import ( - ASPECT_RATIO_256_BIN, - ASPECT_RATIO_512_BIN, - ASPECT_RATIO_1024_BIN, - ASPECT_RATIO_2048_BIN, - SanaPipeline, - ) + from .pipeline_sana import SanaPipeline else: import sys From 0d722cb08791e6ef6d0ff65cb28c780913f68959 Mon Sep 17 00:00:00 2001 From: Aryan Date: Sun, 15 Dec 2024 16:13:28 +0100 Subject: [PATCH 136/141] fix docs --- docs/source/en/api/models/sana_transformer2d.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/en/api/models/sana_transformer2d.md b/docs/source/en/api/models/sana_transformer2d.md index 7fb8cdf5f7a7..fd56d028818f 100644 --- a/docs/source/en/api/models/sana_transformer2d.md +++ b/docs/source/en/api/models/sana_transformer2d.md @@ -27,7 +27,7 @@ transformer = SanaTransformer2DModel.from_pretrained("Efficient-Large-Model/Sana ## SanaTransformer2DModel -[[autodoc]] SanaPlusTransformer2DModel +[[autodoc]] SanaTransformer2DModel ## Transformer2DModelOutput From 0d32ef584e00ad0334d7b8cf6c8589648d159984 Mon Sep 17 00:00:00 2001 From: Aryan Date: Sun, 15 Dec 2024 17:20:12 +0100 Subject: [PATCH 137/141] add integration test --- tests/pipelines/sana/test_sana.py | 76 ++++++++++++++++++++++++++++++- 1 file changed, 75 insertions(+), 1 deletion(-) diff --git a/tests/pipelines/sana/test_sana.py b/tests/pipelines/sana/test_sana.py index ae2883225a04..0fb857b474ae 100644 --- a/tests/pipelines/sana/test_sana.py +++ b/tests/pipelines/sana/test_sana.py @@ -12,6 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. +import gc import inspect import unittest @@ -20,7 +21,12 @@ from transformers import Gemma2Config, Gemma2ForCausalLM, GemmaTokenizer from diffusers import AutoencoderDC, FlowMatchEulerDiscreteScheduler, SanaPipeline, SanaTransformer2DModel -from diffusers.utils.testing_utils import enable_full_determinism, torch_device +from diffusers.utils.testing_utils import ( + enable_full_determinism, + require_torch_gpu, + slow, + torch_device, +) from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS from ..test_pipelines_common import PipelineTesterMixin, to_np @@ -263,3 +269,71 @@ def test_inference_batch_single_identical(self): def test_float16_inference(self): # Requires higher tolerance as model seems very sensitive to dtype super().test_float16_inference(expected_max_diff=0.08) + + +@slow +@require_torch_gpu +class SanaPipelineIntegrationTests(unittest.TestCase): + prompt = "A painting of a squirrel eating a burger." + + def setUp(self): + super().setUp() + gc.collect() + torch.cuda.empty_cache() + + def tearDown(self): + super().tearDown() + gc.collect() + torch.cuda.empty_cache() + + def test_sana_1024(self): + generator = torch.Generator("cpu").manual_seed(0) + + pipe = SanaPipeline.from_pretrained( + "Efficient-Large-Model/Sana_1600M_1024px_diffusers", torch_dtype=torch.float16 + ) + pipe.enable_model_cpu_offload() + + image = pipe( + prompt=self.prompt, + height=1024, + width=1024, + generator=generator, + num_inference_steps=20, + output_type="np", + ).images[0] + + image = image.flatten() + output_slice = np.concatenate((image[:16], image[-16:])) + + # fmt: off + expected_slice = np.array([0.0427, 0.0789, 0.0662, 0.0464, 0.082, 0.0574, 0.0535, 0.0886, 0.0647, 0.0549, 0.0872, 0.0605, 0.0593, 0.0942, 0.0674, 0.0581, 0.0076, 0.0168, 0.0027, 0.0063, 0.0159, 0.0, 0.0071, 0.0198, 0.0034, 0.0105, 0.0212, 0.0, 0.0, 0.0166, 0.0042, 0.0125]) + # fmt: on + + self.assertTrue(np.allclose(output_slice, expected_slice, atol=1e-4)) + + def test_sana_512(self): + generator = torch.Generator("cpu").manual_seed(0) + + pipe = SanaPipeline.from_pretrained( + "Efficient-Large-Model/Sana_1600M_512px_diffusers", torch_dtype=torch.float16 + ) + pipe.enable_model_cpu_offload() + + image = pipe( + prompt=self.prompt, + height=512, + width=512, + generator=generator, + num_inference_steps=20, + output_type="np", + ).images[0] + + image = image.flatten() + output_slice = np.concatenate((image[:16], image[-16:])) + + # fmt: off + expected_slice = np.array([0.0803, 0.0774, 0.1108, 0.0872, 0.093, 0.1118, 0.0952, 0.0898, 0.1038, 0.0818, 0.0754, 0.0894, 0.074, 0.0691, 0.0906, 0.0671, 0.0154, 0.0254, 0.0203, 0.0178, 0.0283, 0.0193, 0.0215, 0.0273, 0.0188, 0.0212, 0.0273, 0.0151, 0.0061, 0.0244, 0.0212, 0.0259]) + # fmt: on + + self.assertTrue(np.allclose(output_slice, expected_slice, atol=1e-4)) From ea7878cad730680fd7c0125a8ded8bf80d7b5c61 Mon Sep 17 00:00:00 2001 From: Aryan Date: Sun, 15 Dec 2024 17:20:51 +0100 Subject: [PATCH 138/141] update docs --- docs/source/en/api/pipelines/sana.md | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/docs/source/en/api/pipelines/sana.md b/docs/source/en/api/pipelines/sana.md index 08ee497d9137..f65faf46c2b9 100644 --- a/docs/source/en/api/pipelines/sana.md +++ b/docs/source/en/api/pipelines/sana.md @@ -42,6 +42,12 @@ Available models: Refer to [this](https://huggingface.co/collections/Efficient-Large-Model/sana-673efba2a57ed99843f11f9e) collection for more information. + + +Make sure to pass the `variant` argument for downloaded checkpoints to use lower disk space. Set it to `"fp16"` for models with recommended dtype as `torch.float16`, and `"bf16"` for models with recommended dtype as `torch.bfloat16`. By default, `torch.float32` weights are downloaded, which use twice the amount of disk storage. Additionally, `torch.float32` weights can be downcasted on-the-fly by specifying the `torch_dtype` argument. Read about it in the [docs](https://huggingface.co/docs/diffusers/v0.31.0/en/api/pipelines/overview#diffusers.DiffusionPipeline.from_pretrained). + + + ## SanaPipeline [[autodoc]] SanaPipeline From 884d29e8492fea12e311348873dd4d288ea9fc59 Mon Sep 17 00:00:00 2001 From: Aryan Date: Sun, 15 Dec 2024 17:27:53 +0100 Subject: [PATCH 139/141] update examples --- src/diffusers/pipelines/pag/pipeline_pag_sana.py | 15 ++++++++++++++- src/diffusers/pipelines/sana/pipeline_sana.py | 13 ++++++++++++- 2 files changed, 26 insertions(+), 2 deletions(-) diff --git a/src/diffusers/pipelines/pag/pipeline_pag_sana.py b/src/diffusers/pipelines/pag/pipeline_pag_sana.py index f965da34dc2e..081dbef21e5c 100644 --- a/src/diffusers/pipelines/pag/pipeline_pag_sana.py +++ b/src/diffusers/pipelines/pag/pipeline_pag_sana.py @@ -55,7 +55,20 @@ EXAMPLE_DOC_STRING = """ Examples: ```py - # TODO(aryan): once the weights are hosted + >>> import torch + >>> from diffusers import SanaPAGPipeline + + >>> pipe = SanaPAGPipeline.from_pretrained( + ... "Efficient-Large-Model/Sana_1600M_1024px_diffusers", + ... pag_applied_layers=["transformer_blocks.8"], + ... torch_dtype=torch.float32, + ... ) + >>> pipe.to("cuda") + >>> pipe.text_encoder.to(torch.bfloat16) + >>> pipe.transformer = pipe.transformer.to(torch.float16) + + >>> image = pipe(prompt='a cyberpunk cat with a neon sign that says "Sana"')[0] + >>> image[0].save("output.png") ``` """ diff --git a/src/diffusers/pipelines/sana/pipeline_sana.py b/src/diffusers/pipelines/sana/pipeline_sana.py index a4d0b2bced12..80736d498e0f 100644 --- a/src/diffusers/pipelines/sana/pipeline_sana.py +++ b/src/diffusers/pipelines/sana/pipeline_sana.py @@ -54,7 +54,18 @@ EXAMPLE_DOC_STRING = """ Examples: ```py - # TODO(aryan): once the weights are hosted + >>> import torch + >>> from diffusers import SanaPipeline + + >>> pipe = SanaPipeline.from_pretrained( + ... "Efficient-Large-Model/Sana_1600M_1024px_diffusers", torch_dtype=torch.float32 + ... ) + >>> pipe.to("cuda") + >>> pipe.text_encoder.to(torch.bfloat16) + >>> pipe.transformer = pipe.transformer.to(torch.float16) + + >>> image = pipe(prompt='a cyberpunk cat with a neon sign that says "Sana"')[0] + >>> image[0].save("output.png") ``` """ From 1bc15548e27f151c2961bc01e339ecb21546328a Mon Sep 17 00:00:00 2001 From: Aryan Date: Sun, 15 Dec 2024 17:35:23 +0100 Subject: [PATCH 140/141] fix convert_model_output in schedulers --- src/diffusers/schedulers/scheduling_deis_multistep.py | 7 +++++-- src/diffusers/schedulers/scheduling_dpmsolver_multistep.py | 4 ++-- .../schedulers/scheduling_dpmsolver_multistep_inverse.py | 4 ++-- .../schedulers/scheduling_dpmsolver_singlestep.py | 7 +++++-- src/diffusers/schedulers/scheduling_sasolver.py | 7 +++++-- src/diffusers/schedulers/scheduling_unipc_multistep.py | 7 +++++-- 6 files changed, 24 insertions(+), 12 deletions(-) diff --git a/src/diffusers/schedulers/scheduling_deis_multistep.py b/src/diffusers/schedulers/scheduling_deis_multistep.py index 31b374f72967..17d3c25761f0 100644 --- a/src/diffusers/schedulers/scheduling_deis_multistep.py +++ b/src/diffusers/schedulers/scheduling_deis_multistep.py @@ -501,10 +501,13 @@ def convert_model_output( x0_pred = model_output elif self.config.prediction_type == "v_prediction": x0_pred = alpha_t * sample - sigma_t * model_output + elif self.config.prediction_type == "flow_prediction": + sigma_t = self.sigmas[self.step_index] + x0_pred = sample - sigma_t * model_output else: raise ValueError( - f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`, or" - " `v_prediction` for the DEISMultistepScheduler." + f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`, " + "`v_prediction`, or `flow_prediction` for the DEISMultistepScheduler." ) if self.config.thresholding: diff --git a/src/diffusers/schedulers/scheduling_dpmsolver_multistep.py b/src/diffusers/schedulers/scheduling_dpmsolver_multistep.py index 910f519a4e68..3547b3edd543 100644 --- a/src/diffusers/schedulers/scheduling_dpmsolver_multistep.py +++ b/src/diffusers/schedulers/scheduling_dpmsolver_multistep.py @@ -666,8 +666,8 @@ def convert_model_output( x0_pred = sample - sigma_t * model_output else: raise ValueError( - f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`," - " `v_prediction`, or `flow_prediction` for the DPMSolverMultistepScheduler." + f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`, " + "`v_prediction`, or `flow_prediction` for the DPMSolverMultistepScheduler." ) if self.config.thresholding: diff --git a/src/diffusers/schedulers/scheduling_dpmsolver_multistep_inverse.py b/src/diffusers/schedulers/scheduling_dpmsolver_multistep_inverse.py index fa49634ba9ee..540f7fd84bd7 100644 --- a/src/diffusers/schedulers/scheduling_dpmsolver_multistep_inverse.py +++ b/src/diffusers/schedulers/scheduling_dpmsolver_multistep_inverse.py @@ -538,8 +538,8 @@ def convert_model_output( x0_pred = sample - sigma_t * model_output else: raise ValueError( - f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`," - " `v_prediction`, or `flow_prediction` for the DPMSolverMultistepScheduler." + f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`, " + "`v_prediction`, or `flow_prediction` for the DPMSolverMultistepScheduler." ) if self.config.thresholding: diff --git a/src/diffusers/schedulers/scheduling_dpmsolver_singlestep.py b/src/diffusers/schedulers/scheduling_dpmsolver_singlestep.py index ec5df84db789..c300f966dbfb 100644 --- a/src/diffusers/schedulers/scheduling_dpmsolver_singlestep.py +++ b/src/diffusers/schedulers/scheduling_dpmsolver_singlestep.py @@ -606,10 +606,13 @@ def convert_model_output( sigma = self.sigmas[self.step_index] alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma) x0_pred = alpha_t * sample - sigma_t * model_output + elif self.config.prediction_type == "flow_prediction": + sigma_t = self.sigmas[self.step_index] + x0_pred = sample - sigma_t * model_output else: raise ValueError( - f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`, or" - " `v_prediction` for the DPMSolverSinglestepScheduler." + f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`, " + "`v_prediction`, or `flow_prediction` for the DPMSolverSinglestepScheduler." ) if self.config.thresholding: diff --git a/src/diffusers/schedulers/scheduling_sasolver.py b/src/diffusers/schedulers/scheduling_sasolver.py index 1ddd35295169..bef6d11973a2 100644 --- a/src/diffusers/schedulers/scheduling_sasolver.py +++ b/src/diffusers/schedulers/scheduling_sasolver.py @@ -542,10 +542,13 @@ def convert_model_output( x0_pred = model_output elif self.config.prediction_type == "v_prediction": x0_pred = alpha_t * sample - sigma_t * model_output + elif self.config.prediction_type == "flow_prediction": + sigma_t = self.sigmas[self.step_index] + x0_pred = sample - sigma_t * model_output else: raise ValueError( - f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`, or" - " `v_prediction` for the SASolverScheduler." + f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`, " + "`v_prediction`, or `flow_prediction` for the SASolverScheduler." ) if self.config.thresholding: diff --git a/src/diffusers/schedulers/scheduling_unipc_multistep.py b/src/diffusers/schedulers/scheduling_unipc_multistep.py index 60587400e9b7..2f6883c5da6b 100644 --- a/src/diffusers/schedulers/scheduling_unipc_multistep.py +++ b/src/diffusers/schedulers/scheduling_unipc_multistep.py @@ -605,10 +605,13 @@ def convert_model_output( x0_pred = model_output elif self.config.prediction_type == "v_prediction": x0_pred = alpha_t * sample - sigma_t * model_output + elif self.config.prediction_type == "flow_prediction": + sigma_t = self.sigmas[self.step_index] + x0_pred = sample - sigma_t * model_output else: raise ValueError( - f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`, or" - " `v_prediction` for the UniPCMultistepScheduler." + f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`, " + "`v_prediction`, or `flow_prediction` for the UniPCMultistepScheduler." ) if self.config.thresholding: From cb212893c242a1e84bffe876396d08433c7d258b Mon Sep 17 00:00:00 2001 From: Aryan Date: Sun, 15 Dec 2024 17:44:45 +0100 Subject: [PATCH 141/141] fix failing tests --- src/diffusers/models/attention_processor.py | 4 ++-- tests/pipelines/pag/test_pag_sana.py | 1 + tests/pipelines/sana/test_sana.py | 1 + 3 files changed, 4 insertions(+), 2 deletions(-) diff --git a/src/diffusers/models/attention_processor.py b/src/diffusers/models/attention_processor.py index 8328baf6c000..77e35364ab09 100644 --- a/src/diffusers/models/attention_processor.py +++ b/src/diffusers/models/attention_processor.py @@ -5567,8 +5567,8 @@ def __call__( key = key.transpose(1, 2).unflatten(1, (attn.heads, -1)).transpose(2, 3) value = value.transpose(1, 2).unflatten(1, (attn.heads, -1)) - query = self.kernel_func(query) - key = self.kernel_func(key) + query = F.relu(query) + key = F.relu(key) query, key, value = query.float(), key.float(), value.float() diff --git a/tests/pipelines/pag/test_pag_sana.py b/tests/pipelines/pag/test_pag_sana.py index 227ad16f468d..12addabeb0a8 100644 --- a/tests/pipelines/pag/test_pag_sana.py +++ b/tests/pipelines/pag/test_pag_sana.py @@ -140,6 +140,7 @@ def get_dummy_inputs(self, device, seed=0): "width": 32, "max_sequence_length": 16, "output_type": "pt", + "complex_human_instruction": None, } return inputs diff --git a/tests/pipelines/sana/test_sana.py b/tests/pipelines/sana/test_sana.py index 0fb857b474ae..f8551fff8447 100644 --- a/tests/pipelines/sana/test_sana.py +++ b/tests/pipelines/sana/test_sana.py @@ -139,6 +139,7 @@ def get_dummy_inputs(self, device, seed=0): "width": 32, "max_sequence_length": 16, "output_type": "pt", + "complex_human_instruction": None, } return inputs

MsI<CGe+4B0_kaGMiJJqWLW@6s(HlHH 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%0DOZ+GgPV)yZ!@`4bIOqPt8`h|eoz0{=L|T1 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

MsI<CGe+4B0_kaGMiJJqWLW@6s(HlHH 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%0DOZ+GgPV)yZ!@`4bIOqPt8`h|eoz0{=L|T1 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