Upload folder using huggingface_hub

.ipynb_checkpoints/config-checkpoint.json

@@ -1,7 +1,7 @@
 {
   "_class_name": "AutoencoderKL",
   "_diffusers_version": "0.37.0",
-  "_name_or_path": "vae16x32ch",
+  "_name_or_path": "vae16x32ch_empty",
   "act_fn": "silu",
   "block_out_channels": [
     128,
@@ -14,7 +14,6 @@
     "DownEncoderBlock2D",
     "DownEncoderBlock2D",
     "DownEncoderBlock2D",
-    "DownEncoderBlock2D",
     "DownEncoderBlock2D"
   ],
   "force_upcast": false,
@@ -99,7 +98,6 @@
     "UpDecoderBlock2D",
     "UpDecoderBlock2D",
     "UpDecoderBlock2D",
-    "UpDecoderBlock2D",
     "UpDecoderBlock2D"
   ],
   "use_post_quant_conv": true,

.ipynb_checkpoints/create_symmetric-Copy1-checkpoint.ipynb

@@ -0,0 +1,765 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "407171be-ab46-442b-a0bd-83ca75173eba",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "AutoencoderKL(\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-1): 2 x DownEncoderBlock2D(\n",
+      "        (resnets): ModuleList(\n",
+      "          (0-2): 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",
+      "        (downsamplers): ModuleList(\n",
+      "          (0): Downsample2D(\n",
+      "            (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2))\n",
+      "          )\n",
+      "        )\n",
+      "      )\n",
+      "      (2): 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-2): 2 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",
+      "        (downsamplers): ModuleList(\n",
+      "          (0): Downsample2D(\n",
+      "            (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2))\n",
+      "          )\n",
+      "        )\n",
+      "      )\n",
+      "      (3): 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-2): 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",
+      "        (downsamplers): ModuleList(\n",
+      "          (0): Downsample2D(\n",
+      "            (conv): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2))\n",
+      "          )\n",
+      "        )\n",
+      "      )\n",
+      "      (4): DownEncoderBlock2D(\n",
+      "        (resnets): ModuleList(\n",
+      "          (0-2): 3 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, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "  )\n",
+      "  (decoder): Decoder(\n",
+      "    (conv_in): Conv2d(32, 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",
+      "        (upsamplers): ModuleList(\n",
+      "          (0): Upsample2D(\n",
+      "            (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "          )\n",
+      "        )\n",
+      "      )\n",
+      "      (4): UpDecoderBlock2D(\n",
+      "        (resnets): ModuleList(\n",
+      "          (0-3): 4 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",
+      "    (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(64, 64, kernel_size=(1, 1), stride=(1, 1))\n",
+      "  (post_quant_conv): Conv2d(32, 32, kernel_size=(1, 1), stride=(1, 1))\n",
+      ")\n"
+     ]
+    }
+   ],
+   "source": [
+    "from diffusers.models import AutoencoderKL\n",
+    "import torch\n",
+    "\n",
+    "config = {\n",
+    "  \"_class_name\": \"AutoencoderKL\",\n",
+    "  \"_diffusers_version\": \"0.36.0\",\n",
+    "  \"act_fn\": \"silu\",\n",
+    "  \"block_out_channels\": [\n",
+    "    128,\n",
+    "    128,\n",
+    "    256,\n",
+    "    512,\n",
+    "    512\n",
+    "  ],\n",
+    "  \"down_block_types\": [\n",
+    "    \"DownEncoderBlock2D\",\n",
+    "    \"DownEncoderBlock2D\",\n",
+    "    \"DownEncoderBlock2D\",\n",
+    "    \"DownEncoderBlock2D\",\n",
+    "    \"DownEncoderBlock2D\"\n",
+    "  ],\n",
+    "  \"force_upcast\": False,\n",
+    "  \"in_channels\": 3,\n",
+    "  \"latent_channels\": 32,\n",
+    "  \"latents_mean\": [\n",
+    "    -0.03542253375053406,\n",
+    "    0.20086465775966644,\n",
+    "    -0.016413161531090736,\n",
+    "    -0.0956302210688591,\n",
+    "    -0.2672063112258911,\n",
+    "    0.2609933018684387,\n",
+    "    -0.07806991040706635,\n",
+    "    -0.48407721519470215,\n",
+    "    0.21844269335269928,\n",
+    "    -0.1122383326292038,\n",
+    "    0.27197545766830444,\n",
+    "    -0.18958772718906403,\n",
+    "    0.18776826560497284,\n",
+    "    0.0987580344080925,\n",
+    "    0.2837068736553192,\n",
+    "    -0.4486690163612366,\n",
+    "    0.4816776514053345,\n",
+    "    0.02947971224784851,\n",
+    "    -0.1337375044822693,\n",
+    "    -0.39750921726226807,\n",
+    "    -0.08513020724058151,\n",
+    "    -0.054023586213588715,\n",
+    "    -0.3943594992160797,\n",
+    "    0.23918119072914124,\n",
+    "    -0.12466679513454437,\n",
+    "    0.09935147315263748,\n",
+    "    0.31858691573143005,\n",
+    "    0.48585832118988037,\n",
+    "    -0.6416525840759277,\n",
+    "    -0.15164820849895477,\n",
+    "    -0.4693508744239807,\n",
+    "    -0.13071806728839874\n",
+    "  ],\n",
+    "  \"latents_std\": [\n",
+    "    1.5792087316513062,\n",
+    "    1.5769503116607666,\n",
+    "    1.5864241123199463,\n",
+    "    1.6454921960830688,\n",
+    "    1.5336694717407227,\n",
+    "    1.5587652921676636,\n",
+    "    1.5838669538497925,\n",
+    "    1.5659377574920654,\n",
+    "    1.6860467195510864,\n",
+    "    1.5192310810089111,\n",
+    "    1.573639988899231,\n",
+    "    1.5953549146652222,\n",
+    "    1.5271092653274536,\n",
+    "    1.6246271133422852,\n",
+    "    1.7054023742675781,\n",
+    "    1.607722282409668,\n",
+    "    1.558642864227295,\n",
+    "    1.5824549198150635,\n",
+    "    1.6202995777130127,\n",
+    "    1.6206320524215698,\n",
+    "    1.6379750967025757,\n",
+    "    1.6527063846588135,\n",
+    "    1.498811960220337,\n",
+    "    1.5706247091293335,\n",
+    "    1.5854856967926025,\n",
+    "    1.4828169345855713,\n",
+    "    1.5693111419677734,\n",
+    "    1.692481517791748,\n",
+    "    1.6409776210784912,\n",
+    "    1.6216280460357666,\n",
+    "    1.6087706089019775,\n",
+    "    1.5776633024215698\n",
+    "  ],\n",
+    "  \"layers_per_block\": 2,\n",
+    "  \"mid_block_add_attention\": True,\n",
+    "  \"norm_num_groups\": 32,\n",
+    "  \"out_channels\": 3,\n",
+    "  \"sample_size\": 32,\n",
+    "  \"scaling_factor\": 1.0,\n",
+    "  \"shift_factor\": 0.0,\n",
+    "  \"up_block_types\": [\n",
+    "    \"UpDecoderBlock2D\",\n",
+    "    \"UpDecoderBlock2D\",\n",
+    "    \"UpDecoderBlock2D\",\n",
+    "    \"UpDecoderBlock2D\",\n",
+    "    \"UpDecoderBlock2D\"\n",
+    "  ],\n",
+    "  \"use_post_quant_conv\": True,\n",
+    "  \"use_quant_conv\": True\n",
+    "}\n",
+    "\n",
+    "\n",
+    "vae = AutoencoderKL(\n",
+    "    act_fn=config[\"act_fn\"],\n",
+    "    block_out_channels=config[\"block_out_channels\"],\n",
+    "    down_block_types=config[\"down_block_types\"],\n",
+    "    up_block_types=config[\"up_block_types\"],\n",
+    "    in_channels=config[\"in_channels\"],\n",
+    "    out_channels=config[\"out_channels\"],\n",
+    "    latent_channels=config[\"latent_channels\"],\n",
+    "    layers_per_block=3, #config[\"layers_per_block\"],\n",
+    "    norm_num_groups=config[\"norm_num_groups\"],\n",
+    "    sample_size=config[\"sample_size\"],\n",
+    "    scaling_factor=config[\"scaling_factor\"],\n",
+    "    force_upcast=config[\"force_upcast\"],\n",
+    "    mid_block_add_attention=config[\"mid_block_add_attention\"],\n",
+    "    use_quant_conv=config[\"use_quant_conv\"],\n",
+    "    use_post_quant_conv=config[\"use_post_quant_conv\"],\n",
+    "    latents_mean=(config[\"latents_mean\"]),\n",
+    "    latents_std=(config[\"latents_std\"]),\n",
+    ")\n",
+    "\n",
+    "vae.save_pretrained(\"vae16x32ch_empty\")\n",
+    "\n",
+    "print(vae)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "a2950158-5203-42b9-8791-e231ddbf1063",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Перенос весов: 100%|██████████| 292/292 [00:00<00:00, 35760.83it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Статистика переноса: {'перенесено': 292, 'несовпадение_размеров': 0, 'пропущено': 0}\n",
+      "Неперенесенные ключи в новой модели:\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",
+      "decoder.up_blocks.4.resnets.3.conv1.bias\n",
+      "decoder.up_blocks.4.resnets.3.conv1.weight\n",
+      "decoder.up_blocks.4.resnets.3.conv2.bias\n",
+      "decoder.up_blocks.4.resnets.3.conv2.weight\n",
+      "decoder.up_blocks.4.resnets.3.norm1.bias\n",
+      "decoder.up_blocks.4.resnets.3.norm1.weight\n",
+      "decoder.up_blocks.4.resnets.3.norm2.bias\n",
+      "decoder.up_blocks.4.resnets.3.norm2.weight\n",
+      "encoder.down_blocks.0.resnets.2.conv1.bias\n",
+      "encoder.down_blocks.0.resnets.2.conv1.weight\n",
+      "encoder.down_blocks.0.resnets.2.conv2.bias\n",
+      "encoder.down_blocks.0.resnets.2.conv2.weight\n",
+      "encoder.down_blocks.0.resnets.2.norm1.bias\n",
+      "encoder.down_blocks.0.resnets.2.norm1.weight\n",
+      "encoder.down_blocks.0.resnets.2.norm2.bias\n",
+      "encoder.down_blocks.0.resnets.2.norm2.weight\n",
+      "encoder.down_blocks.1.resnets.2.conv1.bias\n",
+      "encoder.down_blocks.1.resnets.2.conv1.weight\n",
+      "encoder.down_blocks.1.resnets.2.conv2.bias\n",
+      "encoder.down_blocks.1.resnets.2.conv2.weight\n",
+      "encoder.down_blocks.1.resnets.2.norm1.bias\n",
+      "encoder.down_blocks.1.resnets.2.norm1.weight\n",
+      "encoder.down_blocks.1.resnets.2.norm2.bias\n",
+      "encoder.down_blocks.1.resnets.2.norm2.weight\n",
+      "encoder.down_blocks.2.resnets.2.conv1.bias\n",
+      "encoder.down_blocks.2.resnets.2.conv1.weight\n",
+      "encoder.down_blocks.2.resnets.2.conv2.bias\n",
+      "encoder.down_blocks.2.resnets.2.conv2.weight\n",
+      "encoder.down_blocks.2.resnets.2.norm1.bias\n",
+      "encoder.down_blocks.2.resnets.2.norm1.weight\n",
+      "encoder.down_blocks.2.resnets.2.norm2.bias\n",
+      "encoder.down_blocks.2.resnets.2.norm2.weight\n",
+      "encoder.down_blocks.3.resnets.2.conv1.bias\n",
+      "encoder.down_blocks.3.resnets.2.conv1.weight\n",
+      "encoder.down_blocks.3.resnets.2.conv2.bias\n",
+      "encoder.down_blocks.3.resnets.2.conv2.weight\n",
+      "encoder.down_blocks.3.resnets.2.norm1.bias\n",
+      "encoder.down_blocks.3.resnets.2.norm1.weight\n",
+      "encoder.down_blocks.3.resnets.2.norm2.bias\n",
+      "encoder.down_blocks.3.resnets.2.norm2.weight\n",
+      "encoder.down_blocks.4.resnets.2.conv1.bias\n",
+      "encoder.down_blocks.4.resnets.2.conv1.weight\n",
+      "encoder.down_blocks.4.resnets.2.conv2.bias\n",
+      "encoder.down_blocks.4.resnets.2.conv2.weight\n",
+      "encoder.down_blocks.4.resnets.2.norm1.bias\n",
+      "encoder.down_blocks.4.resnets.2.norm1.weight\n",
+      "encoder.down_blocks.4.resnets.2.norm2.bias\n",
+      "encoder.down_blocks.4.resnets.2.norm2.weight\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "from diffusers import AutoencoderKL,AsymmetricAutoencoderKL\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 = \"vae16x32ch_new\"\n",
+    "    checkpoint_path_new = \"vae16x32ch_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 = AutoencoderKL.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(\"vae16x32ch\")\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": 11,
+   "id": "5a01b8e9-73c9-4da7-a097-e334019bd8e9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "The config attributes {'block_out_channels': [128, 128, 256, 512, 512], 'force_upcast': False, 'latents_mean': [-0.03542253375053406, 0.20086465775966644, -0.016413161531090736, -0.0956302210688591, -0.2672063112258911, 0.2609933018684387, -0.07806991040706635, -0.48407721519470215, 0.21844269335269928, -0.1122383326292038, 0.27197545766830444, -0.18958772718906403, 0.18776826560497284, 0.0987580344080925, 0.2837068736553192, -0.4486690163612366, 0.4816776514053345, 0.02947971224784851, -0.1337375044822693, -0.39750921726226807, -0.08513020724058151, -0.054023586213588715, -0.3943594992160797, 0.23918119072914124, -0.12466679513454437, 0.09935147315263748, 0.31858691573143005, 0.48585832118988037, -0.6416525840759277, -0.15164820849895477, -0.4693508744239807, -0.13071806728839874], 'latents_std': [1.5792087316513062, 1.5769503116607666, 1.5864241123199463, 1.6454921960830688, 1.5336694717407227, 1.5587652921676636, 1.5838669538497925, 1.5659377574920654, 1.6860467195510864, 1.5192310810089111, 1.573639988899231, 1.5953549146652222, 1.5271092653274536, 1.6246271133422852, 1.7054023742675781, 1.607722282409668, 1.558642864227295, 1.5824549198150635, 1.6202995777130127, 1.6206320524215698, 1.6379750967025757, 1.6527063846588135, 1.498811960220337, 1.5706247091293335, 1.5854856967926025, 1.4828169345855713, 1.5693111419677734, 1.692481517791748, 1.6409776210784912, 1.6216280460357666, 1.6087706089019775, 1.5776633024215698]} were passed to AsymmetricAutoencoderKL, but are not expected and will be ignored. Please verify your config.json configuration file.\n",
+      "Перенос весов: 100%|██████████| 284/284 [00:00<00:00, 30094.80it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Статистика: {'перенесено': 292, 'несовпадение_размеров': 0, 'пропущено': 10}\n",
+      "\n",
+      "Неперенесенные ��лючи:\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "from diffusers import AutoencoderKL, AsymmetricAutoencoderKL\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "\n",
+    "def log(message):\n",
+    "    print(message)\n",
+    "\n",
+    "\n",
+    "def remap_key(old_key: str):\n",
+    "    \"\"\"\n",
+    "    Смещение только encoder.down_blocks\n",
+    "    \"\"\"\n",
+    "\n",
+    "    if \"encoder.down_blocks\" not in old_key:\n",
+    "        return [old_key]\n",
+    "\n",
+    "    parts = old_key.split(\".\")\n",
+    "    block_id = int(parts[2])\n",
+    "\n",
+    "    if block_id == 0:\n",
+    "        # первый блок копируем дважды\n",
+    "        return [\n",
+    "            old_key.replace(\"down_blocks.0\", \"down_blocks.0\"),\n",
+    "            old_key.replace(\"down_blocks.0\", \"down_blocks.1\"),\n",
+    "        ]\n",
+    "\n",
+    "    # остальные блоки сдвигаем\n",
+    "    new_block = block_id + 1\n",
+    "    return [old_key.replace(f\"down_blocks.{block_id}\", f\"down_blocks.{new_block}\")]\n",
+    "\n",
+    "\n",
+    "def main():\n",
+    "    checkpoint_path_old = \"asymmetric_vae_new\"\n",
+    "    checkpoint_path_new = \"vae16x32ch_empty\"\n",
+    "\n",
+    "    device = \"cuda\"\n",
+    "    dtype = torch.float32\n",
+    "\n",
+    "    old_vae = AsymmetricAutoencoderKL.from_pretrained(checkpoint_path_old).to(device, dtype=dtype)\n",
+    "    new_vae = AutoencoderKL.from_pretrained(checkpoint_path_new).to(device, dtype=dtype)\n",
+    "\n",
+    "    old_state_dict = old_vae.state_dict()\n",
+    "    new_state_dict = new_vae.state_dict()\n",
+    "\n",
+    "    transferred_state_dict = {}\n",
+    "    transferred_keys = set()\n",
+    "\n",
+    "    transfer_stats = {\n",
+    "        \"перенесено\": 0,\n",
+    "        \"несовпадение_размеров\": 0,\n",
+    "        \"пропущено\": 0\n",
+    "    }\n",
+    "\n",
+    "    for old_key in tqdm(old_state_dict.keys(), desc=\"Перенос весов\"):\n",
+    "\n",
+    "        new_keys = remap_key(old_key)\n",
+    "\n",
+    "        for new_key in new_keys:\n",
+    "\n",
+    "            if new_key in new_state_dict:\n",
+    "\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(\n",
+    "                        f\"✗ Несовпадение размеров: \"\n",
+    "                        f\"{old_key} {old_state_dict[old_key].shape} \"\n",
+    "                        f\"-> {new_key} {new_state_dict[new_key].shape}\"\n",
+    "                    )\n",
+    "                    transfer_stats[\"несовпадение_размеров\"] += 1\n",
+    "            else:\n",
+    "                transfer_stats[\"пропущено\"] += 1\n",
+    "\n",
+    "    new_state_dict.update(transferred_state_dict)\n",
+    "\n",
+    "    new_vae.load_state_dict(new_state_dict)\n",
+    "    new_vae.save_pretrained(\"vae16x32ch\")\n",
+    "\n",
+    "    non_transferred_keys = sorted(set(new_state_dict.keys()) - transferred_keys)\n",
+    "\n",
+    "    print(\"Статистика:\", transfer_stats)\n",
+    "\n",
+    "    print(\"\\nНеперенесенные ключи:\")\n",
+    "    for key in non_transferred_keys:\n",
+    "        print(key)\n",
+    "\n",
+    "\n",
+    "if __name__ == \"__main__\":\n",
+    "    main()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fe8f1ceb-8d3e-4df5-a1dc-1b56a0d398a2",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python3 (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.12.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

config.json

@@ -1,7 +1,7 @@
 {
   "_class_name": "AutoencoderKL",
   "_diffusers_version": "0.37.0",
-  "_name_or_path": "vae16x32ch_new",
+  "_name_or_path": "vae16x32ch",
   "act_fn": "silu",
   "block_out_channels": [
     128,
@@ -88,7 +88,7 @@
     1.6087706089019775,
     1.5776633024215698
   ],
-  "layers_per_block": 2,
+  "layers_per_block": 3,
   "mid_block_add_attention": true,
   "norm_num_groups": 32,
   "out_channels": 3,

create_symmetric-Copy1.ipynb

@@ -0,0 +1,765 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "407171be-ab46-442b-a0bd-83ca75173eba",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "AutoencoderKL(\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-1): 2 x DownEncoderBlock2D(\n",
+      "        (resnets): ModuleList(\n",
+      "          (0-2): 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",
+      "        (downsamplers): ModuleList(\n",
+      "          (0): Downsample2D(\n",
+      "            (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2))\n",
+      "          )\n",
+      "        )\n",
+      "      )\n",
+      "      (2): 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-2): 2 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",
+      "        (downsamplers): ModuleList(\n",
+      "          (0): Downsample2D(\n",
+      "            (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2))\n",
+      "          )\n",
+      "        )\n",
+      "      )\n",
+      "      (3): 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-2): 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",
+      "        (downsamplers): ModuleList(\n",
+      "          (0): Downsample2D(\n",
+      "            (conv): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2))\n",
+      "          )\n",
+      "        )\n",
+      "      )\n",
+      "      (4): DownEncoderBlock2D(\n",
+      "        (resnets): ModuleList(\n",
+      "          (0-2): 3 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, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "  )\n",
+      "  (decoder): Decoder(\n",
+      "    (conv_in): Conv2d(32, 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",
+      "        (upsamplers): ModuleList(\n",
+      "          (0): Upsample2D(\n",
+      "            (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "          )\n",
+      "        )\n",
+      "      )\n",
+      "      (4): UpDecoderBlock2D(\n",
+      "        (resnets): ModuleList(\n",
+      "          (0-3): 4 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",
+      "    (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(64, 64, kernel_size=(1, 1), stride=(1, 1))\n",
+      "  (post_quant_conv): Conv2d(32, 32, kernel_size=(1, 1), stride=(1, 1))\n",
+      ")\n"
+     ]
+    }
+   ],
+   "source": [
+    "from diffusers.models import AutoencoderKL\n",
+    "import torch\n",
+    "\n",
+    "config = {\n",
+    "  \"_class_name\": \"AutoencoderKL\",\n",
+    "  \"_diffusers_version\": \"0.36.0\",\n",
+    "  \"act_fn\": \"silu\",\n",
+    "  \"block_out_channels\": [\n",
+    "    128,\n",
+    "    128,\n",
+    "    256,\n",
+    "    512,\n",
+    "    512\n",
+    "  ],\n",
+    "  \"down_block_types\": [\n",
+    "    \"DownEncoderBlock2D\",\n",
+    "    \"DownEncoderBlock2D\",\n",
+    "    \"DownEncoderBlock2D\",\n",
+    "    \"DownEncoderBlock2D\",\n",
+    "    \"DownEncoderBlock2D\"\n",
+    "  ],\n",
+    "  \"force_upcast\": False,\n",
+    "  \"in_channels\": 3,\n",
+    "  \"latent_channels\": 32,\n",
+    "  \"latents_mean\": [\n",
+    "    -0.03542253375053406,\n",
+    "    0.20086465775966644,\n",
+    "    -0.016413161531090736,\n",
+    "    -0.0956302210688591,\n",
+    "    -0.2672063112258911,\n",
+    "    0.2609933018684387,\n",
+    "    -0.07806991040706635,\n",
+    "    -0.48407721519470215,\n",
+    "    0.21844269335269928,\n",
+    "    -0.1122383326292038,\n",
+    "    0.27197545766830444,\n",
+    "    -0.18958772718906403,\n",
+    "    0.18776826560497284,\n",
+    "    0.0987580344080925,\n",
+    "    0.2837068736553192,\n",
+    "    -0.4486690163612366,\n",
+    "    0.4816776514053345,\n",
+    "    0.02947971224784851,\n",
+    "    -0.1337375044822693,\n",
+    "    -0.39750921726226807,\n",
+    "    -0.08513020724058151,\n",
+    "    -0.054023586213588715,\n",
+    "    -0.3943594992160797,\n",
+    "    0.23918119072914124,\n",
+    "    -0.12466679513454437,\n",
+    "    0.09935147315263748,\n",
+    "    0.31858691573143005,\n",
+    "    0.48585832118988037,\n",
+    "    -0.6416525840759277,\n",
+    "    -0.15164820849895477,\n",
+    "    -0.4693508744239807,\n",
+    "    -0.13071806728839874\n",
+    "  ],\n",
+    "  \"latents_std\": [\n",
+    "    1.5792087316513062,\n",
+    "    1.5769503116607666,\n",
+    "    1.5864241123199463,\n",
+    "    1.6454921960830688,\n",
+    "    1.5336694717407227,\n",
+    "    1.5587652921676636,\n",
+    "    1.5838669538497925,\n",
+    "    1.5659377574920654,\n",
+    "    1.6860467195510864,\n",
+    "    1.5192310810089111,\n",
+    "    1.573639988899231,\n",
+    "    1.5953549146652222,\n",
+    "    1.5271092653274536,\n",
+    "    1.6246271133422852,\n",
+    "    1.7054023742675781,\n",
+    "    1.607722282409668,\n",
+    "    1.558642864227295,\n",
+    "    1.5824549198150635,\n",
+    "    1.6202995777130127,\n",
+    "    1.6206320524215698,\n",
+    "    1.6379750967025757,\n",
+    "    1.6527063846588135,\n",
+    "    1.498811960220337,\n",
+    "    1.5706247091293335,\n",
+    "    1.5854856967926025,\n",
+    "    1.4828169345855713,\n",
+    "    1.5693111419677734,\n",
+    "    1.692481517791748,\n",
+    "    1.6409776210784912,\n",
+    "    1.6216280460357666,\n",
+    "    1.6087706089019775,\n",
+    "    1.5776633024215698\n",
+    "  ],\n",
+    "  \"layers_per_block\": 2,\n",
+    "  \"mid_block_add_attention\": True,\n",
+    "  \"norm_num_groups\": 32,\n",
+    "  \"out_channels\": 3,\n",
+    "  \"sample_size\": 32,\n",
+    "  \"scaling_factor\": 1.0,\n",
+    "  \"shift_factor\": 0.0,\n",
+    "  \"up_block_types\": [\n",
+    "    \"UpDecoderBlock2D\",\n",
+    "    \"UpDecoderBlock2D\",\n",
+    "    \"UpDecoderBlock2D\",\n",
+    "    \"UpDecoderBlock2D\",\n",
+    "    \"UpDecoderBlock2D\"\n",
+    "  ],\n",
+    "  \"use_post_quant_conv\": True,\n",
+    "  \"use_quant_conv\": True\n",
+    "}\n",
+    "\n",
+    "\n",
+    "vae = AutoencoderKL(\n",
+    "    act_fn=config[\"act_fn\"],\n",
+    "    block_out_channels=config[\"block_out_channels\"],\n",
+    "    down_block_types=config[\"down_block_types\"],\n",
+    "    up_block_types=config[\"up_block_types\"],\n",
+    "    in_channels=config[\"in_channels\"],\n",
+    "    out_channels=config[\"out_channels\"],\n",
+    "    latent_channels=config[\"latent_channels\"],\n",
+    "    layers_per_block=3, #config[\"layers_per_block\"],\n",
+    "    norm_num_groups=config[\"norm_num_groups\"],\n",
+    "    sample_size=config[\"sample_size\"],\n",
+    "    scaling_factor=config[\"scaling_factor\"],\n",
+    "    force_upcast=config[\"force_upcast\"],\n",
+    "    mid_block_add_attention=config[\"mid_block_add_attention\"],\n",
+    "    use_quant_conv=config[\"use_quant_conv\"],\n",
+    "    use_post_quant_conv=config[\"use_post_quant_conv\"],\n",
+    "    latents_mean=(config[\"latents_mean\"]),\n",
+    "    latents_std=(config[\"latents_std\"]),\n",
+    ")\n",
+    "\n",
+    "vae.save_pretrained(\"vae16x32ch_empty\")\n",
+    "\n",
+    "print(vae)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "a2950158-5203-42b9-8791-e231ddbf1063",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Перенос весов: 100%|██████████| 292/292 [00:00<00:00, 35760.83it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Статистика переноса: {'перенесено': 292, 'несовпадение_размеров': 0, 'пропущено': 0}\n",
+      "Неперенесенные ключи в новой модели:\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",
+      "decoder.up_blocks.4.resnets.3.conv1.bias\n",
+      "decoder.up_blocks.4.resnets.3.conv1.weight\n",
+      "decoder.up_blocks.4.resnets.3.conv2.bias\n",
+      "decoder.up_blocks.4.resnets.3.conv2.weight\n",
+      "decoder.up_blocks.4.resnets.3.norm1.bias\n",
+      "decoder.up_blocks.4.resnets.3.norm1.weight\n",
+      "decoder.up_blocks.4.resnets.3.norm2.bias\n",
+      "decoder.up_blocks.4.resnets.3.norm2.weight\n",
+      "encoder.down_blocks.0.resnets.2.conv1.bias\n",
+      "encoder.down_blocks.0.resnets.2.conv1.weight\n",
+      "encoder.down_blocks.0.resnets.2.conv2.bias\n",
+      "encoder.down_blocks.0.resnets.2.conv2.weight\n",
+      "encoder.down_blocks.0.resnets.2.norm1.bias\n",
+      "encoder.down_blocks.0.resnets.2.norm1.weight\n",
+      "encoder.down_blocks.0.resnets.2.norm2.bias\n",
+      "encoder.down_blocks.0.resnets.2.norm2.weight\n",
+      "encoder.down_blocks.1.resnets.2.conv1.bias\n",
+      "encoder.down_blocks.1.resnets.2.conv1.weight\n",
+      "encoder.down_blocks.1.resnets.2.conv2.bias\n",
+      "encoder.down_blocks.1.resnets.2.conv2.weight\n",
+      "encoder.down_blocks.1.resnets.2.norm1.bias\n",
+      "encoder.down_blocks.1.resnets.2.norm1.weight\n",
+      "encoder.down_blocks.1.resnets.2.norm2.bias\n",
+      "encoder.down_blocks.1.resnets.2.norm2.weight\n",
+      "encoder.down_blocks.2.resnets.2.conv1.bias\n",
+      "encoder.down_blocks.2.resnets.2.conv1.weight\n",
+      "encoder.down_blocks.2.resnets.2.conv2.bias\n",
+      "encoder.down_blocks.2.resnets.2.conv2.weight\n",
+      "encoder.down_blocks.2.resnets.2.norm1.bias\n",
+      "encoder.down_blocks.2.resnets.2.norm1.weight\n",
+      "encoder.down_blocks.2.resnets.2.norm2.bias\n",
+      "encoder.down_blocks.2.resnets.2.norm2.weight\n",
+      "encoder.down_blocks.3.resnets.2.conv1.bias\n",
+      "encoder.down_blocks.3.resnets.2.conv1.weight\n",
+      "encoder.down_blocks.3.resnets.2.conv2.bias\n",
+      "encoder.down_blocks.3.resnets.2.conv2.weight\n",
+      "encoder.down_blocks.3.resnets.2.norm1.bias\n",
+      "encoder.down_blocks.3.resnets.2.norm1.weight\n",
+      "encoder.down_blocks.3.resnets.2.norm2.bias\n",
+      "encoder.down_blocks.3.resnets.2.norm2.weight\n",
+      "encoder.down_blocks.4.resnets.2.conv1.bias\n",
+      "encoder.down_blocks.4.resnets.2.conv1.weight\n",
+      "encoder.down_blocks.4.resnets.2.conv2.bias\n",
+      "encoder.down_blocks.4.resnets.2.conv2.weight\n",
+      "encoder.down_blocks.4.resnets.2.norm1.bias\n",
+      "encoder.down_blocks.4.resnets.2.norm1.weight\n",
+      "encoder.down_blocks.4.resnets.2.norm2.bias\n",
+      "encoder.down_blocks.4.resnets.2.norm2.weight\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "from diffusers import AutoencoderKL,AsymmetricAutoencoderKL\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 = \"vae16x32ch_new\"\n",
+    "    checkpoint_path_new = \"vae16x32ch_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 = AutoencoderKL.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(\"vae16x32ch\")\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": 11,
+   "id": "5a01b8e9-73c9-4da7-a097-e334019bd8e9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "The config attributes {'block_out_channels': [128, 128, 256, 512, 512], 'force_upcast': False, 'latents_mean': [-0.03542253375053406, 0.20086465775966644, -0.016413161531090736, -0.0956302210688591, -0.2672063112258911, 0.2609933018684387, -0.07806991040706635, -0.48407721519470215, 0.21844269335269928, -0.1122383326292038, 0.27197545766830444, -0.18958772718906403, 0.18776826560497284, 0.0987580344080925, 0.2837068736553192, -0.4486690163612366, 0.4816776514053345, 0.02947971224784851, -0.1337375044822693, -0.39750921726226807, -0.08513020724058151, -0.054023586213588715, -0.3943594992160797, 0.23918119072914124, -0.12466679513454437, 0.09935147315263748, 0.31858691573143005, 0.48585832118988037, -0.6416525840759277, -0.15164820849895477, -0.4693508744239807, -0.13071806728839874], 'latents_std': [1.5792087316513062, 1.5769503116607666, 1.5864241123199463, 1.6454921960830688, 1.5336694717407227, 1.5587652921676636, 1.5838669538497925, 1.5659377574920654, 1.6860467195510864, 1.5192310810089111, 1.573639988899231, 1.5953549146652222, 1.5271092653274536, 1.6246271133422852, 1.7054023742675781, 1.607722282409668, 1.558642864227295, 1.5824549198150635, 1.6202995777130127, 1.6206320524215698, 1.6379750967025757, 1.6527063846588135, 1.498811960220337, 1.5706247091293335, 1.5854856967926025, 1.4828169345855713, 1.5693111419677734, 1.692481517791748, 1.6409776210784912, 1.6216280460357666, 1.6087706089019775, 1.5776633024215698]} were passed to AsymmetricAutoencoderKL, but are not expected and will be ignored. Please verify your config.json configuration file.\n",
+      "Перенос весов: 100%|██████████| 284/284 [00:00<00:00, 30094.80it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Статистика: {'перенесено': 292, 'несовпадение_размеров': 0, 'пропущено': 10}\n",
+      "\n",
+      "Неперенесенные ��лючи:\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "from diffusers import AutoencoderKL, AsymmetricAutoencoderKL\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "\n",
+    "def log(message):\n",
+    "    print(message)\n",
+    "\n",
+    "\n",
+    "def remap_key(old_key: str):\n",
+    "    \"\"\"\n",
+    "    Смещение только encoder.down_blocks\n",
+    "    \"\"\"\n",
+    "\n",
+    "    if \"encoder.down_blocks\" not in old_key:\n",
+    "        return [old_key]\n",
+    "\n",
+    "    parts = old_key.split(\".\")\n",
+    "    block_id = int(parts[2])\n",
+    "\n",
+    "    if block_id == 0:\n",
+    "        # первый блок копируем дважды\n",
+    "        return [\n",
+    "            old_key.replace(\"down_blocks.0\", \"down_blocks.0\"),\n",
+    "            old_key.replace(\"down_blocks.0\", \"down_blocks.1\"),\n",
+    "        ]\n",
+    "\n",
+    "    # остальные блоки сдвигаем\n",
+    "    new_block = block_id + 1\n",
+    "    return [old_key.replace(f\"down_blocks.{block_id}\", f\"down_blocks.{new_block}\")]\n",
+    "\n",
+    "\n",
+    "def main():\n",
+    "    checkpoint_path_old = \"asymmetric_vae_new\"\n",
+    "    checkpoint_path_new = \"vae16x32ch_empty\"\n",
+    "\n",
+    "    device = \"cuda\"\n",
+    "    dtype = torch.float32\n",
+    "\n",
+    "    old_vae = AsymmetricAutoencoderKL.from_pretrained(checkpoint_path_old).to(device, dtype=dtype)\n",
+    "    new_vae = AutoencoderKL.from_pretrained(checkpoint_path_new).to(device, dtype=dtype)\n",
+    "\n",
+    "    old_state_dict = old_vae.state_dict()\n",
+    "    new_state_dict = new_vae.state_dict()\n",
+    "\n",
+    "    transferred_state_dict = {}\n",
+    "    transferred_keys = set()\n",
+    "\n",
+    "    transfer_stats = {\n",
+    "        \"перенесено\": 0,\n",
+    "        \"несовпадение_размеров\": 0,\n",
+    "        \"пропущено\": 0\n",
+    "    }\n",
+    "\n",
+    "    for old_key in tqdm(old_state_dict.keys(), desc=\"Перенос весов\"):\n",
+    "\n",
+    "        new_keys = remap_key(old_key)\n",
+    "\n",
+    "        for new_key in new_keys:\n",
+    "\n",
+    "            if new_key in new_state_dict:\n",
+    "\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(\n",
+    "                        f\"✗ Несовпадение размеров: \"\n",
+    "                        f\"{old_key} {old_state_dict[old_key].shape} \"\n",
+    "                        f\"-> {new_key} {new_state_dict[new_key].shape}\"\n",
+    "                    )\n",
+    "                    transfer_stats[\"несовпадение_размеров\"] += 1\n",
+    "            else:\n",
+    "                transfer_stats[\"пропущено\"] += 1\n",
+    "\n",
+    "    new_state_dict.update(transferred_state_dict)\n",
+    "\n",
+    "    new_vae.load_state_dict(new_state_dict)\n",
+    "    new_vae.save_pretrained(\"vae16x32ch\")\n",
+    "\n",
+    "    non_transferred_keys = sorted(set(new_state_dict.keys()) - transferred_keys)\n",
+    "\n",
+    "    print(\"Статистика:\", transfer_stats)\n",
+    "\n",
+    "    print(\"\\nНеперенесенные ключи:\")\n",
+    "    for key in non_transferred_keys:\n",
+    "        print(key)\n",
+    "\n",
+    "\n",
+    "if __name__ == \"__main__\":\n",
+    "    main()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fe8f1ceb-8d3e-4df5-a1dc-1b56a0d398a2",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python3 (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.12.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

diffusion_pytorch_model.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d349936a1faab1555bf81e68ba1e6fd2b84f6a6a46ffd11470079581d48bdfea
-size 343311604
+oid sha256:ccb16e414b415d5addff3f309a6a2f1e2ba39145587b1b2b6aa77b82ab20d5a4
+size 433047700

scale.py

@@ -0,0 +1,107 @@
+import torch
+import numpy as np
+from PIL import Image
+from diffusers import AutoencoderKL
+from tqdm import tqdm
+import pathlib
+
+# ── 1. Загружаем VAE ──────────────────────────────────────────────────────────
+vae = AutoencoderKL.from_pretrained("vae32ch", torch_dtype=torch.float32)
+vae.eval().cuda()
+
+vae_scale_factor = 2 ** (len(vae.config.block_out_channels) - 1)  # = 8
+
+# ── 2. Собираем все PNG рекурсивно ───────────────────────────────────────────
+dataset_path = pathlib.Path("/workspace/ds")
+image_paths  = sorted(dataset_path.rglob("*.png"))
+print(f"Найдено картинок: {len(image_paths)}")
+
+# Берём первые 3000
+image_paths = image_paths[:30000]
+
+# ── 3. Препроцессинг — кроп до кратного 8 без ресайза ────────────────────────
+def preprocess(path):
+    img = Image.open(path).convert("RGB")
+    w, h = img.size
+
+    new_w = (w // vae_scale_factor) * vae_scale_factor
+    new_h = (h // vae_scale_factor) * vae_scale_factor
+
+    if new_w != w or new_h != h:
+        left = (w - new_w) // 2
+        top  = (h - new_h) // 2
+        img  = img.crop((left, top, left + new_w, top + new_h))
+
+    x = torch.from_numpy(np.array(img).astype(np.float32) / 255.0)
+    x = x.permute(2, 0, 1).unsqueeze(0)  # [1, 3, H, W]
+    x = x * 2.0 - 1.0                    # [-1, 1]
+    return x
+
+# ── 4. Считаем статистику по каналам ─────────────────────────────────────────
+latent_channels = vae.config.latent_channels  # 32
+
+all_means = []  # [N, C]
+all_stds  = []  # [N, C]
+errors    = []
+
+with torch.no_grad():
+    for path in tqdm(image_paths, desc="Encoding"):
+        try:
+            x    = preprocess(path).cuda()
+            lat  = vae.encode(x).latent_dist.sample()          # [1, C, H, W]
+            flat = lat.squeeze(0).float().reshape(latent_channels, -1)  # [C, H*W]
+
+            all_means.append(flat.mean(dim=1).cpu())  # [C]
+            all_stds.append(flat.std(dim=1).cpu())    # [C]
+
+        except Exception as e:
+            errors.append((path, str(e)))
+
+if errors:
+    print(f"\nОшибки ({len(errors)}):")
+    for p, e in errors:
+        print(f"  {p}: {e}")
+
+mean = torch.stack(all_means).mean(dim=0)  # [C]
+std  = torch.stack(all_stds).mean(dim=0)   # [C]
+
+print(f"\nОбработано картинок: {len(all_means)}")
+print(f"\nlatents_mean ({latent_channels} каналов):")
+print(mean.tolist())
+print(f"\nlatents_std ({latent_channels} каналов):")
+print(std.tolist())
+
+# ── 5. Создаём новый VAE с той же архитектурой + scaling векторы ──────────────
+cfg = vae.config
+
+new_vae = AutoencoderKL(
+    in_channels        = cfg.in_channels,
+    out_channels       = cfg.out_channels,
+    latent_channels    = cfg.latent_channels,
+    block_out_channels = cfg.block_out_channels,
+    layers_per_block   = cfg.layers_per_block,
+    norm_num_groups    = cfg.norm_num_groups,
+    act_fn             = cfg.act_fn,
+    down_block_types   = cfg.down_block_types,
+    up_block_types     = cfg.up_block_types,
+)
+new_vae.eval()
+
+# Переносим веса
+result = new_vae.load_state_dict(vae.state_dict(), strict=False)
+print(f"\nВеса перенесены: {result}")
+
+# Прописываем scaling векторы в конфиг
+new_vae.register_to_config(
+    latents_mean   = mean.tolist(),
+    latents_std    = std.tolist(),
+    scaling_factor = 1.0,
+    shift_factor   = 0.0,
+)
+
+print(f"\nlatents_mean в конфиге: {new_vae.config.latents_mean[:4]}...")
+print(f"latents_std  в конфиге: {new_vae.config.latents_std[:4]}...")
+
+# ── 6. Сохраняем ──────────────────────────────────────────────────────────────
+new_vae.save_pretrained("vae32ch2")
+print("\nСохранено в vae32ch2/")

train_vae_16x.py

@@ -29,7 +29,7 @@ from collections import deque
 
 # --------------------------- Параметры ---------------------------
 ds_path            = "/workspace/d23"
-project            = "vae16x32ch_new"
+project            = "vae16x32ch"
 batch_size         = 1
 base_learning_rate = 6e-6
 min_learning_rate  = 7e-7
@@ -41,8 +41,8 @@ use_decay          = True
 optimizer_type     = "adam8bit"
 dtype              = torch.float32
 
-model_resolution   = 768 #448 #288
-high_resolution    = 768 #896 #576 
+model_resolution   = 640 #448 #288
+high_resolution    = 640 #896 #576 
 limit              = 0
 save_barrier       = 1.3
 warmup_percent     = 0.005
@@ -53,7 +53,7 @@ clip_grad_norm     = 1.0
 mixed_precision    = "no"
 gradient_accumulation_steps = 1
 generated_folder   = "samples"
-save_as            = "vae16x32ch_new"
+save_as            = "vae16x32ch"
 num_workers        = 0
 device = None
 torch.backends.cuda.matmul.allow_tf32 = True
@@ -95,7 +95,7 @@ accelerator = Accelerator(
 device = accelerator.device
 
 # reproducibility
-seed = int(datetime.now().strftime("%Y%m%d")) + 13
+seed = int(datetime.now().strftime("%Y%m%d")) + 42
 torch.manual_seed(seed); np.random.seed(seed); random.seed(seed)
 torch.backends.cudnn.benchmark = False