| import torch.nn |
| from ldm_patched.ldm.util import instantiate_from_config |
| from ldm_patched.modules.model_management import unet_dtype, text_encoder_dtype, get_torch_device |
| from lightning_fabric.utilities.device_dtype_mixin import _DeviceDtypeModuleMixin |
| from omegaconf import OmegaConf |
| from modules.shared import opts |
|
|
|
|
| def _alpha(): |
| from ldm_patched.ldm.modules.diffusionmodules.util import make_beta_schedule |
| import numpy as np |
|
|
| betas = make_beta_schedule("linear", 1000, linear_start=0.00085, linear_end=0.0120) |
| return np.cumprod(1.0 - betas, axis=0) |
|
|
|
|
| class DiffusionEngine(_DeviceDtypeModuleMixin, torch.nn.Module): |
| def __init__( |
| self, |
| network_config: OmegaConf, |
| denoiser_config: OmegaConf, |
| first_stage_config: OmegaConf, |
| conditioner_config: OmegaConf, |
| scale_factor: float = 1.0, |
| disable_first_stage_autocast=False, |
| input_key: str = "jpg", |
| *args, |
| **kwargs, |
| ): |
| super().__init__() |
| self.input_key = input_key |
| self.model = DiffusionWrapper(network_config) |
| self.denoiser = instantiate_from_config(denoiser_config) |
| self.sampler = None |
| self.conditioner = instantiate_from_config(conditioner_config) |
| self.instantiate_first_stage(first_stage_config) |
| self.disable_first_stage_autocast = disable_first_stage_autocast |
| self.scale_factor = scale_factor |
|
|
| |
|
|
| self.model.diffusion_model.dtype = unet_dtype() |
| self.model.conditioning_key = "crossattn" |
| self.cond_stage_key = "txt" |
|
|
| self.parameterization = self.denoiser.scaling.parameterization |
| self.alphas_cumprod = torch.asarray(_alpha(), device=get_torch_device(), dtype=torch.float32) |
| self.conditioner.wrapped = torch.nn.Module() |
|
|
| def instantiate_first_stage(self, config): |
| model = instantiate_from_config(config) |
| self.first_stage_model = model.eval() |
|
|
| def decode_first_stage(self, *args, **kwargs): |
| raise NotImplementedError |
|
|
| def encode_first_stage(self, *args, **kwargs): |
| raise NotImplementedError |
|
|
| def forward(self, *args, **kwargs): |
| raise NotImplementedError |
|
|
| def sample(self, *args, **kwargs): |
| raise NotImplementedError |
|
|
| |
|
|
| def get_learned_conditioning(self, batch: list[str]): |
| width = getattr(batch, "width", 1024) |
| height = getattr(batch, "height", 1024) |
| is_negative_prompt = getattr(batch, "is_negative_prompt", False) |
|
|
| force_zero_negative_prompt = is_negative_prompt and all(x == "" for x in batch) |
| aesthetic_score = opts.sdxl_refiner_low_aesthetic_score if is_negative_prompt else opts.sdxl_refiner_high_aesthetic_score |
|
|
| devices_args = dict(device=self.forge_objects.clip.patcher.current_device, dtype=text_encoder_dtype()) |
| sdxl_conds = { |
| "txt": batch, |
| "original_size_as_tuple": torch.tensor([height, width], **devices_args).repeat(len(batch), 1), |
| "crop_coords_top_left": torch.tensor([opts.sdxl_crop_top, opts.sdxl_crop_left], **devices_args).repeat(len(batch), 1), |
| "target_size_as_tuple": torch.tensor([height, width], **devices_args).repeat(len(batch), 1), |
| "aesthetic_score": torch.tensor([aesthetic_score], **devices_args).repeat(len(batch), 1), |
| } |
|
|
| return self.conditioner(sdxl_conds, force_zero_embeddings=["txt"] if force_zero_negative_prompt else []) |
|
|
| def apply_model(self, x, t, cond, *args, **kwargs): |
| if self.model.diffusion_model.in_channels == 9: |
| x = torch.cat([x] + cond["c_concat"], dim=1) |
|
|
| return self.model(x, t, cond, *args, **kwargs) |
|
|
| def get_first_stage_encoding(self, x): |
| return x |
|
|
|
|
| class DiffusionWrapper(_DeviceDtypeModuleMixin, torch.nn.Module): |
| def __init__(self, model_config): |
| super().__init__() |
| self.diffusion_model = instantiate_from_config(model_config) |
|
|
| def forward(self, *args, **kwargs): |
| return None |
|
|
