asymmetric

README.md

@@ -14,12 +14,18 @@ library_name: diffusers
 |----------------------------|-------------|-----------|------------|
 | madebyollin/sdxl-vae-fp16-fix | 3.680e-03   | 25.2100   | 0.1314     |
 | KBlueLeaf/EQ-SDXL-VAE        | 3.530e-03   | 25.2827   | 0.1298     |
-| **AiArtLab/sdxl_vae**       | <span style="color:red">**3.321e-03**</span> | <span style="color:red">**25.6389**</span> | <span style="color:red">**0.1251**</span> |
+| **AiArtLab/sdxl_vae**       | **3.321e-03** | **25.6389** | **0.1251** |
+
+
+[![Click it](vae.png)](https://imgsli.com/NDA3OTgz)
+
+
+![zooomed](result.png)
 
 
 ### Train status, in progress:
 
-![result](result.png)
+We are currently testing the possibility of improving the SDXL VAE decoder by increasing its depth (asymmetric VAE). This will lead to a slight increase in model size (approximately 20 percent), but we expect this will improve reconstruction quality without modifying the encoder (does not require retraining SDXL). Unfortunately, our resources are quite limited (we train models on consumer GPUs, currently training three models: SDXL VAE, Simple Diffusion, and Simple VAE), so please be patient. Model training is a meticulous and time-consuming process.
 
 ## VAE Training Process
 
@@ -47,6 +53,8 @@ library_name: diffusers
 
 ## Compare
 
+https://imgsli.com/NDA3OTgz
+
 https://imgsli.com/NDA3Njgw/2/3
 
 ## Donations

asymmetric_vae/config.json

@@ -0,0 +1,45 @@
+{
+  "_class_name": "AsymmetricAutoencoderKL",
+  "_diffusers_version": "0.34.0",
+  "_name_or_path": "asymmetric_vae_empty",
+  "act_fn": "silu",
+  "block_out_channels": [
+    128,
+    256,
+    512,
+    512
+  ],
+  "down_block_out_channels": [
+    128,
+    256,
+    512,
+    512
+  ],
+  "down_block_types": [
+    "DownEncoderBlock2D",
+    "DownEncoderBlock2D",
+    "DownEncoderBlock2D",
+    "DownEncoderBlock2D"
+  ],
+  "force_upcast": false,
+  "in_channels": 3,
+  "latent_channels": 4,
+  "layers_per_down_block": 2,
+  "layers_per_up_block": 3,
+  "norm_num_groups": 32,
+  "out_channels": 3,
+  "sample_size": 1024,
+  "scaling_factor": 0.13025,
+  "up_block_out_channels": [
+    128,
+    256,
+    512,
+    512
+  ],
+  "up_block_types": [
+    "UpDecoderBlock2D",
+    "UpDecoderBlock2D",
+    "UpDecoderBlock2D",
+    "UpDecoderBlock2D"
+  ]
+}

asymmetric_vae/diffusion_pytorch_model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8de44e4f21835eb457785a63f7e96c7ddba34b9b812bdeee79012d8bd0dae199
+size 421473052

asymmetric_vae_new/config.json

@@ -0,0 +1,45 @@
+{
+  "_class_name": "AsymmetricAutoencoderKL",
+  "_diffusers_version": "0.34.0",
+  "_name_or_path": "asymmetric_vae",
+  "act_fn": "silu",
+  "block_out_channels": [
+    128,
+    256,
+    512,
+    512
+  ],
+  "down_block_out_channels": [
+    128,
+    256,
+    512,
+    512
+  ],
+  "down_block_types": [
+    "DownEncoderBlock2D",
+    "DownEncoderBlock2D",
+    "DownEncoderBlock2D",
+    "DownEncoderBlock2D"
+  ],
+  "force_upcast": false,
+  "in_channels": 3,
+  "latent_channels": 4,
+  "layers_per_down_block": 2,
+  "layers_per_up_block": 3,
+  "norm_num_groups": 32,
+  "out_channels": 3,
+  "sample_size": 1024,
+  "scaling_factor": 0.13025,
+  "up_block_out_channels": [
+    128,
+    256,
+    512,
+    512
+  ],
+  "up_block_types": [
+    "UpDecoderBlock2D",
+    "UpDecoderBlock2D",
+    "UpDecoderBlock2D",
+    "UpDecoderBlock2D"
+  ]
+}

asymmetric_vae_new/diffusion_pytorch_model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2b0689cd2f3a6f81c14a95e1f2a7c4cee6b97b51f34700c5983ee2f28df17ef6
+size 421473052

convert_a1111.py

@@ -0,0 +1,117 @@
+import torch
+from diffusers import AutoencoderKL
+from safetensors.torch import save_file
+
+# Маппинг ключей Diffusers -> A1111
+KEY_MAP = {
+    # Encoder
+    "encoder.conv_in": "encoder.conv_in",
+    "encoder.conv_norm_out": "encoder.norm_out",
+    "encoder.conv_out": "encoder.conv_out",
+    
+    # Encoder blocks
+    "encoder.down_blocks.0.resnets.0": "encoder.down.0.block.0",
+    "encoder.down_blocks.0.resnets.1": "encoder.down.0.block.1",
+    "encoder.down_blocks.0.downsamplers.0": "encoder.down.0.downsample",
+    
+    "encoder.down_blocks.1.resnets.0": "encoder.down.1.block.0",
+    "encoder.down_blocks.1.resnets.1": "encoder.down.1.block.1",
+    "encoder.down_blocks.1.downsamplers.0": "encoder.down.1.downsample",
+    
+    "encoder.down_blocks.2.resnets.0": "encoder.down.2.block.0",
+    "encoder.down_blocks.2.resnets.1": "encoder.down.2.block.1",
+    "encoder.down_blocks.2.downsamplers.0": "encoder.down.2.downsample",
+    
+    "encoder.down_blocks.3.resnets.0": "encoder.down.3.block.0",
+    "encoder.down_blocks.3.resnets.1": "encoder.down.3.block.1",
+    
+    # Encoder middle
+    "encoder.mid_block.resnets.0": "encoder.mid.block_1",
+    "encoder.mid_block.attentions.0": "encoder.mid.attn_1",
+    "encoder.mid_block.resnets.1": "encoder.mid.block_2",
+    
+    # Decoder
+    "decoder.conv_in": "decoder.conv_in",
+    "decoder.conv_norm_out": "decoder.norm_out",
+    "decoder.conv_out": "decoder.conv_out",
+    
+    # Decoder middle
+    "decoder.mid_block.resnets.0": "decoder.mid.block_1",
+    "decoder.mid_block.attentions.0": "decoder.mid.attn_1",
+    "decoder.mid_block.resnets.1": "decoder.mid.block_2",
+    
+    # Decoder blocks
+    "decoder.up_blocks.0.resnets.0": "decoder.up.3.block.0",
+    "decoder.up_blocks.0.resnets.1": "decoder.up.3.block.1",
+    "decoder.up_blocks.0.resnets.2": "decoder.up.3.block.2",
+    "decoder.up_blocks.0.upsamplers.0": "decoder.up.3.upsample",
+    
+    "decoder.up_blocks.1.resnets.0": "decoder.up.2.block.0",
+    "decoder.up_blocks.1.resnets.1": "decoder.up.2.block.1",
+    "decoder.up_blocks.1.resnets.2": "decoder.up.2.block.2",
+    "decoder.up_blocks.1.upsamplers.0": "decoder.up.2.upsample",
+    
+    "decoder.up_blocks.2.resnets.0": "decoder.up.1.block.0",
+    "decoder.up_blocks.2.resnets.1": "decoder.up.1.block.1",
+    "decoder.up_blocks.2.resnets.2": "decoder.up.1.block.2",
+    "decoder.up_blocks.2.upsamplers.0": "decoder.up.1.upsample",
+    
+    "decoder.up_blocks.3.resnets.0": "decoder.up.0.block.0",
+    "decoder.up_blocks.3.resnets.1": "decoder.up.0.block.1",
+    "decoder.up_blocks.3.resnets.2": "decoder.up.0.block.2",
+}
+
+# Дополнительные замены для конкретных слоев
+LAYER_RENAMES = {
+    "conv_shortcut": "nin_shortcut",
+    "group_norm": "norm",
+    "to_q": "q",
+    "to_k": "k", 
+    "to_v": "v",
+    "to_out.0": "proj_out",
+}
+
+def convert_key(key):
+    """Конвертирует ключ из формата Diffusers в формат A1111"""
+    # Сначала проверяем прямые маппинги
+    for diffusers_prefix, a1111_prefix in KEY_MAP.items():
+        if key.startswith(diffusers_prefix):
+            new_key = key.replace(diffusers_prefix, a1111_prefix, 1)
+            # Применяем дополнительные замены
+            for old, new in LAYER_RENAMES.items():
+                new_key = new_key.replace(old, new)
+            return new_key
+    
+    # Если не нашли в маппинге, возвращаем как есть
+    return key
+
+# Загружаем VAE
+vae = AutoencoderKL.from_pretrained("./vae")
+state_dict = vae.state_dict()
+
+# Конвертируем ключи
+converted_state_dict = {}
+for key, value in state_dict.items():
+    new_key = convert_key(key)
+    
+    # Проверяем, нужно ли изменить форму для attention весов
+    if "attn_1" in new_key and any(x in new_key for x in ["q.weight", "k.weight", "v.weight", "proj_out.weight"]):
+        # Преобразуем из [out_features, in_features] в [out_features, in_features, 1, 1]
+        if value.dim() == 2:
+            value = value.unsqueeze(-1).unsqueeze(-1)
+    
+    converted_state_dict[new_key] = value
+
+# Сохраняем
+save_file(converted_state_dict, "sdxl_vae_a1111.safetensors")
+
+print(f"Конвертировано {len(converted_state_dict)} ключей")
+print("\nПримеры конвертированных ключей:")
+for i, (old, new) in enumerate(zip(list(state_dict.keys())[:5], list(converted_state_dict.keys())[:5])):
+    print(f"{old} -> {new}")
+
+# Проверяем attention веса
+print("\nAttention веса после конвертации:")
+for key, value in converted_state_dict.items():
+    if "attn_1" in key and "weight" in key:
+        print(f"{key}: {value.shape}")

convert_a1111_asymm.py

@@ -0,0 +1,143 @@
+import torch
+from diffusers import AsymmetricAutoencoderKL
+from safetensors.torch import save_file
+
+# Маппинг ключей Diffusers -> A1111
+KEY_MAP = {
+    # Encoder (без изменений)
+    "encoder.conv_in": "encoder.conv_in",
+    "encoder.conv_norm_out": "encoder.norm_out",
+    "encoder.conv_out": "encoder.conv_out",
+    
+    # Encoder blocks (без изменений)
+    "encoder.down_blocks.0.resnets.0": "encoder.down.0.block.0",
+    "encoder.down_blocks.0.resnets.1": "encoder.down.0.block.1",
+    "encoder.down_blocks.0.downsamplers.0": "encoder.down.0.downsample",
+    
+    "encoder.down_blocks.1.resnets.0": "encoder.down.1.block.0",
+    "encoder.down_blocks.1.resnets.1": "encoder.down.1.block.1",
+    "encoder.down_blocks.1.downsamplers.0": "encoder.down.1.downsample",
+    
+    "encoder.down_blocks.2.resnets.0": "encoder.down.2.block.0",
+    "encoder.down_blocks.2.resnets.1": "encoder.down.2.block.1",
+    "encoder.down_blocks.2.downsamplers.0": "encoder.down.2.downsample",
+    
+    "encoder.down_blocks.3.resnets.0": "encoder.down.3.block.0",
+    "encoder.down_blocks.3.resnets.1": "encoder.down.3.block.1",
+    
+    # Encoder middle
+    "encoder.mid_block.resnets.0": "encoder.mid.block_1",
+    "encoder.mid_block.attentions.0": "encoder.mid.attn_1",
+    "encoder.mid_block.resnets.1": "encoder.mid.block_2",
+    
+    # Decoder
+    "decoder.conv_in": "decoder.conv_in",
+    "decoder.conv_norm_out": "decoder.norm_out",
+    "decoder.conv_out": "decoder.conv_out",
+    
+    # Decoder middle
+    "decoder.mid_block.resnets.0": "decoder.mid.block_1",
+    "decoder.mid_block.attentions.0": "decoder.mid.attn_1",
+    "decoder.mid_block.resnets.1": "decoder.mid.block_2",
+    
+    # Decoder blocks - ИСПРАВЛЕНО для 4 блоков
+    # up_blocks.0 -> up.3 (самый глубокий)
+    "decoder.up_blocks.0.resnets.0": "decoder.up.3.block.0",
+    "decoder.up_blocks.0.resnets.1": "decoder.up.3.block.1",
+    "decoder.up_blocks.0.resnets.2": "decoder.up.3.block.2",
+    "decoder.up_blocks.0.resnets.3": "decoder.up.3.block.3",
+    "decoder.up_blocks.0.upsamplers.0": "decoder.up.3.upsample",
+    
+    # up_blocks.1 -> up.2
+    "decoder.up_blocks.1.resnets.0": "decoder.up.2.block.0",
+    "decoder.up_blocks.1.resnets.1": "decoder.up.2.block.1",
+    "decoder.up_blocks.1.resnets.2": "decoder.up.2.block.2",
+    "decoder.up_blocks.1.resnets.3": "decoder.up.2.block.3",
+    "decoder.up_blocks.1.upsamplers.0": "decoder.up.2.upsample",
+    
+    # up_blocks.2 -> up.1
+    "decoder.up_blocks.2.resnets.0": "decoder.up.1.block.0",
+    "decoder.up_blocks.2.resnets.1": "decoder.up.1.block.1",
+    "decoder.up_blocks.2.resnets.2": "decoder.up.1.block.2",
+    "decoder.up_blocks.2.resnets.3": "decoder.up.1.block.3",
+    "decoder.up_blocks.2.upsamplers.0": "decoder.up.1.upsample",
+    
+    # up_blocks.3 -> up.0 (самый верхний)
+    "decoder.up_blocks.3.resnets.0": "decoder.up.0.block.0",
+    "decoder.up_blocks.3.resnets.1": "decoder.up.0.block.1",
+    "decoder.up_blocks.3.resnets.2": "decoder.up.0.block.2",
+    "decoder.up_blocks.3.resnets.3": "decoder.up.0.block.3",
+}
+
+# Дополнительные замены для конкретных слоев
+LAYER_RENAMES = {
+    "conv_shortcut": "nin_shortcut",
+    "group_norm": "norm",
+    "to_q": "q",
+    "to_k": "k", 
+    "to_v": "v",
+    "to_out.0": "proj_out",
+}
+
+def convert_key(key):
+    """Конвертирует ключ из формата Diffusers в формат A1111"""
+    # Пропускаем специфичные для AsymmetricVAE компоненты
+    if "condition_encoder" in key:
+        return None  # A1111 не поддерживает condition_encoder
+    
+    # Сначала проверяем прямые маппинги
+    for diffusers_prefix, a1111_prefix in KEY_MAP.items():
+        if key.startswith(diffusers_prefix):
+            new_key = key.replace(diffusers_prefix, a1111_prefix, 1)
+            # Применяем дополнительные замены
+            for old, new in LAYER_RENAMES.items():
+                new_key = new_key.replace(old, new)
+            return new_key
+    
+    # Если не нашли в маппинге, возвращаем как есть
+    return key
+
+# Загружаем VAE
+vae = AsymmetricAutoencoderKL.from_pretrained("./asymmetric_vae")
+state_dict = vae.state_dict()
+
+# Конвертируем ключи
+converted_state_dict = {}
+skipped_keys = []
+
+for key, value in state_dict.items():
+    new_key = convert_key(key)
+    
+    if new_key is None:
+        skipped_keys.append(key)
+        continue
+    
+    # Проверяем, нужно ли изменить форму для attention весов
+    if "attn_1" in new_key and any(x in new_key for x in ["q.weight", "k.weight", "v.weight", "proj_out.weight"]):
+        # Преобразуем из [out_features, in_features] в [out_features, in_features, 1, 1]
+        if value.dim() == 2:
+            value = value.unsqueeze(-1).unsqueeze(-1)
+    
+    converted_state_dict[new_key] = value
+
+# Сохраняем
+save_file(converted_state_dict, "sdxl_vae_asymm_a1111.safetensors")
+
+print(f"Конвертировано {len(converted_state_dict)} ключей")
+print(f"Пропущено {len(skipped_keys)} ключей (condition_encoder и др.)")
+
+if skipped_keys:
+    print("\nПропущенные ключи:")
+    for key in skipped_keys[:10]:  # Показываем первые 10
+        print(f"  - {key}")
+
+print("\nПримеры конвертированных ключей:")
+for i, (old, new) in enumerate(zip(list(state_dict.keys())[:5], list(converted_state_dict.keys())[:5])):
+    if old not in skipped_keys:
+        print(f"{old} -> {new}")
+
+# Проверяем attention веса
+print("\nAttention веса после конвертации:")
+for key, value in converted_state_dict.items():
+    if "attn_1" in key and "weight" in key:
+        print(f"{key}: {value.shape}")

create_asymmetric.ipynb

@@ -0,0 +1,516 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "407171be-ab46-442b-a0bd-83ca75173eba",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "AsymmetricAutoencoderKL(\n",
+      "  (encoder): Encoder(\n",
+      "    (conv_in): Conv2d(3, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "    (down_blocks): ModuleList(\n",
+      "      (0): DownEncoderBlock2D(\n",
+      "        (resnets): ModuleList(\n",
+      "          (0-1): 2 x ResnetBlock2D(\n",
+      "            (norm1): GroupNorm(32, 128, eps=1e-06, affine=True)\n",
+      "            (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "            (norm2): GroupNorm(32, 128, eps=1e-06, affine=True)\n",
+      "            (dropout): Dropout(p=0.0, inplace=False)\n",
+      "            (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "            (nonlinearity): SiLU()\n",
+      "          )\n",
+      "        )\n",
+      "        (downsamplers): ModuleList(\n",
+      "          (0): Downsample2D(\n",
+      "            (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2))\n",
+      "          )\n",
+      "        )\n",
+      "      )\n",
+      "      (1): DownEncoderBlock2D(\n",
+      "        (resnets): ModuleList(\n",
+      "          (0): ResnetBlock2D(\n",
+      "            (norm1): GroupNorm(32, 128, eps=1e-06, affine=True)\n",
+      "            (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "            (norm2): GroupNorm(32, 256, eps=1e-06, affine=True)\n",
+      "            (dropout): Dropout(p=0.0, inplace=False)\n",
+      "            (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "            (nonlinearity): SiLU()\n",
+      "            (conv_shortcut): Conv2d(128, 256, kernel_size=(1, 1), stride=(1, 1))\n",
+      "          )\n",
+      "          (1): ResnetBlock2D(\n",
+      "            (norm1): GroupNorm(32, 256, eps=1e-06, affine=True)\n",
+      "            (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "            (norm2): GroupNorm(32, 256, eps=1e-06, affine=True)\n",
+      "            (dropout): Dropout(p=0.0, inplace=False)\n",
+      "            (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "            (nonlinearity): SiLU()\n",
+      "          )\n",
+      "        )\n",
+      "        (downsamplers): ModuleList(\n",
+      "          (0): Downsample2D(\n",
+      "            (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2))\n",
+      "          )\n",
+      "        )\n",
+      "      )\n",
+      "      (2): DownEncoderBlock2D(\n",
+      "        (resnets): ModuleList(\n",
+      "          (0): ResnetBlock2D(\n",
+      "            (norm1): GroupNorm(32, 256, eps=1e-06, affine=True)\n",
+      "            (conv1): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "            (norm2): GroupNorm(32, 512, eps=1e-06, affine=True)\n",
+      "            (dropout): Dropout(p=0.0, inplace=False)\n",
+      "            (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "            (nonlinearity): SiLU()\n",
+      "            (conv_shortcut): Conv2d(256, 512, kernel_size=(1, 1), stride=(1, 1))\n",
+      "          )\n",
+      "          (1): ResnetBlock2D(\n",
+      "            (norm1): GroupNorm(32, 512, eps=1e-06, affine=True)\n",
+      "            (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "            (norm2): GroupNorm(32, 512, eps=1e-06, affine=True)\n",
+      "            (dropout): Dropout(p=0.0, inplace=False)\n",
+      "            (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "            (nonlinearity): SiLU()\n",
+      "          )\n",
+      "        )\n",
+      "        (downsamplers): ModuleList(\n",
+      "          (0): Downsample2D(\n",
+      "            (conv): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2))\n",
+      "          )\n",
+      "        )\n",
+      "      )\n",
+      "      (3): DownEncoderBlock2D(\n",
+      "        (resnets): ModuleList(\n",
+      "          (0-1): 2 x ResnetBlock2D(\n",
+      "            (norm1): GroupNorm(32, 512, eps=1e-06, affine=True)\n",
+      "            (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "            (norm2): GroupNorm(32, 512, eps=1e-06, affine=True)\n",
+      "            (dropout): Dropout(p=0.0, inplace=False)\n",
+      "            (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "            (nonlinearity): SiLU()\n",
+      "          )\n",
+      "        )\n",
+      "      )\n",
+      "    )\n",
+      "    (mid_block): UNetMidBlock2D(\n",
+      "      (attentions): ModuleList(\n",
+      "        (0): Attention(\n",
+      "          (group_norm): GroupNorm(32, 512, eps=1e-06, affine=True)\n",
+      "          (to_q): Linear(in_features=512, out_features=512, bias=True)\n",
+      "          (to_k): Linear(in_features=512, out_features=512, bias=True)\n",
+      "          (to_v): Linear(in_features=512, out_features=512, bias=True)\n",
+      "          (to_out): ModuleList(\n",
+      "            (0): Linear(in_features=512, out_features=512, bias=True)\n",
+      "            (1): Dropout(p=0.0, inplace=False)\n",
+      "          )\n",
+      "        )\n",
+      "      )\n",
+      "      (resnets): ModuleList(\n",
+      "        (0-1): 2 x ResnetBlock2D(\n",
+      "          (norm1): GroupNorm(32, 512, eps=1e-06, affine=True)\n",
+      "          (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "          (norm2): GroupNorm(32, 512, eps=1e-06, affine=True)\n",
+      "          (dropout): Dropout(p=0.0, inplace=False)\n",
+      "          (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "          (nonlinearity): SiLU()\n",
+      "        )\n",
+      "      )\n",
+      "    )\n",
+      "    (conv_norm_out): GroupNorm(32, 512, eps=1e-06, affine=True)\n",
+      "    (conv_act): SiLU()\n",
+      "    (conv_out): Conv2d(512, 8, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "  )\n",
+      "  (decoder): MaskConditionDecoder(\n",
+      "    (conv_in): Conv2d(4, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "    (up_blocks): ModuleList(\n",
+      "      (0-1): 2 x UpDecoderBlock2D(\n",
+      "        (resnets): ModuleList(\n",
+      "          (0-3): 4 x ResnetBlock2D(\n",
+      "            (norm1): GroupNorm(32, 512, eps=1e-06, affine=True)\n",
+      "            (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "            (norm2): GroupNorm(32, 512, eps=1e-06, affine=True)\n",
+      "            (dropout): Dropout(p=0.0, inplace=False)\n",
+      "            (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "            (nonlinearity): SiLU()\n",
+      "          )\n",
+      "        )\n",
+      "        (upsamplers): ModuleList(\n",
+      "          (0): Upsample2D(\n",
+      "            (conv): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "          )\n",
+      "        )\n",
+      "      )\n",
+      "      (2): UpDecoderBlock2D(\n",
+      "        (resnets): ModuleList(\n",
+      "          (0): ResnetBlock2D(\n",
+      "            (norm1): GroupNorm(32, 512, eps=1e-06, affine=True)\n",
+      "            (conv1): Conv2d(512, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "            (norm2): GroupNorm(32, 256, eps=1e-06, affine=True)\n",
+      "            (dropout): Dropout(p=0.0, inplace=False)\n",
+      "            (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "            (nonlinearity): SiLU()\n",
+      "            (conv_shortcut): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1))\n",
+      "          )\n",
+      "          (1-3): 3 x ResnetBlock2D(\n",
+      "            (norm1): GroupNorm(32, 256, eps=1e-06, affine=True)\n",
+      "            (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "            (norm2): GroupNorm(32, 256, eps=1e-06, affine=True)\n",
+      "            (dropout): Dropout(p=0.0, inplace=False)\n",
+      "            (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "            (nonlinearity): SiLU()\n",
+      "          )\n",
+      "        )\n",
+      "        (upsamplers): ModuleList(\n",
+      "          (0): Upsample2D(\n",
+      "            (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "          )\n",
+      "        )\n",
+      "      )\n",
+      "      (3): UpDecoderBlock2D(\n",
+      "        (resnets): ModuleList(\n",
+      "          (0): ResnetBlock2D(\n",
+      "            (norm1): GroupNorm(32, 256, eps=1e-06, affine=True)\n",
+      "            (conv1): Conv2d(256, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "            (norm2): GroupNorm(32, 128, eps=1e-06, affine=True)\n",
+      "            (dropout): Dropout(p=0.0, inplace=False)\n",
+      "            (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "            (nonlinearity): SiLU()\n",
+      "            (conv_shortcut): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1))\n",
+      "          )\n",
+      "          (1-3): 3 x ResnetBlock2D(\n",
+      "            (norm1): GroupNorm(32, 128, eps=1e-06, affine=True)\n",
+      "            (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "            (norm2): GroupNorm(32, 128, eps=1e-06, affine=True)\n",
+      "            (dropout): Dropout(p=0.0, inplace=False)\n",
+      "            (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "            (nonlinearity): SiLU()\n",
+      "          )\n",
+      "        )\n",
+      "      )\n",
+      "    )\n",
+      "    (mid_block): UNetMidBlock2D(\n",
+      "      (attentions): ModuleList(\n",
+      "        (0): Attention(\n",
+      "          (group_norm): GroupNorm(32, 512, eps=1e-06, affine=True)\n",
+      "          (to_q): Linear(in_features=512, out_features=512, bias=True)\n",
+      "          (to_k): Linear(in_features=512, out_features=512, bias=True)\n",
+      "          (to_v): Linear(in_features=512, out_features=512, bias=True)\n",
+      "          (to_out): ModuleList(\n",
+      "            (0): Linear(in_features=512, out_features=512, bias=True)\n",
+      "            (1): Dropout(p=0.0, inplace=False)\n",
+      "          )\n",
+      "        )\n",
+      "      )\n",
+      "      (resnets): ModuleList(\n",
+      "        (0-1): 2 x ResnetBlock2D(\n",
+      "          (norm1): GroupNorm(32, 512, eps=1e-06, affine=True)\n",
+      "          (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "          (norm2): GroupNorm(32, 512, eps=1e-06, affine=True)\n",
+      "          (dropout): Dropout(p=0.0, inplace=False)\n",
+      "          (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "          (nonlinearity): SiLU()\n",
+      "        )\n",
+      "      )\n",
+      "    )\n",
+      "    (condition_encoder): MaskConditionEncoder(\n",
+      "      (layers): Sequential(\n",
+      "        (0): Conv2d(3, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "        (1): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "        (2): Conv2d(256, 512, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
+      "        (3): Conv2d(512, 512, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
+      "        (4): Conv2d(512, 512, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
+      "      )\n",
+      "    )\n",
+      "    (conv_norm_out): GroupNorm(32, 128, eps=1e-06, affine=True)\n",
+      "    (conv_act): SiLU()\n",
+      "    (conv_out): Conv2d(128, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "  )\n",
+      "  (quant_conv): Conv2d(8, 8, kernel_size=(1, 1), stride=(1, 1))\n",
+      "  (post_quant_conv): Conv2d(4, 4, kernel_size=(1, 1), stride=(1, 1))\n",
+      ")\n"
+     ]
+    }
+   ],
+   "source": [
+    "from diffusers.models import AsymmetricAutoencoderKL\n",
+    "import torch\n",
+    "\n",
+    "config = {\n",
+    "    \"_class_name\": \"AsymmetricAutoencoderKL\",\n",
+    "    \"act_fn\": \"silu\",\n",
+    "    \"down_block_out_channels\": [128, 256, 512, 512],\n",
+    "    \"down_block_types\": [\n",
+    "        \"DownEncoderBlock2D\",\n",
+    "        \"DownEncoderBlock2D\",\n",
+    "        \"DownEncoderBlock2D\",\n",
+    "        \"DownEncoderBlock2D\",\n",
+    "    ],\n",
+    "    \"in_channels\": 3,\n",
+    "    \"latent_channels\": 4,\n",
+    "    \"norm_num_groups\": 32,\n",
+    "    \"out_channels\": 3,\n",
+    "    \"sample_size\": 1024,\n",
+    "    \"scaling_factor\": 0.13025,\n",
+    "    \"shift_factor\": 0,\n",
+    "    \"up_block_out_channels\": [128, 256, 512, 512],\n",
+    "    \"up_block_types\": [\n",
+    "        \"UpDecoderBlock2D\",\n",
+    "        \"UpDecoderBlock2D\",\n",
+    "        \"UpDecoderBlock2D\",\n",
+    "        \"UpDecoderBlock2D\",\n",
+    "    ],\n",
+    "}\n",
+    "\n",
+    "# Создаем модель\n",
+    "vae = AsymmetricAutoencoderKL(\n",
+    "    act_fn=config[\"act_fn\"],\n",
+    "    down_block_out_channels=config[\"down_block_out_channels\"],\n",
+    "    down_block_types=config[\"down_block_types\"],\n",
+    "    in_channels=config[\"in_channels\"],\n",
+    "    latent_channels=config[\"latent_channels\"],\n",
+    "    norm_num_groups=config[\"norm_num_groups\"],\n",
+    "    out_channels=config[\"out_channels\"],\n",
+    "    sample_size=config[\"sample_size\"],\n",
+    "    scaling_factor=config[\"scaling_factor\"],\n",
+    "    up_block_out_channels=config[\"up_block_out_channels\"],\n",
+    "    up_block_types=config[\"up_block_types\"],\n",
+    "    layers_per_down_block = 2,\n",
+    "    layers_per_up_block = 3\n",
+    ")\n",
+    "\n",
+    "\n",
+    "vae.save_pretrained(\"asymmetric_vae_empty\")\n",
+    "print(vae)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "a2950158-5203-42b9-8791-e231ddbf1063",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "The config attributes {'block_out_channels': [128, 256, 512, 512], 'force_upcast': False} were passed to AsymmetricAutoencoderKL, but are not expected and will be ignored. Please verify your config.json configuration file.\n",
+      "Перенос весов: 100%|██████████| 248/248 [00:00<00:00, 30427.29it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Статистика переноса: {'перенесено': 248, 'несовпадение_размеров': 0, 'пропущено': 0}\n",
+      "Неперенесенные ключи в новой модели:\n",
+      "decoder.condition_encoder.layers.0.bias\n",
+      "decoder.condition_encoder.layers.0.weight\n",
+      "decoder.condition_encoder.layers.1.bias\n",
+      "decoder.condition_encoder.layers.1.weight\n",
+      "decoder.condition_encoder.layers.2.bias\n",
+      "decoder.condition_encoder.layers.2.weight\n",
+      "decoder.condition_encoder.layers.3.bias\n",
+      "decoder.condition_encoder.layers.3.weight\n",
+      "decoder.condition_encoder.layers.4.bias\n",
+      "decoder.condition_encoder.layers.4.weight\n",
+      "decoder.up_blocks.0.resnets.3.conv1.bias\n",
+      "decoder.up_blocks.0.resnets.3.conv1.weight\n",
+      "decoder.up_blocks.0.resnets.3.conv2.bias\n",
+      "decoder.up_blocks.0.resnets.3.conv2.weight\n",
+      "decoder.up_blocks.0.resnets.3.norm1.bias\n",
+      "decoder.up_blocks.0.resnets.3.norm1.weight\n",
+      "decoder.up_blocks.0.resnets.3.norm2.bias\n",
+      "decoder.up_blocks.0.resnets.3.norm2.weight\n",
+      "decoder.up_blocks.1.resnets.3.conv1.bias\n",
+      "decoder.up_blocks.1.resnets.3.conv1.weight\n",
+      "decoder.up_blocks.1.resnets.3.conv2.bias\n",
+      "decoder.up_blocks.1.resnets.3.conv2.weight\n",
+      "decoder.up_blocks.1.resnets.3.norm1.bias\n",
+      "decoder.up_blocks.1.resnets.3.norm1.weight\n",
+      "decoder.up_blocks.1.resnets.3.norm2.bias\n",
+      "decoder.up_blocks.1.resnets.3.norm2.weight\n",
+      "decoder.up_blocks.2.resnets.3.conv1.bias\n",
+      "decoder.up_blocks.2.resnets.3.conv1.weight\n",
+      "decoder.up_blocks.2.resnets.3.conv2.bias\n",
+      "decoder.up_blocks.2.resnets.3.conv2.weight\n",
+      "decoder.up_blocks.2.resnets.3.norm1.bias\n",
+      "decoder.up_blocks.2.resnets.3.norm1.weight\n",
+      "decoder.up_blocks.2.resnets.3.norm2.bias\n",
+      "decoder.up_blocks.2.resnets.3.norm2.weight\n",
+      "decoder.up_blocks.3.resnets.3.conv1.bias\n",
+      "decoder.up_blocks.3.resnets.3.conv1.weight\n",
+      "decoder.up_blocks.3.resnets.3.conv2.bias\n",
+      "decoder.up_blocks.3.resnets.3.conv2.weight\n",
+      "decoder.up_blocks.3.resnets.3.norm1.bias\n",
+      "decoder.up_blocks.3.resnets.3.norm1.weight\n",
+      "decoder.up_blocks.3.resnets.3.norm2.bias\n",
+      "decoder.up_blocks.3.resnets.3.norm2.weight\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "from diffusers import AsymmetricAutoencoderKL,AutoencoderKL\n",
+    "from tqdm import tqdm\n",
+    "import torch.nn.init as init\n",
+    "\n",
+    "def log(message):\n",
+    "    print(message)\n",
+    "\n",
+    "def main():\n",
+    "    checkpoint_path_old = \"vae\"\n",
+    "    checkpoint_path_new = \"asymmetric_vae_empty\"\n",
+    "    device = \"cuda\"\n",
+    "    dtype = torch.float32\n",
+    "\n",
+    "    # Загрузка моделей\n",
+    "    old_unet = AutoencoderKL.from_pretrained(checkpoint_path_old).to(device, dtype=dtype)\n",
+    "    new_unet = AsymmetricAutoencoderKL.from_pretrained(checkpoint_path_new).to(device, dtype=dtype)\n",
+    "\n",
+    "    old_state_dict = old_unet.state_dict()\n",
+    "    new_state_dict = new_unet.state_dict()\n",
+    "\n",
+    "    transferred_state_dict = {}\n",
+    "    transfer_stats = {\n",
+    "        \"перенесено\": 0,\n",
+    "        \"несовпадение_размеров\": 0,\n",
+    "        \"пропущено\": 0\n",
+    "    }\n",
+    "\n",
+    "    transferred_keys = set()\n",
+    "\n",
+    "    # Обрабатываем каждый ключ старой модели\n",
+    "    for old_key in tqdm(old_state_dict.keys(), desc=\"Перенос весов\"):\n",
+    "        new_key = old_key\n",
+    "\n",
+    "        if new_key in new_state_dict:\n",
+    "            if old_state_dict[old_key].shape == new_state_dict[new_key].shape:\n",
+    "                transferred_state_dict[new_key] = old_state_dict[old_key].clone()\n",
+    "                transferred_keys.add(new_key)\n",
+    "                transfer_stats[\"перенесено\"] += 1\n",
+    "            else:\n",
+    "                log(f\"✗ Несовпадение размеров: {old_key} ({old_state_dict[old_key].shape}) -> {new_key} ({new_state_dict[new_key].shape})\")\n",
+    "                transfer_stats[\"несовпадение_размеров\"] += 1\n",
+    "        else:\n",
+    "            log(f\"? Ключ не найден в новой модели: {old_key} -> {old_state_dict[old_key].shape}\")\n",
+    "            transfer_stats[\"пропущено\"] += 1\n",
+    "\n",
+    "    # Обновляем состояние новой модели перенесенными весами\n",
+    "    new_state_dict.update(transferred_state_dict)\n",
+    "    \n",
+    "    # Инициализируем веса для нового mid блока\n",
+    "    #new_state_dict = initialize_mid_block_weights(new_state_dict, device, dtype)\n",
+    "    \n",
+    "    new_unet.load_state_dict(new_state_dict)\n",
+    "    new_unet.save_pretrained(\"asymmetric_vae\")\n",
+    "\n",
+    "    # Получаем список неперенесенных ключей\n",
+    "    non_transferred_keys = sorted(set(new_state_dict.keys()) - transferred_keys)\n",
+    "\n",
+    "    print(\"Статистика переноса:\", transfer_stats)\n",
+    "    print(\"Неперенесенные ключи в новой модели:\")\n",
+    "    for key in non_transferred_keys:\n",
+    "        print(key)\n",
+    "\n",
+    "if __name__ == \"__main__\":\n",
+    "    main()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "b316ee6c-d295-4396-9177-78e39a53055b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "The config attributes {'block_out_channels': [128, 256, 512, 512], 'force_upcast': False} were passed to AsymmetricAutoencoderKL, but are not expected and will be ignored. Please verify your config.json configuration file.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "ok\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "\n",
+    "from torchvision import transforms, utils\n",
+    "\n",
+    "import diffusers\n",
+    "from diffusers import AsymmetricAutoencoderKL\n",
+    "\n",
+    "from diffusers.utils import load_image\n",
+    "\n",
+    "def crop_image_to_nearest_divisible_by_8(img):\n",
+    "    # Check if the image height and width are divisible by 8\n",
+    "    if img.shape[1] % 8 == 0 and img.shape[2] % 8 == 0:\n",
+    "        return img\n",
+    "    else:\n",
+    "        # Calculate the closest lower resolution divisible by 8\n",
+    "        new_height = img.shape[1] - (img.shape[1] % 8)\n",
+    "        new_width = img.shape[2] - (img.shape[2] % 8)\n",
+    "        \n",
+    "        # Use CenterCrop to crop the image\n",
+    "        transform = transforms.CenterCrop((new_height, new_width), interpolation=transforms.InterpolationMode.BILINEAR)\n",
+    "        img = transform(img).to(torch.float32).clamp(-1, 1)\n",
+    "        \n",
+    "        return img\n",
+    "        \n",
+    "to_tensor = transforms.ToTensor()\n",
+    "\n",
+    "device = \"cuda\"\n",
+    "dtype=torch.float16\n",
+    "vae = AsymmetricAutoencoderKL.from_pretrained(\"asymmetric_vae\",torch_dtype=dtype).to(device).eval()\n",
+    "\n",
+    "image = load_image(\"123456789.jpg\")\n",
+    "\n",
+    "image = crop_image_to_nearest_divisible_by_8(to_tensor(image)).unsqueeze(0).to(device,dtype=dtype)\n",
+    "\n",
+    "upscaled_image = vae(image).sample\n",
+    "#vae.config.scaled_factor\n",
+    "# Save the reconstructed image\n",
+    "utils.save_image(upscaled_image, \"test.png\")\n",
+    "print('ok')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5a01b8e9-73c9-4da7-a097-e334019bd8e9",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

sdxl_vae_a1111.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ebe642d26e14851e98eb3d06575009e0d1a669704a1c9c8dcf06573d82233a21
+size 334640988

train_sdxl_vae.py

@@ -23,21 +23,22 @@ import lpips   # pip install lpips
 
 # --------------------------- Параметры ---------------------------
 ds_path            = "/workspace/png"
-project            = "sdxl_vae"
-batch_size         = 1
+project            = "asymmetric_vae"
+batch_size         = 2
 base_learning_rate = 1e-6
 min_learning_rate  = 8e-7
 num_epochs         = 8
-sample_interval_share = 20
+sample_interval_share = 10
 use_wandb          = True
 save_model         = True
 use_decay          = True
+asymmetric         = True
 optimizer_type     = "adam8bit"
 dtype              = torch.float32
 # model_resolution — то, что подавается в VAE (низкое разрешение)
-model_resolution   = 768   # бывший `resolution`
+model_resolution   = 512   # бывший `resolution`
 # high_resolution — настоящий «высокий» кроп, на котором считаем метрики и сохраняем сэмплы
-high_resolution    = 768  # >>> CHANGED: обучаемся на входах 1024 -> даунсемплим до 512 для модели
+high_resolution    = 512  # >>> CHANGED: обучаемся на входах 1024 -> даунсемплим до 512 для модели
 limit              = 0
 save_barrier       = 1.03
 warmup_percent     = 0.01
@@ -46,9 +47,9 @@ beta2              = 0.97
 eps                = 1e-6
 clip_grad_norm     = 1.0
 mixed_precision    = "no"   # или "fp16"/"bf16" при поддержке
-gradient_accumulation_steps = 16
+gradient_accumulation_steps = 8
 generated_folder   = "samples"
-save_as            = "sdxl_vae_new"
+save_as            = "asymmetric_vae_new"
 perceptual_loss_weight = 0.03  # начальное значение веса (будет перезаписываться каждый шаг)
 num_workers        = 0
 device = None  # accelerator задаст устройство
@@ -91,8 +92,10 @@ if use_wandb and accelerator.is_main_process:
     })
 
 # --------------------------- VAE ---------------------------
-vae = AutoencoderKL.from_pretrained(project).to(dtype)
-#vae = AsymmetricAutoencoderKL.from_pretrained(project).to(dtype)
+if model_resolution==high_resolution and not asymmetric:
+    vae = AutoencoderKL.from_pretrained(project).to(dtype)
+else:
+    vae = AsymmetricAutoencoderKL.from_pretrained(project).to(dtype)
 
 # >>> CHANGED: заморозка всех параметров, затем разморозка mid_block + up_blocks[-2:]
 for p in vae.parameters():
@@ -109,7 +112,7 @@ if not hasattr(decoder, "up_blocks"):
 
 # >>> CHANGED: размораживаем последние 2 up_blocks (как просил) и mid_block
 n_up = len(decoder.up_blocks)
-start_idx = 0 #max(0, n_up - 2)
+start_idx = 0 #max(0, n_up - 2) # all
 for idx in range(start_idx, n_up):
     block = decoder.up_blocks[idx]
     for name, p in block.named_parameters():

vae/config.json

@@ -0,0 +1,38 @@
+{
+  "_class_name": "AutoencoderKL",
+  "_diffusers_version": "0.34.0",
+  "_name_or_path": "sdxl_vae",
+  "act_fn": "silu",
+  "block_out_channels": [
+    128,
+    256,
+    512,
+    512
+  ],
+  "down_block_types": [
+    "DownEncoderBlock2D",
+    "DownEncoderBlock2D",
+    "DownEncoderBlock2D",
+    "DownEncoderBlock2D"
+  ],
+  "force_upcast": false,
+  "in_channels": 3,
+  "latent_channels": 4,
+  "latents_mean": null,
+  "latents_std": null,
+  "layers_per_block": 2,
+  "mid_block_add_attention": true,
+  "norm_num_groups": 32,
+  "out_channels": 3,
+  "sample_size": 512,
+  "scaling_factor": 0.13025,
+  "shift_factor": null,
+  "up_block_types": [
+    "UpDecoderBlock2D",
+    "UpDecoderBlock2D",
+    "UpDecoderBlock2D",
+    "UpDecoderBlock2D"
+  ],
+  "use_post_quant_conv": true,
+  "use_quant_conv": true
+}

vae/diffusion_pytorch_model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f17d5c9503862b25a273b8874851a99de817dbfae6094432f51381bb1cdd60c8
+size 334643268