| from dataclasses import dataclass |
| from enum import Enum |
| from json import JSONEncoder |
| import torch |
|
|
|
|
| class SDVersion(Enum): |
| SD1 = 1 |
| SD2 = 2 |
| SDXL = 3 |
| Unknown = -1 |
|
|
| def __str__(self): |
| return self.name |
|
|
| @classmethod |
| def from_str(cls, str): |
| try: |
| return cls[str] |
| except KeyError: |
| return cls.Unknown |
|
|
| def match(self, sd_model): |
| if sd_model.is_sd1 and self == SDVersion.SD1: |
| return True |
| elif sd_model.is_sd2 and self == SDVersion.SD2: |
| return True |
| elif sd_model.is_sdxl and self == SDVersion.SDXL: |
| return True |
| elif self == SDVersion.Unknown: |
| return True |
| else: |
| return False |
|
|
|
|
| class ModelType(Enum): |
| UNET = 0 |
| CONTROLNET = 1 |
| LORA = 2 |
| UNDEFINED = -1 |
|
|
| @classmethod |
| def from_string(cls, s): |
| return getattr(cls, s.upper(), None) |
|
|
| def __str__(self): |
| return self.name.lower() |
|
|
|
|
| @dataclass |
| class ModelConfig: |
| profile: dict |
| static_shapes: bool |
| fp32: bool |
| inpaint: bool |
| refit: bool |
| lora: bool |
| vram: int |
| unet_hidden_dim: int = 4 |
|
|
| def is_compatible_from_dict(self, feed_dict: dict): |
| distance = 0 |
| for k, v in feed_dict.items(): |
| _min, _opt, _max = self.profile[k] |
| v_tensor = torch.Tensor(list(v.shape)) |
| r_min = torch.Tensor(_max) - v_tensor |
| r_opt = (torch.Tensor(_opt) - v_tensor).abs() |
| r_max = v_tensor - torch.Tensor(_min) |
| if torch.any(r_min < 0) or torch.any(r_max < 0): |
| return (False, distance) |
| distance += r_opt.sum() + 0.5 * (r_max.sum() + 0.5 * r_min.sum()) |
| return (True, distance) |
|
|
| def is_compatible( |
| self, width: int, height: int, batch_size: int, max_embedding: int |
| ): |
| distance = 0 |
| sample = self.profile["sample"] |
| embedding = self.profile["encoder_hidden_states"] |
|
|
| batch_size *= 2 |
| width = width // 8 |
| height = height // 8 |
|
|
| _min, _opt, _max = sample |
| if _min[0] > batch_size or _max[0] < batch_size: |
| return (False, distance) |
| if _min[2] > height or _max[2] < height: |
| return (False, distance) |
| if _min[3] > width or _max[3] < width: |
| return (False, distance) |
|
|
| _min_em, _opt_em, _max_em = embedding |
| if _min_em[1] > max_embedding or _max_em[1] < max_embedding: |
| return (False, distance) |
|
|
| distance = ( |
| abs(_opt[0] - batch_size) |
| + abs(_opt[2] - height) |
| + abs(_opt[3] - width) |
| + 0.5 * (abs(_max[2] - height) + abs(_max[3] - width)) |
| ) |
|
|
| return (True, distance) |
|
|
|
|
| class ModelConfigEncoder(JSONEncoder): |
| def default(self, o: ModelConfig): |
| return o.__dict__ |
|
|
|
|
| @dataclass |
| class ProfileSettings: |
| bs_min: int |
| bs_opt: int |
| bs_max: int |
| h_min: int |
| h_opt: int |
| h_max: int |
| w_min: int |
| w_opt: int |
| w_max: int |
| t_min: int |
| t_opt: int |
| t_max: int |
| static_shape: bool = False |
|
|
| def __str__(self) -> str: |
| return "Batch Size: {}-{}-{}\nHeight: {}-{}-{}\nWidth: {}-{}-{}\nToken Count: {}-{}-{}".format( |
| self.bs_min, |
| self.bs_opt, |
| self.bs_max, |
| self.h_min, |
| self.h_opt, |
| self.h_max, |
| self.w_min, |
| self.w_opt, |
| self.w_max, |
| self.t_min, |
| self.t_opt, |
| self.t_max, |
| ) |
|
|
| def out(self): |
| return ( |
| self.bs_min, |
| self.bs_opt, |
| self.bs_max, |
| self.h_min, |
| self.h_opt, |
| self.h_max, |
| self.w_min, |
| self.w_opt, |
| self.w_max, |
| self.t_min, |
| self.t_opt, |
| self.t_max, |
| ) |
|
|
| def token_to_dim(self, static_shapes: bool): |
| self.t_min = (self.t_min // 75) * 77 |
| self.t_opt = (self.t_opt // 75) * 77 |
| self.t_max = (self.t_max // 75) * 77 |
|
|
| if static_shapes: |
| self.t_min = self.t_max = self.t_opt |
| self.bs_min = self.bs_max = self.bs_opt |
| self.h_min = self.h_max = self.h_opt |
| self.w_min = self.w_max = self.w_opt |
| self.static_shape = True |
|
|
| def get_latent_dim(self): |
| return ( |
| self.h_min // 8, |
| self.h_opt // 8, |
| self.h_max // 8, |
| self.w_min // 8, |
| self.w_opt // 8, |
| self.w_max // 8, |
| ) |
|
|
| def get_a1111_batch_dim(self): |
| static_batch = self.bs_min == self.bs_max == self.bs_opt |
| if self.t_max <= 77: |
| return (self.bs_min * 2, self.bs_opt * 2, self.bs_max * 2) |
| elif self.t_max > 77 and static_batch: |
| return (self.bs_opt, self.bs_opt, self.bs_opt) |
| elif self.t_max > 77 and not static_batch: |
| if self.t_opt > 77: |
| return (self.bs_min, self.bs_opt, self.bs_max * 2) |
| return (self.bs_min, self.bs_opt * 2, self.bs_max * 2) |
| else: |
| raise Exception("Uncovered case in get_batch_dim") |
|
|
|
|
| class ProfilePrests: |
| def __init__(self): |
| self.profile_presets = { |
| "512x512 | Batch Size 1 (Static)": ProfileSettings( |
| 1, 1, 1, 512, 512, 512, 512, 512, 512, 75, 75, 75 |
| ), |
| "768x768 | Batch Size 1 (Static)": ProfileSettings( |
| 1, 1, 1, 768, 768, 768, 768, 768, 768, 75, 75, 75 |
| ), |
| "1024x1024 | Batch Size 1 (Static)": ProfileSettings( |
| 1, 1, 1, 1024, 1024, 1024, 1024, 1024, 1024, 75, 75, 75 |
| ), |
| "256x256 - 512x512 | Batch Size 1-4": ProfileSettings( |
| 1, 1, 4, 256, 512, 512, 256, 512, 512, 75, 75, 150 |
| ), |
| "512x512 - 768x768 | Batch Size 1-4": ProfileSettings( |
| 1, 1, 4, 512, 512, 768, 512, 512, 768, 75, 75, 150 |
| ), |
| "768x768 - 1024x1024 | Batch Size 1-4": ProfileSettings( |
| 1, 1, 4, 768, 1024, 1024, 768, 1024, 1024, 75, 75, 150 |
| ), |
| } |
| self.default = ProfileSettings( |
| 1, 1, 4, 512, 512, 768, 512, 512, 768, 75, 75, 150 |
| ) |
| self.default_xl = ProfileSettings( |
| 1, 1, 1, 1024, 1024, 1024, 1024, 1024, 1024, 75, 75, 75 |
| ) |
|
|
| def get_settings_from_version(self, version: str): |
| static = False |
| if version == "Default": |
| return *self.default.out(), static |
| if "Static" in version: |
| static = True |
| return *self.profile_presets[version].out(), static |
|
|
| def get_choices(self): |
| return list(self.profile_presets.keys()) + ["Default"] |
|
|
| def get_default(self, is_xl: bool): |
| if is_xl: |
| return self.default_xl |
| return self.default |
|
|
