Super-squash branch 'main' using huggingface_hub

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,13 @@
+---
+title: Download and Convert FLUX.1 ComfyUI Safetensors To Diffusers (Give Up)
+emoji: 🎨➡️🧨
+colorFrom: indigo
+colorTo: purple
+sdk: gradio
+sdk_version: 4.40.0
+app_file: app.py
+pinned: false
+license: mit
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,59 @@
+import gradio as gr
+import spaces
+import os
+from convert_url_to_diffusers_flux_gr import convert_url_to_diffusers_repo_flux
+os.environ["GRADIO_ANALYTICS_ENABLED"] = "False"
+
+
+css = """"""
+
+with gr.Blocks(theme="NoCrypt/miku@>=1.2.2", fill_width=True, css=css) as demo:
+    gr.Markdown("# Download and convert FLUX.1 ComfyUI formatted safetensors to Diffusers and create your repo")
+    gr.Markdown(
+        f"""
+**⚠️IMPORTANT NOTICE⚠️**<br>
+# If the output setting was fp8, this space could be completed in about 10 minutes, but **the torch on HF's server apparently does not support fp8 input**, which makes no sense.
+The conversion to bf16 does not seem feasible in any way at present. Even if the file is processed as shard, it still does not work due to lack of RAM. (P.S. But then the RAM was down to only 60% consumption. I don't know why anymore.)
+I guess I'll have to freeze it until someone with more advanced technology realizes it, or until Diffusers, pytorch, or Quanto will be upgraded.<br><br>
+From an information security standpoint, it is dangerous to expose your access token or key to others.
+If you do use it, I recommend that you duplicate this space on your own account before doing so.
+Keys and tokens could be set to SECRET (HF_TOKEN, CIVITAI_API_KEY) if it's placed in your own space.
+It saves you the trouble of typing them in.<br>
+<br>
+**The steps are the following**:
+- Paste a write-access token from [hf.co/settings/tokens](https://huggingface.co/settings/tokens).
+- Input a model download url from the Hub or Civitai or other sites.
+- If you want to download a model from Civitai, paste a Civitai API Key.
+- Input your HF user ID. e.g. 'yourid'.
+- Input your new repo name. If empty, auto-complete. e.g. 'newrepo'.
+- Set the parameters. If not sure, just use the defaults.
+- Click "Submit".
+- Patiently wait until the output changes. It takes approximately ? minutes (downloading from HF).
+            """
+    )
+    with gr.Column():
+        dl_url = gr.Textbox(label="URL to download", placeholder="https://huggingface.co/marduk191/Flux.1_collection/blob/main/flux.1_dev_fp8_fp16t5-marduk191.safetensors", value="", max_lines=1)
+        hf_user = gr.Textbox(label="Your HF user ID", placeholder="username", value="", max_lines=1)
+        hf_repo = gr.Textbox(label="New repo name", placeholder="reponame", info="If empty, auto-complete", value="", max_lines=1)
+        hf_token = gr.Textbox(label="Your HF write token", placeholder="hf_...", value="", max_lines=1)
+        civitai_key = gr.Textbox(label="Your Civitai API Key (Optional)", info="If you download model from Civitai...", placeholder="", value="", max_lines=1)
+        is_upload_sf = gr.Checkbox(label="Upload single safetensors file into new repo", value=False, visible=False)
+        data_type = gr.Radio(label="Output data type", info="It only affects transformer and text encoder.", choices=["bf16", "fp8", "qfloat8"], value="fp8")
+        model_type = gr.Radio(label="Original model type", choices=["dev", "schnell"], value="dev")
+        is_dequat = gr.Checkbox(label="Dequantization", info="Deadly slow", value=False)
+        use_original = gr.CheckboxGroup(label="Use original version", choices=["vae", "text_encoder", "text_encoder_2"], value=["vae", "text_encoder"])
+        is_fix_only = gr.Checkbox(label="Only fixing", value=False)
+        run_button = gr.Button(value="Submit")
+        repo_urls = gr.CheckboxGroup(visible=False, choices=[], value=None)
+        output_md = gr.Markdown(label="Output")
+    gr.DuplicateButton(value="Duplicate Space")
+
+    gr.on(
+        triggers=[run_button.click],
+        fn=convert_url_to_diffusers_repo_flux,
+        inputs=[dl_url, hf_user, hf_repo, hf_token, civitai_key, is_upload_sf,
+                data_type, model_type, is_dequat, repo_urls, is_fix_only, use_original],
+        outputs=[repo_urls, output_md],
+    )
+
+demo.queue(default_concurrency_limit=1, max_size=5).launch(debug=True, show_api=False)

convert_url_to_diffusers_flux_gr.py

@@ -0,0 +1,939 @@
+import json
+import torch
+from safetensors.torch import load_file, save_file
+from pathlib import Path
+import gc
+import gguf
+from dequant import dequantize_tensor # https://github.com/city96/ComfyUI-GGUF
+
+import os
+import argparse
+import gradio as gr
+# also requires aria, gdown, peft, huggingface_hub, safetensors, transformers, accelerate, pytorch_lightning
+import spaces
+
+flux_dev_repo = "ChuckMcSneed/FLUX.1-dev"
+flux_schnell_repo = "black-forest-labs/FLUX.1-schnell"
+system_temp_dir = "temp"
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+torch.set_grad_enabled(False)
+
+GGUF_QTYPE = [gguf.GGMLQuantizationType.Q8_0, gguf.GGMLQuantizationType.Q5_1,
+    gguf.GGMLQuantizationType.Q5_0, gguf.GGMLQuantizationType.Q4_1,
+    gguf.GGMLQuantizationType.Q4_0, gguf.GGMLQuantizationType.F32, gguf.GGMLQuantizationType.F16]
+
+TORCH_DTYPE = [torch.float32, torch.float, torch.float64, torch.double, torch.float16, torch.half,
+    torch.bfloat16, torch.complex32, torch.chalf, torch.complex64, torch.cfloat,
+    torch.complex128, torch.cdouble, torch.uint8, torch.uint16, torch.uint32, torch.uint64,
+    torch.int8, torch.int16, torch.short, torch.int32, torch.int, torch.int64, torch.long,
+    torch.bool, torch.float8_e4m3fn, torch.float8_e5m2]
+
+TORCH_QUANTIZED_DTYPE = [torch.quint8, torch.qint8, torch.qint32, torch.quint4x2]
+
+def list_sub(a, b):
+    return [e for e in a if e not in b]
+
+def is_repo_name(s):
+    import re
+    return re.fullmatch(r'^[^/,\s]+?/[^/,\s]+?$', s)
+
+def print_resource_usage():
+    import psutil
+    cpu_usage = psutil.cpu_percent()
+    ram_usage = psutil.virtual_memory().used / psutil.virtual_memory().total * 100
+    print(f"CPU usage: {cpu_usage}% / RAM usage: {ram_usage}%")
+
+def download_thing(directory, url, civitai_api_key="", progress=gr.Progress(track_tqdm=True)):
+    progress(0, desc="Start downloading...")
+    url = url.strip()
+    if "drive.google.com" in url:
+        original_dir = os.getcwd()
+        os.chdir(directory)
+        os.system(f"gdown --fuzzy {url}")
+        os.chdir(original_dir)
+    elif "huggingface.co" in url:
+        url = url.replace("?download=true", "")
+        if "/blob/" in url:
+            url = url.replace("/blob/", "/resolve/")
+            os.system(f"aria2c --console-log-level=error --summary-interval=10 -c -x 16 -k 1M -s 16 {url} -d {directory}  -o {url.split('/')[-1]}")
+        else:
+            os.system (f"aria2c --optimize-concurrent-downloads --console-log-level=error --summary-interval=10 -c -x 16 -k 1M -s 16 {url} -d {directory}  -o {url.split('/')[-1]}")
+    elif "civitai.com" in url:
+        if "?" in url:
+            url = url.split("?")[0]
+        if civitai_api_key:
+            url = url + f"?token={civitai_api_key}"
+            os.system(f"aria2c --console-log-level=error --summary-interval=10 -c -x 16 -k 1M -s 16 -d {directory} {url}")
+        else:
+            print("You need an API key to download Civitai models.")
+    else:
+        os.system(f"aria2c --console-log-level=error --summary-interval=10 -c -x 16 -k 1M -s 16 -d {directory} {url}")
+
+def get_local_model_list(dir_path):
+    model_list = []
+    valid_extensions = ('.safetensors')
+    for file in Path(dir_path).glob("*"):
+        if file.suffix in valid_extensions:
+            file_path = str(Path(f"{dir_path}/{file.name}"))
+            model_list.append(file_path)
+    return model_list
+
+def get_download_file(temp_dir, url, civitai_key, progress=gr.Progress(track_tqdm=True)):
+    if not "http" in url and is_repo_name(url) and not Path(url).exists():
+        print(f"Use HF Repo: {url}")
+        new_file = url
+    elif not "http" in url and Path(url).exists():
+        print(f"Use local file: {url}")
+        new_file = url
+    elif Path(f"{temp_dir}/{url.split('/')[-1]}").exists():
+        print(f"File to download alreday exists: {url}")
+        new_file = f"{temp_dir}/{url.split('/')[-1]}"
+    else:
+        print(f"Start downloading: {url}")
+        before = get_local_model_list(temp_dir)
+        try:
+            download_thing(temp_dir, url.strip(), civitai_key)
+        except Exception:
+            print(f"Download failed: {url}")
+            return ""
+        after = get_local_model_list(temp_dir)
+        new_file = list_sub(after, before)[0] if list_sub(after, before) else ""
+    if not new_file:
+        print(f"Download failed: {url}")
+        return ""
+    print(f"Download completed: {url}")
+    return new_file
+
+def save_readme_md(dir, url):
+    orig_url = ""
+    if "http" in url:
+        orig_url = url
+    if orig_url:
+       md = f"""---
+license: other
+license_name: flux-1-dev-non-commercial-license
+license_link: https://huggingface.co/black-forest-labs/FLUX.1-dev/blob/main/LICENSE.
+language:
+- en
+library_name: diffusers
+pipeline_tag: text-to-image
+tags:
+- text-to-image
+- Flux
+---
+Converted from [{orig_url}]({orig_url}).
+"""
+    else:
+        md = f"""---
+license: other
+license_name: flux-1-dev-non-commercial-license
+license_link: https://huggingface.co/black-forest-labs/FLUX.1-dev/blob/main/LICENSE.
+language:
+- en
+library_name: diffusers
+pipeline_tag: text-to-image
+tags:
+- text-to-image
+- Flux
+---
+"""
+    path = str(Path(dir, "README.md"))
+    with open(path, mode='w', encoding="utf-8") as f:
+        f.write(md)
+
+def is_repo_exists(repo_id):
+    from huggingface_hub import HfApi
+    api = HfApi()
+    try:
+        if api.repo_exists(repo_id=repo_id): return True
+        else: return False
+    except Exception as e:
+        print(f"Error: Failed to connect {repo_id}. ")
+        return True # for safe
+
+def create_diffusers_repo(new_repo_id, diffusers_folder, progress=gr.Progress(track_tqdm=True)):
+    from huggingface_hub import HfApi
+    import os
+    hf_token = os.environ.get("HF_TOKEN")
+    api = HfApi()
+    try:
+        progress(0, desc="Start uploading...")
+        api.create_repo(repo_id=new_repo_id, token=hf_token, private=True, exist_ok=True)
+        for path in Path(diffusers_folder).glob("*"):
+            if path.is_dir():
+                api.upload_folder(repo_id=new_repo_id, folder_path=str(path), path_in_repo=path.name, token=hf_token)
+            elif path.is_file():
+                api.upload_file(repo_id=new_repo_id, path_or_fileobj=str(path), path_in_repo=path.name, token=hf_token)
+        progress(1, desc="Uploaded.")
+        url = f"https://huggingface.co/{new_repo_id}"
+    except Exception as e:
+        print(f"Error: Failed to upload to {new_repo_id}. ")
+        print(e)
+        return ""
+    return url
+
+# https://github.com/huggingface/diffusers/blob/main/scripts/convert_flux_to_diffusers.py 
+# in SD3 original implementation of AdaLayerNormContinuous, it split linear projection output into shift, scale;
+# while in diffusers it split into scale, shift. Here we swap the linear projection weights in order to be able to use diffusers implementation
+with torch.no_grad(), torch.autocast(device):
+    @torch.jit.script
+    def swap_scale_shift(weight):
+        shift, scale = weight.chunk(2, dim=0)
+        new_weight = torch.cat([scale, shift], dim=0)
+        return new_weight
+
+with torch.no_grad(), torch.autocast(device):
+    def convert_flux_transformer_checkpoint_to_diffusers(
+        original_state_dict, num_layers, num_single_layers, inner_dim, mlp_ratio=4.0,
+        progress=gr.Progress(track_tqdm=True)):
+        def conv(cdict: dict, odict: dict, ckey: str, okey: str):
+            if okey in odict.keys():
+                progress(0, desc=f"Converting {okey} => {ckey}")
+                print(f"Converting {okey} => {ckey}")
+                cdict[ckey] = odict.pop(okey)
+                gc.collect()
+
+        def convswap(cdict: dict, odict: dict, ckey: str, okey: str):
+            if okey in odict.keys():
+                progress(0, desc=f"Converting (swap) {okey} => {ckey}")
+                print(f"Converting {okey} => {ckey} (swap)")
+                cdict[ckey] = swap_scale_shift(odict.pop(okey))
+                gc.collect()
+
+        def convqkv(cdict: dict, odict: dict, i: int):
+            keys = odict.keys()
+            if (f"double_blocks.{i}.img_attn.qkv.weight" in keys or f"double_blocks.{i}.txt_attn.qkv.weight" in keys\
+                or f"double_blocks.{i}.img_attn.qkv.bias" in keys or f"double_blocks.{i}.txt_attn.qkv.bias" in keys)\
+                and (f"double_blocks.{i}.img_attn.qkv.weight" not in keys or f"double_blocks.{i}.txt_attn.qkv.weight" not in keys\
+                     or f"double_blocks.{i}.img_attn.qkv.bias" not in keys or f"double_blocks.{i}.txt_attn.qkv.bias" not in keys):
+                progress(0, desc=f"Key error in converting Q, K, V (double_blocks.{i}).")
+                print(f"Key error in converting Q, K, V (double_blocks.{i}).")
+                return
+            progress(0, desc=f"Converting Q, K, V (double_blocks.{i}).")
+            print(f"Converting Q, K, V (double_blocks.{i}).")
+            sample_q, sample_k, sample_v = torch.chunk(
+                odict.pop(f"double_blocks.{i}.img_attn.qkv.weight"), 3, dim=0
+            )
+            context_q, context_k, context_v = torch.chunk(
+                odict.pop(f"double_blocks.{i}.txt_attn.qkv.weight"), 3, dim=0
+            )
+            sample_q_bias, sample_k_bias, sample_v_bias = torch.chunk(
+                odict.pop(f"double_blocks.{i}.img_attn.qkv.bias"), 3, dim=0
+            )
+            context_q_bias, context_k_bias, context_v_bias = torch.chunk(
+                odict.pop(f"double_blocks.{i}.txt_attn.qkv.bias"), 3, dim=0
+            )
+            cdict[f"{block_prefix}attn.to_q.weight"] = torch.cat([sample_q])
+            cdict[f"{block_prefix}attn.to_q.bias"] = torch.cat([sample_q_bias])
+            cdict[f"{block_prefix}attn.to_k.weight"] = torch.cat([sample_k])
+            cdict[f"{block_prefix}attn.to_k.bias"] = torch.cat([sample_k_bias])
+            cdict[f"{block_prefix}attn.to_v.weight"] = torch.cat([sample_v])
+            cdict[f"{block_prefix}attn.to_v.bias"] = torch.cat([sample_v_bias])
+            cdict[f"{block_prefix}attn.add_q_proj.weight"] = torch.cat([context_q])
+            cdict[f"{block_prefix}attn.add_q_proj.bias"] = torch.cat([context_q_bias])
+            cdict[f"{block_prefix}attn.add_k_proj.weight"] = torch.cat([context_k])
+            cdict[f"{block_prefix}attn.add_k_proj.bias"] = torch.cat([context_k_bias])
+            cdict[f"{block_prefix}attn.add_v_proj.weight"] = torch.cat([context_v])
+            cdict[f"{block_prefix}attn.add_v_proj.bias"] = torch.cat([context_v_bias])
+            gc.collect()
+
+        def convqkvmlp(cdict: dict, odict: dict, i: int, inner_dim: int, mlp_ratio: float):
+            keys = odict.keys()
+            if (f"single_blocks.{i}.linear1.weight" in keys or f"single_blocks.{i}.linear1.bias" in keys)\
+                and (f"single_blocks.{i}.linear1.weight" not in keys or f"single_blocks.{i}.linear1.bias" not in keys):
+                progress(0, desc=f"Key error in converting Q, K, V, mlp (single_blocks.{i}).")
+                print(f"Key error in converting Q, K, V, mlp (single_blocks.{i}).")
+                return
+            progress(0, desc=f"Converting Q, K, V, mlp (single_blocks.{i}).")
+            print(f"Converting Q, K, V, mlp (single_blocks.{i}).")
+            mlp_hidden_dim = int(inner_dim * mlp_ratio)
+            split_size = (inner_dim, inner_dim, inner_dim, mlp_hidden_dim)
+            q, k, v, mlp = torch.split(odict.pop(f"single_blocks.{i}.linear1.weight"), split_size, dim=0)
+            q_bias, k_bias, v_bias, mlp_bias = torch.split(
+                odict.pop(f"single_blocks.{i}.linear1.bias"), split_size, dim=0
+            )
+            cdict[f"{block_prefix}attn.to_q.weight"] = torch.cat([q])
+            cdict[f"{block_prefix}attn.to_q.bias"] = torch.cat([q_bias])
+            cdict[f"{block_prefix}attn.to_k.weight"] = torch.cat([k])
+            cdict[f"{block_prefix}attn.to_k.bias"] = torch.cat([k_bias])
+            cdict[f"{block_prefix}attn.to_v.weight"] = torch.cat([v])
+            cdict[f"{block_prefix}attn.to_v.bias"] = torch.cat([v_bias])
+            cdict[f"{block_prefix}proj_mlp.weight"] = torch.cat([mlp])
+            cdict[f"{block_prefix}proj_mlp.bias"] = torch.cat([mlp_bias])
+            gc.collect()
+
+        converted_state_dict = {}
+        progress(0, desc="Converting FLUX.1 state dict to Diffusers format.")
+
+        ## time_text_embed.timestep_embedder <-  time_in
+        conv(converted_state_dict, original_state_dict, "time_text_embed.timestep_embedder.linear_1.weight", "time_in.in_layer.weight")
+        conv(converted_state_dict, original_state_dict, "time_text_embed.timestep_embedder.linear_1.bias", "time_in.in_layer.bias")
+        conv(converted_state_dict, original_state_dict, "time_text_embed.timestep_embedder.linear_2.weight", "time_in.out_layer.weight")
+        conv(converted_state_dict, original_state_dict, "time_text_embed.timestep_embedder.linear_2.bias", "time_in.out_layer.bias")
+
+        ## time_text_embed.text_embedder <- vector_in
+        conv(converted_state_dict, original_state_dict, "time_text_embed.text_embedder.linear_1.weight", "vector_in.in_layer.weight")
+        conv(converted_state_dict, original_state_dict, "time_text_embed.text_embedder.linear_1.bias", "vector_in.in_layer.bias")
+        conv(converted_state_dict, original_state_dict, "time_text_embed.text_embedder.linear_2.weight", "vector_in.out_layer.weight")
+        conv(converted_state_dict, original_state_dict, "time_text_embed.text_embedder.linear_2.bias", "vector_in.out_layer.bias")
+
+        # guidance
+        has_guidance = any("guidance" in k for k in original_state_dict)
+        if has_guidance:
+            conv(converted_state_dict, original_state_dict, "time_text_embed.guidance_embedder.linear_1.weight", "guidance_in.in_layer.weight")
+            conv(converted_state_dict, original_state_dict, "time_text_embed.guidance_embedder.linear_1.bias", "guidance_in.in_layer.bias")
+            conv(converted_state_dict, original_state_dict, "time_text_embed.guidance_embedder.linear_2.weight", "guidance_in.out_layer.weight")
+            conv(converted_state_dict, original_state_dict, "time_text_embed.guidance_embedder.linear_2.bias", "guidance_in.out_layer.bias")
+
+        # context_embedder
+        conv(converted_state_dict, original_state_dict, "context_embedder.weight", "txt_in.weight")
+        conv(converted_state_dict, original_state_dict, "context_embedder.bias", "txt_in.bias")
+
+        # x_embedder
+        conv(converted_state_dict, original_state_dict, "x_embedder.weight", "img_in.weight")
+        conv(converted_state_dict, original_state_dict, "x_embedder.bias", "img_in.bias")
+
+        progress(0.25, desc="Converting FLUX.1 state dict to Diffusers format.")
+        # double transformer blocks
+        for i in range(num_layers):
+            block_prefix = f"transformer_blocks.{i}."
+            # norms.
+            ## norm1
+            conv(converted_state_dict, original_state_dict, f"{block_prefix}norm1.linear.weight", f"double_blocks.{i}.img_mod.lin.weight")
+            conv(converted_state_dict, original_state_dict, f"{block_prefix}norm1.linear.bias", f"double_blocks.{i}.img_mod.lin.bias")
+            ## norm1_context
+            conv(converted_state_dict, original_state_dict, f"{block_prefix}norm1_context.linear.weight", f"double_blocks.{i}.txt_mod.lin.weight")
+            conv(converted_state_dict, original_state_dict, f"{block_prefix}norm1_context.linear.bias", f"double_blocks.{i}.txt_mod.lin.bias")
+            # Q, K, V
+            convqkv(converted_state_dict, original_state_dict, i)
+            # qk_norm
+            conv(converted_state_dict, original_state_dict, f"{block_prefix}attn.norm_q.weight", f"double_blocks.{i}.img_attn.norm.query_norm.scale")
+            conv(converted_state_dict, original_state_dict, f"{block_prefix}attn.norm_k.weight", f"double_blocks.{i}.img_attn.norm.key_norm.scale")
+            conv(converted_state_dict, original_state_dict, f"{block_prefix}attn.norm_added_q.weight", f"double_blocks.{i}.txt_attn.norm.query_norm.scale")
+            conv(converted_state_dict, original_state_dict, f"{block_prefix}attn.norm_added_k.weight", f"double_blocks.{i}.txt_attn.norm.key_norm.scale")
+            # ff img_mlp
+            conv(converted_state_dict, original_state_dict, f"{block_prefix}ff.net.0.proj.weight", f"double_blocks.{i}.img_mlp.0.weight")
+            conv(converted_state_dict, original_state_dict, f"{block_prefix}ff.net.0.proj.bias", f"double_blocks.{i}.img_mlp.0.bias")
+            conv(converted_state_dict, original_state_dict, f"{block_prefix}ff.net.2.weight", f"double_blocks.{i}.img_mlp.2.weight")
+            conv(converted_state_dict, original_state_dict, f"{block_prefix}ff.net.2.bias", f"double_blocks.{i}.img_mlp.2.bias")
+            conv(converted_state_dict, original_state_dict, f"{block_prefix}ff_context.net.0.proj.weight", f"double_blocks.{i}.txt_mlp.0.weight")
+            conv(converted_state_dict, original_state_dict, f"{block_prefix}ff_context.net.0.proj.bias", f"double_blocks.{i}.txt_mlp.0.bias")
+            conv(converted_state_dict, original_state_dict, f"{block_prefix}ff_context.net.2.weight", f"double_blocks.{i}.txt_mlp.2.weight")
+            conv(converted_state_dict, original_state_dict, f"{block_prefix}ff_context.net.2.bias", f"double_blocks.{i}.txt_mlp.2.bias")
+            # output projections.
+            conv(converted_state_dict, original_state_dict, f"{block_prefix}attn.to_out.0.weight", f"double_blocks.{i}.img_attn.proj.weight")
+            conv(converted_state_dict, original_state_dict, f"{block_prefix}attn.to_out.0.bias", f"double_blocks.{i}.img_attn.proj.bias")
+            conv(converted_state_dict, original_state_dict, f"{block_prefix}attn.to_add_out.weight", f"double_blocks.{i}.txt_attn.proj.weight")
+            conv(converted_state_dict, original_state_dict, f"{block_prefix}attn.to_add_out.bias", f"double_blocks.{i}.txt_attn.proj.bias")
+
+        progress(0.5, desc="Converting FLUX.1 state dict to Diffusers format.")
+        # single transfomer blocks
+        for i in range(num_single_layers):
+            block_prefix = f"single_transformer_blocks.{i}."
+            # norm.linear  <- single_blocks.0.modulation.lin
+            conv(converted_state_dict, original_state_dict, f"{block_prefix}norm.linear.weight", f"single_blocks.{i}.modulation.lin.weight")
+            conv(converted_state_dict, original_state_dict, f"{block_prefix}norm.linear.bias", f"single_blocks.{i}.modulation.lin.bias")
+            # Q, K, V, mlp
+            convqkvmlp(converted_state_dict, original_state_dict, i, inner_dim, mlp_ratio)
+            # qk norm
+            conv(converted_state_dict, original_state_dict, f"{block_prefix}attn.norm_q.weight", f"single_blocks.{i}.norm.query_norm.scale")
+            conv(converted_state_dict, original_state_dict, f"{block_prefix}attn.norm_k.weight", f"single_blocks.{i}.norm.key_norm.scale")
+            # output projections.
+            conv(converted_state_dict, original_state_dict, f"{block_prefix}proj_out.weight", f"single_blocks.{i}.linear2.weight")
+            conv(converted_state_dict, original_state_dict, f"{block_prefix}proj_out.bias", f"single_blocks.{i}.linear2.bias")
+
+        progress(0.75, desc="Converting FLUX.1 state dict to Diffusers format.")
+        conv(converted_state_dict, original_state_dict, "proj_out.weight", "final_layer.linear.weight")
+        conv(converted_state_dict, original_state_dict, "proj_out.bias", "final_layer.linear.bias")
+        convswap(converted_state_dict, original_state_dict, "norm_out.linear.weight", "final_layer.adaLN_modulation.1.weight")
+        convswap(converted_state_dict, original_state_dict, "norm_out.linear.bias", "final_layer.adaLN_modulation.1.bias")
+
+        progress(1, desc="Converting FLUX.1 state dict to Diffusers format.")
+        return converted_state_dict
+
+# read safetensors metadata
+def read_safetensors_metadata(path):
+    with open(path, 'rb') as f:       
+        header_size = int.from_bytes(f.read(8), 'little')
+        header_json = f.read(header_size).decode('utf-8')
+        header = json.loads(header_json)
+        metadata = header.get('__metadata__', {})
+        return metadata
+
+def normalize_key(k: str):
+    return k.replace("vae.", "").replace("model.diffusion_model.", "")\
+        .replace("text_encoders.clip_l.transformer.text_model.", "")\
+        .replace("text_encoders.t5xxl.transformer.", "")
+
+def load_json_list(path: str):
+    try:
+        with open(path, encoding='utf-8') as f:
+            return list(json.load(f))
+    except Exception as e:
+        print(e)
+        return []
+
+# https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py
+# https://huggingface.co/docs/huggingface_hub/v0.24.5/package_reference/serialization
+# https://huggingface.co/docs/huggingface_hub/index
+with torch.no_grad():
+    def to_safetensors(sd: dict, path: str, pattern: str, size: str, progress=gr.Progress(track_tqdm=True)):
+        from huggingface_hub import save_torch_state_dict
+        print(f"Saving a temporary file to disk: {path}")
+        os.makedirs(path, exist_ok=True)
+        try:
+            for k, v in sd.items():
+                sd[k] = v.to(device="cpu")
+            save_torch_state_dict(sd, path, filename_pattern=pattern, max_shard_size=size)
+        except Exception as e:
+            print(e)
+
+# https://discuss.huggingface.co/t/t5forconditionalgeneration-checkpoint-size-mismatch-19418/24119
+# https://github.com/huggingface/transformers/issues/13769
+# https://github.com/huggingface/optimum-quanto/issues/278
+# https://github.com/huggingface/huggingface_hub/blob/main/src/huggingface_hub/serialization/_torch.py
+with torch.no_grad():
+    def to_safetensors_flux_module(sd: dict, path: str, pattern: str, size: str,
+                                        quantization: bool=False, name: str = "",
+                                        metadata: dict | None = None, progress=gr.Progress(track_tqdm=True)):
+        from huggingface_hub import save_torch_state_dict
+        try:
+            progress(0, desc=f"Preparing to save FLUX.1 {name} to Diffusers format.")
+            print(f"Preparing to save FLUX.1 {name} to Diffusers format.")
+            for k, v in sd.items():
+                sd[k] = v.to(device="cpu")
+            progress(0, desc=f"Loading FLUX.1 {name}.")
+            print(f"Loading FLUX.1 {name}.")
+            os.makedirs(path, exist_ok=True)
+            if quantization:
+                progress(0.5, desc=f"Saving quantized FLUX.1 {name} to {path}")
+                print(f"Saving quantized FLUX.1 {name} to {path}")
+            else:
+                progress(0.5, desc=f"Saving FLUX.1 {name} to: {path}")
+                print(f"Saving FLUX.1 {name} to: {path}")
+                if metadata is not None:
+                    save_torch_state_dict(state_dict=sd, save_directory=path,
+                                        filename_pattern=pattern, max_shard_size=size, metadata=metadata)
+                else:
+                    save_torch_state_dict(state_dict=sd, save_directory=path,
+                                        filename_pattern=pattern, max_shard_size=size)
+                progress(1, desc=f"Saved FLUX.1 {name} to: {path}")
+                print(f"Saved FLUX.1 {name} to: {path}")
+        except Exception as e:
+            print(e)
+        finally:
+            gc.collect()
+
+flux_transformer_json = "flux_transformer_keys.json"
+flux_t5xxl_json = "flux_t5xxl_keys.json"
+flux_clip_json = "flux_clip_keys.json"
+flux_vae_json = "flux_vae_keys.json"
+keys_flux_t5xxl = set(load_json_list(flux_t5xxl_json))
+keys_flux_transformer = set(load_json_list(flux_transformer_json))
+keys_flux_clip = set(load_json_list(flux_clip_json))
+keys_flux_vae = set(load_json_list(flux_vae_json))
+
+with torch.no_grad():
+    def dequant_tensor(v: torch.Tensor, dtype: torch.dtype, dequant: bool):
+        try:
+            #print(f"shape: {v.shape} / dim: {v.ndim}")
+            if dequant:
+                qtype = v.tensor_type
+                if v.dtype in TORCH_DTYPE: return v.to(dtype) if v.dtype != dtype else v
+                elif qtype in GGUF_QTYPE: return dequantize_tensor(v, dtype)
+                elif torch.dtype in TORCH_QUANTIZED_DTYPE: return torch.dequantize(v).to(dtype)
+                else: return torch.dequantize(v).to(dtype)
+            else: return v.to(dtype) if v.dtype != dtype else v
+        except Exception as e:
+            print(e)
+
+with torch.no_grad():
+    def normalize_flux_state_dict(path: str, savepath: str, dtype: torch.dtype = torch.bfloat16,
+                                dequant: bool = False, progress=gr.Progress(track_tqdm=True)):
+        progress(0, desc=f"Loading and normalizing FLUX.1 safetensors: {path}")
+        print(f"Loading and normalizing FLUX.1 safetensors: {path}")
+        new_sd = dict()
+        state_dict = load_file(path, device="cpu")
+        try:
+            for k in list(state_dict.keys()):
+                v = state_dict.pop(k)
+                nk = normalize_key(k)
+                print(f"{k} => {nk}") #
+                new_sd[nk] = dequant_tensor(v, dtype, dequant)
+        except Exception as e:
+            print(e)
+            return
+        finally:
+            del state_dict
+            torch.cuda.empty_cache()
+            gc.collect()
+        new_path = str(Path(savepath, Path(path).stem + "_fixed" + Path(path).suffix))
+        metadata = read_safetensors_metadata(path)
+        progress(0.5, desc=f"Saving FLUX.1 safetensors: {new_path}")
+        print(f"Saving FLUX.1 safetensors: {new_path}")
+        os.makedirs(savepath, exist_ok=True)
+        save_file(new_sd, new_path, metadata={"format": "pt", **metadata})
+        progress(1, desc=f"Saved FLUX.1 safetensors: {new_path}")
+        print(f"Saved FLUX.1 safetensors: {new_path}")
+        del new_sd
+        torch.cuda.empty_cache()
+        gc.collect()
+
+with torch.no_grad():
+    def extract_norm_flux_module_sd(path: str, dtype: torch.dtype = torch.bfloat16,
+                                        dequant: bool = False, name: str = "", keys: set = {},
+                                        progress=gr.Progress(track_tqdm=True)):
+        progress(0, desc=f"Loading and normalizing FLUX.1 {name} safetensors: {path}")
+        print(f"Loading and normalizing FLUX.1 {name} safetensors: {path}")
+        new_sd = dict()
+        state_dict = load_file(path, device="cpu")
+        try:
+            for k in list(state_dict.keys()):
+                if k not in keys: state_dict.pop(k)
+            gc.collect()
+            for k in list(state_dict.keys()):
+                v = state_dict.pop(k)
+                if k in keys:
+                    nk = normalize_key(k)
+                    progress(0.5, desc=f"{k} => {nk}") #
+                    print(f"{k} => {nk}") #
+                    new_sd[nk] = dequant_tensor(v, dtype, dequant)
+                    #print_resource_usage() #
+        except Exception as e:
+            print(e)
+            return None
+        finally:
+            progress(1, desc=f"Normalized FLUX.1 {name} safetensors: {path}")
+            print(f"Normalized FLUX.1 {name} safetensors: {path}")
+            del state_dict
+            torch.cuda.empty_cache()
+            gc.collect()
+        return new_sd
+
+with torch.no_grad():
+    def convert_flux_transformer_sd_to_diffusers(sd: dict, progress=gr.Progress(track_tqdm=True)):
+        progress(0, desc="Converting FLUX.1 state dict to Diffusers format.")
+        print("Converting FLUX.1 state dict to Diffusers format.")
+        num_layers = 19
+        num_single_layers = 38
+        inner_dim = 3072
+        mlp_ratio = 4.0
+        try:
+            sd = convert_flux_transformer_checkpoint_to_diffusers(
+                sd, num_layers, num_single_layers, inner_dim, mlp_ratio=mlp_ratio
+            )
+        except Exception as e:
+            print(e)
+        finally:
+            progress(1, desc="Converted FLUX.1 state dict to Diffusers format.")
+            print("Converted FLUX.1 state dict to Diffusers format.")
+            gc.collect()
+        return sd
+
+with torch.no_grad():
+    def load_sharded_safetensors(path: str):
+        import glob
+        sd = {}
+        try:
+            for filepath in glob.glob(f"{path}/*.safetensors"):
+                sharded_sd = load_file(str(filepath), device="cpu")
+                for k, v in sharded_sd.items():
+                    sharded_sd[k] = v.to(device="cpu")
+                sd = sd | sharded_sd.copy()
+                del sharded_sd
+                torch.cuda.empty_cache()
+                gc.collect()
+        except Exception as e:
+                print(e)
+        return sd
+    
+# https://huggingface.co/docs/safetensors/api/torch
+with torch.no_grad():
+    def convert_flux_transformer_sd_to_diffusers_sharded(sd: dict, path: str, pattern: str,
+                                                size: str, progress=gr.Progress(track_tqdm=True)):
+        from huggingface_hub import save_torch_state_dict#, load_torch_model
+        import glob
+        try:
+            progress(0, desc=f"Saving temporary files to disk: {path}")
+            print(f"Saving temporary files to disk: {path}")
+            os.makedirs(path, exist_ok=True)
+            for k, v in sd.items():
+                if k in set(keys_flux_transformer): sd[k] = v.to(device="cpu")
+            save_torch_state_dict(sd, path, filename_pattern=pattern, max_shard_size=size)
+            del sd
+            torch.cuda.empty_cache()
+            gc.collect()
+            progress(0.25, desc=f"Saved temporary files to disk: {path}")
+            print(f"Saved temporary files to disk: {path}")
+            for filepath in glob.glob(f"{path}/*.safetensors"):
+                progress(0.25, desc=f"Processing temporary files: {str(filepath)}")
+                print(f"Processing temporary files: {str(filepath)}")
+                sharded_sd = load_file(str(filepath), device="cpu")
+                sharded_sd = convert_flux_transformer_sd_to_diffusers(sharded_sd)
+                for k, v in sharded_sd.items():
+                    sharded_sd[k] = v.to(device="cpu")
+                save_file(sharded_sd, str(filepath))
+                del sharded_sd
+                torch.cuda.empty_cache()
+                gc.collect()
+            print(f"Loading temporary files from disk: {path}")
+            sd = load_sharded_safetensors(path)
+            print(f"Loaded temporary files from disk: {path}")
+        except Exception as e:
+            print(e)
+        return sd
+
+with torch.no_grad():
+    def extract_normalized_flux_state_dict_sharded(loadpath: str, dtype: torch.dtype,
+         dequant: bool, path: str, pattern: str, size: str, progress=gr.Progress(track_tqdm=True)):
+        from huggingface_hub import save_torch_state_dict#, load_torch_model
+        import glob
+        try:
+            progress(0, desc=f"Loading model file: {loadpath}")
+            print(f"Loading model file: {loadpath}")
+            sd = load_file(loadpath, device="cpu")
+            progress(0, desc=f"Saving temporary files to disk: {path}")
+            print(f"Saving temporary files to disk: {path}")
+            os.makedirs(path, exist_ok=True)
+            for k, v in sd.items():
+                sd[k] = v.to(device="cpu")
+            save_torch_state_dict(sd, path, filename_pattern=pattern, max_shard_size=size)
+            del sd
+            torch.cuda.empty_cache()
+            gc.collect()
+            progress(0.25, desc=f"Saved temporary files to disk: {path}")
+            print(f"Saved temporary files to disk: {path}")
+            for filepath in glob.glob(f"{path}/*.safetensors"):
+                progress(0.25, desc=f"Processing temporary files: {str(filepath)}")
+                print(f"Processing temporary files: {str(filepath)}")
+                sharded_sd = extract_normalized_flux_state_dict_unet(str(filepath), dtype, dequant)
+                for k, v in sharded_sd.items():
+                    sharded_sd[k] = v.to(device="cpu")
+                save_file(sharded_sd, str(filepath))
+                del sharded_sd
+                torch.cuda.empty_cache()
+                gc.collect()
+                print(f"Processed temporary files: {str(filepath)}")
+            print(f"Loading temporary files from disk: {path}")
+            sd = load_sharded_safetensors(path)
+            print(f"Loaded temporary files from disk: {path}")
+        except Exception as e:
+            print(e)
+        return sd
+
+def download_repo(repo_name, path, download_sf=False, progress=gr.Progress(track_tqdm=True)):
+    from huggingface_hub import snapshot_download
+    print(f"Downloading {repo_name}.")
+    try:
+        if download_sf:
+            snapshot_download(repo_id=repo_name, local_dir=path, ignore_patterns=["transformer/", "*.sft", ".*", "README*", "*.md", "*.index", "*.jpg", "*.png", "*.webp"])
+        else:
+            snapshot_download(repo_id=repo_name, local_dir=path, ignore_patterns=["transformer/", "text_encoder_2/", "*.sft", ".*", "README*", "*.md", "*.index", "*.jpg", "*.png", "*.webp"])
+    except Exception as e:
+        print(e)
+
+def copy_nontensor_files(from_path, to_path, copy_sf=False):
+    import shutil
+    if copy_sf:
+        print(f"Copying non-tensor files {from_path} to {to_path}")
+        shutil.copytree(from_path, to_path, ignore=shutil.ignore_patterns("*.safetensors", "*.bin", "*.sft", ".*", "README*", "*.md", "*.index", "*.jpg", "*.png", "*.webp"), dirs_exist_ok=True)
+        te_from = str(Path(from_path, "text_encoder_2"))
+        te_to = str(Path(to_path, "text_encoder_2"))
+        print(f"Copying Text Encoder 2 files {te_from} to {te_to}")
+        shutil.copytree(te_from, te_to, ignore=shutil.ignore_patterns(".*", "README*", "*.md", "*.jpg", "*.png", "*.webp"), dirs_exist_ok=True)
+        te1_from = str(Path(from_path, "text_encoder"))
+        te1_to = str(Path(to_path, "text_encoder"))
+        print(f"Copying Text Encoder 1 files {te1_from} to {te1_to}")
+        shutil.copytree(te1_from, te1_to, ignore=shutil.ignore_patterns(".*", "README*", "*.md", "*.jpg", "*.png", "*.webp"), dirs_exist_ok=True)
+        tn2_from = str(Path(from_path, "tokenizer_2"))
+        tn2_to = str(Path(to_path, "tokenizer_2"))
+        print(f"Copying Tokenizer 2 files {tn2_from} to {tn2_to}")
+        shutil.copytree(tn2_from, tn2_to, ignore=shutil.ignore_patterns(".*", "README*", "*.md", "*.jpg", "*.png", "*.webp"), dirs_exist_ok=True)
+        vae_from = str(Path(from_path, "vae"))
+        vae_to = str(Path(to_path, "vae"))
+        print(f"Copying VAE files {vae_from} to {vae_to}")
+        shutil.copytree(vae_from, vae_to, ignore=shutil.ignore_patterns(".*", "README*", "*.md", "*.jpg", "*.png", "*.webp"), dirs_exist_ok=True)
+    else:
+        print(f"Copying non-tensor files {from_path} to {to_path}")
+        shutil.copytree(from_path, to_path, ignore=shutil.ignore_patterns("*.safetensors", "*.bin", "*.sft", ".*", "README*", "*.md", "*.index", "*.jpg", "*.png", "*.webp"), dirs_exist_ok=True)
+        te1_from = str(Path(from_path, "text_encoder"))
+        te1_to = str(Path(to_path, "text_encoder"))
+        print(f"Copying Text Encoder 1 files {te1_from} to {te1_to}")
+        shutil.copytree(te1_from, te1_to, ignore=shutil.ignore_patterns(".*", "README*", "*.md", "*.jpg", "*.png", "*.webp"), dirs_exist_ok=True)
+        tn2_from = str(Path(from_path, "tokenizer_2"))
+        tn2_to = str(Path(to_path, "tokenizer_2"))
+        print(f"Copying Tokenizer 2 files {tn2_from} to {tn2_to}")
+        shutil.copytree(tn2_from, tn2_to, ignore=shutil.ignore_patterns(".*", "README*", "*.md", "*.jpg", "*.png", "*.webp"), dirs_exist_ok=True)
+        vae_from = str(Path(from_path, "vae"))
+        vae_to = str(Path(to_path, "vae"))
+        print(f"Copying VAE files {vae_from} to {vae_to}")
+        shutil.copytree(vae_from, vae_to, ignore=shutil.ignore_patterns(".*", "README*", "*.md", "*.jpg", "*.png", "*.webp"), dirs_exist_ok=True)
+  
+def save_flux_other_diffusers(path: str, model_type: str = "dev", copy_te: bool = False, progress=gr.Progress(track_tqdm=True)):
+    import shutil
+    progress(0, desc="Loading FLUX.1 Components.")
+    print("Loading FLUX.1 Components.")
+    temppath = system_temp_dir
+    if model_type == "schnell": repo = flux_schnell_repo
+    else: repo = flux_dev_repo
+    os.makedirs(temppath, exist_ok=True)
+    os.makedirs(path, exist_ok=True)
+    download_repo(repo, temppath, copy_te)
+    progress(0.5, desc="Saving FLUX.1 Components.")
+    print("Saving FLUX.1 Components.")
+    copy_nontensor_files(temppath, path, copy_te)
+    shutil.rmtree(temppath)
+
+with torch.no_grad():
+    def fix_flux_safetensors(loadpath: str, savepath: str, dtype: torch.dtype = torch.bfloat16,
+                          quantization: bool = False, model_type: str = "dev", dequant: bool = False):
+        save_flux_other_diffusers(savepath, model_type)
+        normalize_flux_state_dict(loadpath, savepath, dtype, dequant)
+        torch.cuda.empty_cache()
+        gc.collect()
+
+with torch.no_grad(): # Much lower memory consumption, but higher disk load
+    def flux_to_diffusers_lowmem(loadpath: str, savepath: str, dtype: torch.dtype = torch.bfloat16,
+                          quantization: bool = False, model_type: str = "dev",
+                          dequant: bool = False, use_original: list = ["vae", "text_encoder"],
+                          new_repo_id: str = "", local: bool = False, progress=gr.Progress(track_tqdm=True)):
+        unet_sd_path = savepath.removesuffix("/") + "/transformer"
+        unet_sd_pattern = "diffusion_pytorch_model{suffix}.safetensors"
+        unet_sd_size = "10GB"
+        te_sd_path = savepath.removesuffix("/") + "/text_encoder_2"
+        te_sd_pattern = "model{suffix}.safetensors"
+        te_sd_size = "5GB"
+        clip_sd_path = savepath.removesuffix("/") + "/text_encoder"
+        clip_sd_pattern = "model{suffix}.safetensors"
+        clip_sd_size = "10GB"
+        vae_sd_path = savepath.removesuffix("/") + "/vae"
+        vae_sd_pattern = "diffusion_pytorch_model{suffix}.safetensors"
+        vae_sd_size = "10GB"
+        metadata = {"format": "pt", **read_safetensors_metadata(loadpath)}
+        save_flux_other_diffusers(savepath, model_type, "text_encoder_2" in use_original)
+        if "vae" not in use_original:
+            vae_sd = extract_norm_flux_module_sd(loadpath, torch.bfloat16, dequant, "VAE",
+                                                keys_flux_vae)
+            to_safetensors_flux_module(vae_sd, vae_sd_path, vae_sd_pattern, vae_sd_size,
+                                       quantization, "VAE", None)
+            del vae_sd
+            torch.cuda.empty_cache()
+            gc.collect()
+        if "text_encoder" not in use_original:
+            clip_sd = extract_norm_flux_module_sd(loadpath, torch.bfloat16, dequant, "Text Encoder",
+                                                keys_flux_clip)
+            to_safetensors_flux_module(clip_sd, clip_sd_path, clip_sd_pattern, clip_sd_size,
+                                       quantization, "Text Encoder", None)
+            del clip_sd
+            torch.cuda.empty_cache()
+            gc.collect()
+        if "text_encoder_2" not in use_original:
+            te_sd = extract_norm_flux_module_sd(loadpath, dtype, dequant, "Text Encoder 2",
+                                                keys_flux_t5xxl)
+            to_safetensors_flux_module(te_sd, te_sd_path, te_sd_pattern, te_sd_size,
+                                       quantization, "Text Encoder 2", None)
+            del te_sd
+            torch.cuda.empty_cache()
+            gc.collect()
+        unet_sd = extract_norm_flux_module_sd(loadpath, dtype, dequant, "Transformer",
+                                              keys_flux_transformer)
+        if not local: os.remove(loadpath)
+        to_safetensors_flux_module(unet_sd, unet_sd_path, unet_sd_pattern, unet_sd_size,
+                                        quantization, "Transformer", metadata)
+        del unet_sd
+        torch.cuda.empty_cache()
+        gc.collect()
+
+with torch.no_grad(): # lowest memory consumption, but higheest disk load
+    def flux_to_diffusers_lowmem2(loadpath: str, savepath: str, dtype: torch.dtype = torch.bfloat16,
+                          quantization: bool = False, model_type: str = "dev",
+                          dequant: bool = False, use_original: list = ["vae", "text_encoder"],
+                          new_repo_id: str = "", progress=gr.Progress(track_tqdm=True)):
+        unet_sd_path = savepath.removesuffix("/") + "/transformer"
+        unet_temp_path = system_temp_dir.removesuffix("/") + "/sharded"
+        unet_sd_pattern = "diffusion_pytorch_model{suffix}.safetensors"
+        unet_sd_size = "10GB"
+        unet_temp_size = "5GB"
+        te_sd_path = savepath.removesuffix("/") + "/text_encoder_2"
+        te_sd_pattern = "model{suffix}.safetensors"
+        te_sd_size = "5GB"
+        clip_sd_path = savepath.removesuffix("/") + "/text_encoder"
+        clip_sd_pattern = "model{suffix}.safetensors"
+        clip_sd_size = "10GB"
+        vae_sd_path = savepath.removesuffix("/") + "/vae"
+        vae_sd_pattern = "diffusion_pytorch_model{suffix}.safetensors"
+        vae_sd_size = "10GB"
+        metadata = {"format": "pt", **read_safetensors_metadata(loadpath)}
+        save_flux_other_diffusers(savepath, model_type, "text_encoder_2" in use_original)
+        if "vae" not in use_original:
+            vae_sd = extract_norm_flux_module_sd(loadpath, torch.bfloat16, dequant, "VAE",
+                                                keys_flux_vae)
+            to_safetensors_flux_module(vae_sd, vae_sd_path, vae_sd_pattern, vae_sd_size,
+                                       quantization, "VAE", None)
+            del vae_sd
+            torch.cuda.empty_cache()
+            gc.collect()
+        if "text_encoder" not in use_original:
+            clip_sd = extract_norm_flux_module_sd(loadpath, torch.bfloat16, dequant, "Text Encoder",
+                                                keys_flux_clip)
+            to_safetensors_flux_module(clip_sd, clip_sd_path, clip_sd_pattern, clip_sd_size,
+                                       quantization, "Text Encoder", None)
+            del clip_sd
+            torch.cuda.empty_cache()
+            gc.collect()
+        if "text_encoder_2" not in use_original:
+            te_sd = extract_norm_flux_module_sd(loadpath, dtype, dequant, "Text Encoder 2",
+                                                keys_flux_t5xxl)
+            to_safetensors_flux_module(te_sd, te_sd_path, te_sd_pattern, te_sd_size,
+                                       quantization, "Text Encoder 2", None)
+            del te_sd
+            torch.cuda.empty_cache()
+            gc.collect()
+        unet_sd = extract_normalized_flux_state_dict_sharded(loadpath, dtype, dequant,
+                                        unet_temp_path, unet_sd_pattern, unet_temp_size)
+        unet_sd = convert_flux_transformer_sd_to_diffusers_sharded(unet_sd, unet_temp_path,
+                                                                   unet_sd_pattern, unet_temp_size)
+        to_safetensors_flux_module(unet_sd, unet_sd_path, unet_sd_pattern, unet_sd_size,
+                                        quantization, "Transformer", metadata)
+        del unet_sd
+        torch.cuda.empty_cache()
+        gc.collect()
+
+def convert_url_to_diffusers_flux(url, civitai_key="", is_upload_sf=False, data_type="bf16",
+                                  model_type="dev", dequant=False, use_original=["vae", "text_encoder"],
+                                  hf_user="", hf_repo="", q=None, progress=gr.Progress(track_tqdm=True)):
+    progress(0, desc="Start converting...")
+    temp_dir = "."
+    new_file = get_download_file(temp_dir, url, civitai_key)
+    if not new_file:
+        print(f"Not found: {url}")
+        return ""
+    new_repo_name = Path(new_file).stem.replace(" ", "_").replace(",", "_").replace(".", "_") #
+
+    dtype = torch.bfloat16
+    quantization = False
+    if data_type == "fp8": dtype = torch.float8_e4m3fn
+    elif data_type == "fp16": dtype = torch.float16
+    elif data_type == "qfloat8":
+        dtype = torch.bfloat16
+        quantization = True
+    else: dtype = torch.bfloat16
+
+    new_repo_id = f"{hf_user}/{Path(new_repo_name).stem}"
+    if hf_repo != "": new_repo_id = f"{hf_user}/{hf_repo}"
+    flux_to_diffusers_lowmem(new_file, new_repo_name, dtype, quantization, model_type, dequant, use_original, new_repo_id)
+
+    """if is_upload_sf:
+        import shutil
+        shutil.move(str(Path(new_file).resolve()), str(Path(new_repo_name, Path(new_file).name).resolve()))
+    else: os.remove(new_file)"""
+
+    progress(1, desc="Converted.")
+    q.put(new_repo_name)
+    return new_repo_name
+
+def convert_url_to_fixed_flux_safetensors(url, civitai_key="", is_upload_sf=False, data_type="bf16",
+                                  model_type="dev", dequant=False, q=None, progress=gr.Progress(track_tqdm=True)):
+    progress(0, desc="Start converting...")
+    temp_dir = "."
+    new_file = get_download_file(temp_dir, url, civitai_key)
+    if not new_file:
+        print(f"Not found: {url}")
+        return ""
+    new_repo_name = Path(new_file).stem.replace(" ", "_").replace(",", "_").replace(".", "_") #
+
+    dtype = torch.bfloat16
+    quantization = False
+    if data_type == "fp8": dtype = torch.float8_e4m3fn
+    elif data_type == "fp16": dtype = torch.float16
+    elif data_type == "qfloat8":
+        dtype = torch.bfloat16
+        quantization = True
+    else: dtype = torch.bfloat16
+
+    fix_flux_safetensors(new_file, new_repo_name, dtype, model_type, dequant)
+
+    os.remove(new_file)
+
+    progress(1, desc="Converted.")
+    q.put(new_repo_name)
+    return new_repo_name
+
+def convert_url_to_diffusers_repo_flux(dl_url, hf_user, hf_repo, hf_token, civitai_key="",
+                                       is_upload_sf=False, data_type="bf16", model_type="dev", dequant=False,
+                                       repo_urls=[], fix_only=False, use_original=["vae", "text_encoder"],
+                                       progress=gr.Progress(track_tqdm=True)):
+    import multiprocessing as mp
+    import shutil
+    if not hf_user:
+        print(f"Invalid user name: {hf_user}")
+        progress(1, desc=f"Invalid user name: {hf_user}")
+        return gr.update(value=repo_urls, choices=repo_urls), gr.update(value="")
+    if hf_token and not os.environ.get("HF_TOKEN"): os.environ['HF_TOKEN'] = hf_token
+    if not civitai_key and os.environ.get("CIVITAI_API_KEY"): civitai_key = os.environ.get("CIVITAI_API_KEY")
+    q = mp.Queue()
+    if fix_only:
+        p = mp.Process(target=convert_url_to_fixed_flux_safetensors, args=(dl_url, civitai_key,
+                    is_upload_sf, data_type, model_type, dequant, q))
+        #new_path = convert_url_to_fixed_flux_safetensors(dl_url, civitai_key, is_upload_sf, data_type, model_type, dequant)
+    else:
+        p = mp.Process(target=convert_url_to_diffusers_flux, args=(dl_url, civitai_key,
+                    is_upload_sf, data_type, model_type, dequant, use_original, hf_user, hf_repo, q))
+        #new_path = convert_url_to_diffusers_flux(dl_url, civitai_key, is_upload_sf, data_type, model_type, dequant)
+    p.start()
+    new_path = q.get()
+    p.join()
+    if not new_path: return ""
+    new_repo_id = f"{hf_user}/{Path(new_path).stem}"
+    if hf_repo != "": new_repo_id = f"{hf_user}/{hf_repo}"
+    if not is_repo_name(new_repo_id):
+        print(f"Invalid repo name: {new_repo_id}")
+        progress(1, desc=f"Invalid repo name: {new_repo_id}")
+        return gr.update(value=repo_urls, choices=repo_urls), gr.update(value="")
+    if is_repo_exists(new_repo_id):
+        print(f"Repo already exists: {new_repo_id}")
+        progress(1, desc=f"Repo already exists: {new_repo_id}")
+        return gr.update(value=repo_urls, choices=repo_urls), gr.update(value="")
+    save_readme_md(new_path, dl_url)
+    repo_url = create_diffusers_repo(new_repo_id, new_path)
+    shutil.rmtree(new_path)
+    if not repo_urls: repo_urls = []
+    repo_urls.append(repo_url)
+    md = "Your new repo:<br>"
+    for u in repo_urls:
+        md += f"[{str(u).split('/')[-2]}/{str(u).split('/')[-1]}]({str(u)})<br>"
+    return gr.update(value=repo_urls, choices=repo_urls), gr.update(value=md)
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--url", default=None, type=str, required=False, help="URL of the model to convert.")
+    parser.add_argument("--file", default=None, type=str, required=False, help="Filename of the model to convert.")
+    parser.add_argument("--fix", action="store_true", help="Only fix the keys of the local model.")
+    parser.add_argument("--civitai_key", default=None, type=str, required=False, help="Civitai API Key (If you want to download file from Civitai).")
+    parser.add_argument("--dtype", type=str, default="fp8")
+    parser.add_argument("--model", type=str, default="dev")
+    parser.add_argument("--dequant", action="store_true", help="Dequantize model.")
+    args = parser.parse_args()
+    assert (args.url, args.file) != (None, None), "Must provide --url or --file!"
+
+    dtype = torch.bfloat16
+    quantization = False
+    if args.dtype == "fp8": dtype = torch.float8_e4m3fn
+    elif args.dtype == "fp16": dtype = torch.float16
+    elif args.dtype == "qfloat8":
+        dtype = torch.bfloat16
+        quantization = True
+    else: dtype = torch.bfloat16
+
+    use_original = ["vae", "text_encoder"]
+    new_repo_id = ""
+    use_local = True
+
+    if args.file is not None and Path(args.file).exists():
+        if args.fix: normalize_flux_state_dict(args.file, ".", dtype, args.dequant)
+        else: flux_to_diffusers_lowmem(args.file, Path(args.file).stem, dtype, quantization,
+                                       args.model, args.dequant, use_original, new_repo_id, use_local)
+    elif args.url is not None:
+        convert_url_to_diffusers_flux(args.url, args.civitai_key, False, args.dtype, args.model,
+                                      args.dequant)

dequant.py

@@ -0,0 +1,114 @@
+# (c) City96 || Apache-2.0 (apache.org/licenses/LICENSE-2.0)
+import gguf
+import torch
+import numpy as np
+
+def dequantize_tensor(tensor, dtype=torch.float16):
+    data = torch.tensor(tensor.data)
+    qtype = tensor.tensor_type
+    oshape = tensor.tensor_shape
+
+    if qtype == gguf.GGMLQuantizationType.F32:
+        return data.to(dtype)
+    elif qtype == gguf.GGMLQuantizationType.F16:
+        return data.to(dtype)
+    elif qtype in dequantize_functions:
+        # dequantize in fp16 then convert instead of keeping FP32
+        out = dequantize(data, qtype, oshape, dtype=None)
+        return out.to(dtype) if out.dtype != dtype else out # why is .to() not a no-op?
+    else:
+        # this is incredibly slow
+        new = gguf.quants.dequantize(data.cpu().numpy(), qtype)
+        return torch.from_numpy(new).to(data.device, dtype=dtype)
+
+def dequantize(data, qtype, oshape, dtype=None):
+    """
+    Dequantize tensor back to usable shape/dtype
+    """
+    block_size, type_size = gguf.GGML_QUANT_SIZES[qtype]
+    dequantize_blocks = dequantize_functions[qtype]
+
+    rows = data.reshape(
+        (-1, data.shape[-1])
+    ).view(torch.uint8)
+
+    n_blocks = rows.numel() // type_size
+    blocks = rows.reshape((n_blocks, type_size))
+    blocks = dequantize_blocks(blocks, block_size, type_size, dtype)
+    return blocks.reshape(oshape)
+
+def to_uint32(x):
+    # no uint32 :(
+    x = x.view(torch.uint8).to(torch.int32) 
+    return (x[:, 0] | x[:, 1] << 8 | x[:, 2] << 16 | x[:, 3] << 24).unsqueeze(1)
+
+def dequantize_blocks_Q8_0(blocks, block_size, type_size, dtype=None):
+    d = blocks[:, :2].view(torch.float16).to(dtype)
+    x = blocks[:, 2:].view(torch.int8)
+    return (d * x)
+
+def dequantize_blocks_Q5_1(blocks, block_size, type_size, dtype=None):
+    n_blocks = blocks.shape[0]
+
+    d  = blocks[:,  :2].view(torch.float16).to(dtype)
+    m  = blocks[:, 2:4].view(torch.float16).to(dtype)
+    qh = blocks[:, 4:8]
+    qs = blocks[:, 8: ]
+
+    qh = to_uint32(qh)
+
+    qh = qh.reshape((n_blocks, 1)) >> torch.arange(32, device=d.device, dtype=torch.int32).reshape(1, 32)
+    ql = qs.reshape((n_blocks, -1, 1, block_size // 2)) >> torch.tensor([0, 4], device=d.device, dtype=torch.uint8).reshape(1, 1, 2, 1)
+    qh = (qh & 1).to(torch.uint8)
+    ql = (ql & 0x0F).reshape((n_blocks, -1))
+
+    qs = (ql | (qh << 4))
+    return (d * qs) + m
+
+def dequantize_blocks_Q5_0(blocks, block_size, type_size, dtype=None):
+    n_blocks = blocks.shape[0]
+
+    d  = blocks[:,  :2].view(torch.float16).to(dtype)
+    qh = blocks[:, 2:6]
+    qs = blocks[:, 6: ]
+
+    qh = to_uint32(qh)
+
+    qh = qh.reshape(n_blocks, 1) >> torch.arange(32, device=d.device, dtype=torch.int32).reshape(1, 32)
+    ql = qs.reshape(n_blocks, -1, 1, block_size // 2) >> torch.tensor([0, 4], device=d.device, dtype=torch.uint8).reshape(1, 1, 2, 1)
+
+    qh = (qh & 1).to(torch.uint8)
+    ql = (ql & 0x0F).reshape(n_blocks, -1)
+
+    qs = (ql | (qh << 4)).to(torch.int8) - 16
+    return (d * qs)
+
+def dequantize_blocks_Q4_1(blocks, block_size, type_size, dtype=None):
+    n_blocks = blocks.shape[0]
+
+    d  = blocks[:,  :2].view(torch.float16).to(dtype)
+    m  = blocks[:, 2:4].view(torch.float16).to(dtype)
+    qs = blocks[:, 4: ]
+
+    qs = qs.reshape((n_blocks, -1, 1, block_size // 2)) >> torch.tensor([0, 4], device=d.device, dtype=torch.uint8).reshape(1, 1, 2, 1)
+    qs = (qs & 0x0F).reshape(n_blocks, -1)
+
+    return (d * qs) + m
+
+def dequantize_blocks_Q4_0(blocks, block_size, type_size, dtype=None):
+    n_blocks = blocks.shape[0]
+
+    d  = blocks[:,  :2].view(torch.float16).to(dtype)
+    qs = blocks[:,  2:]
+
+    qs = qs.reshape((n_blocks, -1, 1, block_size // 2)) >> torch.tensor([0, 4], device=d.device, dtype=torch.uint8).reshape((1, 1, 2, 1))
+    qs = (qs & 0x0F).reshape((n_blocks, -1)).to(torch.int8) - 8
+    return (d * qs)
+
+dequantize_functions = {
+    gguf.GGMLQuantizationType.Q8_0: dequantize_blocks_Q8_0,
+    gguf.GGMLQuantizationType.Q5_1: dequantize_blocks_Q5_1,
+    gguf.GGMLQuantizationType.Q5_0: dequantize_blocks_Q5_0,
+    gguf.GGMLQuantizationType.Q4_1: dequantize_blocks_Q4_1,
+    gguf.GGMLQuantizationType.Q4_0: dequantize_blocks_Q4_0,
+}

flux_clip_keys.json

@@ -0,0 +1,396 @@
+[
+  "embeddings.position_embedding.weight",
+  "embeddings.token_embedding.weight",
+  "encoder.layers.0.layer_norm1.bias",
+  "encoder.layers.0.layer_norm1.weight",
+  "encoder.layers.0.layer_norm2.bias",
+  "encoder.layers.0.layer_norm2.weight",
+  "encoder.layers.0.mlp.fc1.bias",
+  "encoder.layers.0.mlp.fc1.weight",
+  "encoder.layers.0.mlp.fc2.bias",
+  "encoder.layers.0.mlp.fc2.weight",
+  "encoder.layers.0.self_attn.k_proj.bias",
+  "encoder.layers.0.self_attn.k_proj.weight",
+  "encoder.layers.0.self_attn.out_proj.bias",
+  "encoder.layers.0.self_attn.out_proj.weight",
+  "encoder.layers.0.self_attn.q_proj.bias",
+  "encoder.layers.0.self_attn.q_proj.weight",
+  "encoder.layers.0.self_attn.v_proj.bias",
+  "encoder.layers.0.self_attn.v_proj.weight",
+  "encoder.layers.1.layer_norm1.bias",
+  "encoder.layers.1.layer_norm1.weight",
+  "encoder.layers.1.layer_norm2.bias",
+  "encoder.layers.1.layer_norm2.weight",
+  "encoder.layers.1.mlp.fc1.bias",
+  "encoder.layers.1.mlp.fc1.weight",
+  "encoder.layers.1.mlp.fc2.bias",
+  "encoder.layers.1.mlp.fc2.weight",
+  "encoder.layers.1.self_attn.k_proj.bias",
+  "encoder.layers.1.self_attn.k_proj.weight",
+  "encoder.layers.1.self_attn.out_proj.bias",
+  "encoder.layers.1.self_attn.out_proj.weight",
+  "encoder.layers.1.self_attn.q_proj.bias",
+  "encoder.layers.1.self_attn.q_proj.weight",
+  "encoder.layers.1.self_attn.v_proj.bias",
+  "encoder.layers.1.self_attn.v_proj.weight",
+  "encoder.layers.10.layer_norm1.bias",
+  "encoder.layers.10.layer_norm1.weight",
+  "encoder.layers.10.layer_norm2.bias",
+  "encoder.layers.10.layer_norm2.weight",
+  "encoder.layers.10.mlp.fc1.bias",
+  "encoder.layers.10.mlp.fc1.weight",
+  "encoder.layers.10.mlp.fc2.bias",
+  "encoder.layers.10.mlp.fc2.weight",
+  "encoder.layers.10.self_attn.k_proj.bias",
+  "encoder.layers.10.self_attn.k_proj.weight",
+  "encoder.layers.10.self_attn.out_proj.bias",
+  "encoder.layers.10.self_attn.out_proj.weight",
+  "encoder.layers.10.self_attn.q_proj.bias",
+  "encoder.layers.10.self_attn.q_proj.weight",
+  "encoder.layers.10.self_attn.v_proj.bias",
+  "encoder.layers.10.self_attn.v_proj.weight",
+  "encoder.layers.11.layer_norm1.bias",
+  "encoder.layers.11.layer_norm1.weight",
+  "encoder.layers.11.layer_norm2.bias",
+  "encoder.layers.11.layer_norm2.weight",
+  "encoder.layers.11.mlp.fc1.bias",
+  "encoder.layers.11.mlp.fc1.weight",
+  "encoder.layers.11.mlp.fc2.bias",
+  "encoder.layers.11.mlp.fc2.weight",
+  "encoder.layers.11.self_attn.k_proj.bias",
+  "encoder.layers.11.self_attn.k_proj.weight",
+  "encoder.layers.11.self_attn.out_proj.bias",
+  "encoder.layers.11.self_attn.out_proj.weight",
+  "encoder.layers.11.self_attn.q_proj.bias",
+  "encoder.layers.11.self_attn.q_proj.weight",
+  "encoder.layers.11.self_attn.v_proj.bias",
+  "encoder.layers.11.self_attn.v_proj.weight",
+  "encoder.layers.2.layer_norm1.bias",
+  "encoder.layers.2.layer_norm1.weight",
+  "encoder.layers.2.layer_norm2.bias",
+  "encoder.layers.2.layer_norm2.weight",
+  "encoder.layers.2.mlp.fc1.bias",
+  "encoder.layers.2.mlp.fc1.weight",
+  "encoder.layers.2.mlp.fc2.bias",
+  "encoder.layers.2.mlp.fc2.weight",
+  "encoder.layers.2.self_attn.k_proj.bias",
+  "encoder.layers.2.self_attn.k_proj.weight",
+  "encoder.layers.2.self_attn.out_proj.bias",
+  "encoder.layers.2.self_attn.out_proj.weight",
+  "encoder.layers.2.self_attn.q_proj.bias",
+  "encoder.layers.2.self_attn.q_proj.weight",
+  "encoder.layers.2.self_attn.v_proj.bias",
+  "encoder.layers.2.self_attn.v_proj.weight",
+  "encoder.layers.3.layer_norm1.bias",
+  "encoder.layers.3.layer_norm1.weight",
+  "encoder.layers.3.layer_norm2.bias",
+  "encoder.layers.3.layer_norm2.weight",
+  "encoder.layers.3.mlp.fc1.bias",
+  "encoder.layers.3.mlp.fc1.weight",
+  "encoder.layers.3.mlp.fc2.bias",
+  "encoder.layers.3.mlp.fc2.weight",
+  "encoder.layers.3.self_attn.k_proj.bias",
+  "encoder.layers.3.self_attn.k_proj.weight",
+  "encoder.layers.3.self_attn.out_proj.bias",
+  "encoder.layers.3.self_attn.out_proj.weight",
+  "encoder.layers.3.self_attn.q_proj.bias",
+  "encoder.layers.3.self_attn.q_proj.weight",
+  "encoder.layers.3.self_attn.v_proj.bias",
+  "encoder.layers.3.self_attn.v_proj.weight",
+  "encoder.layers.4.layer_norm1.bias",
+  "encoder.layers.4.layer_norm1.weight",
+  "encoder.layers.4.layer_norm2.bias",
+  "encoder.layers.4.layer_norm2.weight",
+  "encoder.layers.4.mlp.fc1.bias",
+  "encoder.layers.4.mlp.fc1.weight",
+  "encoder.layers.4.mlp.fc2.bias",
+  "encoder.layers.4.mlp.fc2.weight",
+  "encoder.layers.4.self_attn.k_proj.bias",
+  "encoder.layers.4.self_attn.k_proj.weight",
+  "encoder.layers.4.self_attn.out_proj.bias",
+  "encoder.layers.4.self_attn.out_proj.weight",
+  "encoder.layers.4.self_attn.q_proj.bias",
+  "encoder.layers.4.self_attn.q_proj.weight",
+  "encoder.layers.4.self_attn.v_proj.bias",
+  "encoder.layers.4.self_attn.v_proj.weight",
+  "encoder.layers.5.layer_norm1.bias",
+  "encoder.layers.5.layer_norm1.weight",
+  "encoder.layers.5.layer_norm2.bias",
+  "encoder.layers.5.layer_norm2.weight",
+  "encoder.layers.5.mlp.fc1.bias",
+  "encoder.layers.5.mlp.fc1.weight",
+  "encoder.layers.5.mlp.fc2.bias",
+  "encoder.layers.5.mlp.fc2.weight",
+  "encoder.layers.5.self_attn.k_proj.bias",
+  "encoder.layers.5.self_attn.k_proj.weight",
+  "encoder.layers.5.self_attn.out_proj.bias",
+  "encoder.layers.5.self_attn.out_proj.weight",
+  "encoder.layers.5.self_attn.q_proj.bias",
+  "encoder.layers.5.self_attn.q_proj.weight",
+  "encoder.layers.5.self_attn.v_proj.bias",
+  "encoder.layers.5.self_attn.v_proj.weight",
+  "encoder.layers.6.layer_norm1.bias",
+  "encoder.layers.6.layer_norm1.weight",
+  "encoder.layers.6.layer_norm2.bias",
+  "encoder.layers.6.layer_norm2.weight",
+  "encoder.layers.6.mlp.fc1.bias",
+  "encoder.layers.6.mlp.fc1.weight",
+  "encoder.layers.6.mlp.fc2.bias",
+  "encoder.layers.6.mlp.fc2.weight",
+  "encoder.layers.6.self_attn.k_proj.bias",
+  "encoder.layers.6.self_attn.k_proj.weight",
+  "encoder.layers.6.self_attn.out_proj.bias",
+  "encoder.layers.6.self_attn.out_proj.weight",
+  "encoder.layers.6.self_attn.q_proj.bias",
+  "encoder.layers.6.self_attn.q_proj.weight",
+  "encoder.layers.6.self_attn.v_proj.bias",
+  "encoder.layers.6.self_attn.v_proj.weight",
+  "encoder.layers.7.layer_norm1.bias",
+  "encoder.layers.7.layer_norm1.weight",
+  "encoder.layers.7.layer_norm2.bias",
+  "encoder.layers.7.layer_norm2.weight",
+  "encoder.layers.7.mlp.fc1.bias",
+  "encoder.layers.7.mlp.fc1.weight",
+  "encoder.layers.7.mlp.fc2.bias",
+  "encoder.layers.7.mlp.fc2.weight",
+  "encoder.layers.7.self_attn.k_proj.bias",
+  "encoder.layers.7.self_attn.k_proj.weight",
+  "encoder.layers.7.self_attn.out_proj.bias",
+  "encoder.layers.7.self_attn.out_proj.weight",
+  "encoder.layers.7.self_attn.q_proj.bias",
+  "encoder.layers.7.self_attn.q_proj.weight",
+  "encoder.layers.7.self_attn.v_proj.bias",
+  "encoder.layers.7.self_attn.v_proj.weight",
+  "encoder.layers.8.layer_norm1.bias",
+  "encoder.layers.8.layer_norm1.weight",
+  "encoder.layers.8.layer_norm2.bias",
+  "encoder.layers.8.layer_norm2.weight",
+  "encoder.layers.8.mlp.fc1.bias",
+  "encoder.layers.8.mlp.fc1.weight",
+  "encoder.layers.8.mlp.fc2.bias",
+  "encoder.layers.8.mlp.fc2.weight",
+  "encoder.layers.8.self_attn.k_proj.bias",
+  "encoder.layers.8.self_attn.k_proj.weight",
+  "encoder.layers.8.self_attn.out_proj.bias",
+  "encoder.layers.8.self_attn.out_proj.weight",
+  "encoder.layers.8.self_attn.q_proj.bias",
+  "encoder.layers.8.self_attn.q_proj.weight",
+  "encoder.layers.8.self_attn.v_proj.bias",
+  "encoder.layers.8.self_attn.v_proj.weight",
+  "encoder.layers.9.layer_norm1.bias",
+  "encoder.layers.9.layer_norm1.weight",
+  "encoder.layers.9.layer_norm2.bias",
+  "encoder.layers.9.layer_norm2.weight",
+  "encoder.layers.9.mlp.fc1.bias",
+  "encoder.layers.9.mlp.fc1.weight",
+  "encoder.layers.9.mlp.fc2.bias",
+  "encoder.layers.9.mlp.fc2.weight",
+  "encoder.layers.9.self_attn.k_proj.bias",
+  "encoder.layers.9.self_attn.k_proj.weight",
+  "encoder.layers.9.self_attn.out_proj.bias",
+  "encoder.layers.9.self_attn.out_proj.weight",
+  "encoder.layers.9.self_attn.q_proj.bias",
+  "encoder.layers.9.self_attn.q_proj.weight",
+  "encoder.layers.9.self_attn.v_proj.bias",
+  "encoder.layers.9.self_attn.v_proj.weight",
+  "final_layer_norm.bias",
+  "final_layer_norm.weight",
+  "text_encoders.clip_l.transformer.text_projection.weight",
+  "text_encoders.clip_l.transformer.text_model.embeddings.position_embedding.weight",
+  "text_encoders.clip_l.transformer.text_model.embeddings.token_embedding.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.0.layer_norm1.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.0.layer_norm1.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.0.layer_norm2.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.0.layer_norm2.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.0.mlp.fc1.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.0.mlp.fc1.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.0.mlp.fc2.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.0.mlp.fc2.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.0.self_attn.k_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.0.self_attn.k_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.0.self_attn.out_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.0.self_attn.out_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.0.self_attn.q_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.0.self_attn.q_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.0.self_attn.v_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.0.self_attn.v_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.1.layer_norm1.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.1.layer_norm1.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.1.layer_norm2.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.1.layer_norm2.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.1.mlp.fc1.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.1.mlp.fc1.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.1.mlp.fc2.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.1.mlp.fc2.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.1.self_attn.k_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.1.self_attn.k_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.1.self_attn.out_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.1.self_attn.out_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.1.self_attn.q_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.1.self_attn.q_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.1.self_attn.v_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.1.self_attn.v_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.10.layer_norm1.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.10.layer_norm1.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.10.layer_norm2.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.10.layer_norm2.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.10.mlp.fc1.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.10.mlp.fc1.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.10.mlp.fc2.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.10.mlp.fc2.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.10.self_attn.k_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.10.self_attn.k_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.10.self_attn.out_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.10.self_attn.out_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.10.self_attn.q_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.10.self_attn.q_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.10.self_attn.v_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.10.self_attn.v_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.11.layer_norm1.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.11.layer_norm1.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.11.layer_norm2.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.11.layer_norm2.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.11.mlp.fc1.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.11.mlp.fc1.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.11.mlp.fc2.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.11.mlp.fc2.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.11.self_attn.k_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.11.self_attn.k_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.11.self_attn.out_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.11.self_attn.out_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.11.self_attn.q_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.11.self_attn.q_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.11.self_attn.v_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.11.self_attn.v_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.2.layer_norm1.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.2.layer_norm1.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.2.layer_norm2.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.2.layer_norm2.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.2.mlp.fc1.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.2.mlp.fc1.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.2.mlp.fc2.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.2.mlp.fc2.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.2.self_attn.k_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.2.self_attn.k_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.2.self_attn.out_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.2.self_attn.out_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.2.self_attn.q_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.2.self_attn.q_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.2.self_attn.v_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.2.self_attn.v_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.3.layer_norm1.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.3.layer_norm1.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.3.layer_norm2.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.3.layer_norm2.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.3.mlp.fc1.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.3.mlp.fc1.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.3.mlp.fc2.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.3.mlp.fc2.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.3.self_attn.k_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.3.self_attn.k_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.3.self_attn.out_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.3.self_attn.out_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.3.self_attn.q_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.3.self_attn.q_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.3.self_attn.v_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.3.self_attn.v_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.4.layer_norm1.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.4.layer_norm1.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.4.layer_norm2.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.4.layer_norm2.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.4.mlp.fc1.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.4.mlp.fc1.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.4.mlp.fc2.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.4.mlp.fc2.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.4.self_attn.k_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.4.self_attn.k_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.4.self_attn.out_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.4.self_attn.out_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.4.self_attn.q_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.4.self_attn.q_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.4.self_attn.v_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.4.self_attn.v_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.5.layer_norm1.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.5.layer_norm1.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.5.layer_norm2.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.5.layer_norm2.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.5.mlp.fc1.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.5.mlp.fc1.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.5.mlp.fc2.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.5.mlp.fc2.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.5.self_attn.k_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.5.self_attn.k_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.5.self_attn.out_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.5.self_attn.out_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.5.self_attn.q_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.5.self_attn.q_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.5.self_attn.v_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.5.self_attn.v_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.6.layer_norm1.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.6.layer_norm1.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.6.layer_norm2.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.6.layer_norm2.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.6.mlp.fc1.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.6.mlp.fc1.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.6.mlp.fc2.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.6.mlp.fc2.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.6.self_attn.k_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.6.self_attn.k_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.6.self_attn.out_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.6.self_attn.out_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.6.self_attn.q_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.6.self_attn.q_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.6.self_attn.v_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.6.self_attn.v_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.7.layer_norm1.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.7.layer_norm1.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.7.layer_norm2.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.7.layer_norm2.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.7.mlp.fc1.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.7.mlp.fc1.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.7.mlp.fc2.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.7.mlp.fc2.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.7.self_attn.k_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.7.self_attn.k_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.7.self_attn.out_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.7.self_attn.out_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.7.self_attn.q_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.7.self_attn.q_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.7.self_attn.v_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.7.self_attn.v_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.8.layer_norm1.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.8.layer_norm1.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.8.layer_norm2.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.8.layer_norm2.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.8.mlp.fc1.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.8.mlp.fc1.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.8.mlp.fc2.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.8.mlp.fc2.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.8.self_attn.k_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.8.self_attn.k_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.8.self_attn.out_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.8.self_attn.out_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.8.self_attn.q_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.8.self_attn.q_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.8.self_attn.v_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.8.self_attn.v_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.9.layer_norm1.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.9.layer_norm1.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.9.layer_norm2.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.9.layer_norm2.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.9.mlp.fc1.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.9.mlp.fc1.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.9.mlp.fc2.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.9.mlp.fc2.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.9.self_attn.k_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.9.self_attn.k_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.9.self_attn.out_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.9.self_attn.out_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.9.self_attn.q_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.9.self_attn.q_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.9.self_attn.v_proj.bias",
+  "text_encoders.clip_l.transformer.text_model.encoder.layers.9.self_attn.v_proj.weight",
+  "text_encoders.clip_l.transformer.text_model.final_layer_norm.bias",
+  "text_encoders.clip_l.transformer.text_model.final_layer_norm.weight",
+  "text_encoders.clip_l.transformer.text_projection.weight"
+]

flux_t5xxl_keys.json

@@ -0,0 +1,440 @@
+[
+  "encoder.block.0.layer.0.SelfAttention.k.weight",
+  "encoder.block.0.layer.0.SelfAttention.o.weight",
+  "encoder.block.0.layer.0.SelfAttention.q.weight",
+  "encoder.block.0.layer.0.SelfAttention.relative_attention_bias.weight",
+  "encoder.block.0.layer.0.SelfAttention.v.weight",
+  "encoder.block.0.layer.0.layer_norm.weight",
+  "encoder.block.0.layer.1.DenseReluDense.wi_0.weight",
+  "encoder.block.0.layer.1.DenseReluDense.wi_1.weight",
+  "encoder.block.0.layer.1.DenseReluDense.wo.weight",
+  "encoder.block.0.layer.1.layer_norm.weight",
+  "encoder.block.1.layer.0.SelfAttention.k.weight",
+  "encoder.block.1.layer.0.SelfAttention.o.weight",
+  "encoder.block.1.layer.0.SelfAttention.q.weight",
+  "encoder.block.1.layer.0.SelfAttention.v.weight",
+  "encoder.block.1.layer.0.layer_norm.weight",
+  "encoder.block.1.layer.1.DenseReluDense.wi_0.weight",
+  "encoder.block.1.layer.1.DenseReluDense.wi_1.weight",
+  "encoder.block.1.layer.1.DenseReluDense.wo.weight",
+  "encoder.block.1.layer.1.layer_norm.weight",
+  "encoder.block.10.layer.0.SelfAttention.k.weight",
+  "encoder.block.10.layer.0.SelfAttention.o.weight",
+  "encoder.block.10.layer.0.SelfAttention.q.weight",
+  "encoder.block.10.layer.0.SelfAttention.v.weight",
+  "encoder.block.10.layer.0.layer_norm.weight",
+  "encoder.block.10.layer.1.DenseReluDense.wi_0.weight",
+  "encoder.block.10.layer.1.DenseReluDense.wi_1.weight",
+  "encoder.block.10.layer.1.DenseReluDense.wo.weight",
+  "encoder.block.10.layer.1.layer_norm.weight",
+  "encoder.block.11.layer.0.SelfAttention.k.weight",
+  "encoder.block.11.layer.0.SelfAttention.o.weight",
+  "encoder.block.11.layer.0.SelfAttention.q.weight",
+  "encoder.block.11.layer.0.SelfAttention.v.weight",
+  "encoder.block.11.layer.0.layer_norm.weight",
+  "encoder.block.11.layer.1.DenseReluDense.wi_0.weight",
+  "encoder.block.11.layer.1.DenseReluDense.wi_1.weight",
+  "encoder.block.11.layer.1.DenseReluDense.wo.weight",
+  "encoder.block.11.layer.1.layer_norm.weight",
+  "encoder.block.12.layer.0.SelfAttention.k.weight",
+  "encoder.block.12.layer.0.SelfAttention.o.weight",
+  "encoder.block.12.layer.0.SelfAttention.q.weight",
+  "encoder.block.12.layer.0.SelfAttention.v.weight",
+  "encoder.block.12.layer.0.layer_norm.weight",
+  "encoder.block.12.layer.1.DenseReluDense.wi_0.weight",
+  "encoder.block.12.layer.1.DenseReluDense.wi_1.weight",
+  "encoder.block.12.layer.1.DenseReluDense.wo.weight",
+  "encoder.block.12.layer.1.layer_norm.weight",
+  "encoder.block.13.layer.0.SelfAttention.k.weight",
+  "encoder.block.13.layer.0.SelfAttention.o.weight",
+  "encoder.block.13.layer.0.SelfAttention.q.weight",
+  "encoder.block.13.layer.0.SelfAttention.v.weight",
+  "encoder.block.13.layer.0.layer_norm.weight",
+  "encoder.block.13.layer.1.DenseReluDense.wi_0.weight",
+  "encoder.block.13.layer.1.DenseReluDense.wi_1.weight",
+  "encoder.block.13.layer.1.DenseReluDense.wo.weight",
+  "encoder.block.13.layer.1.layer_norm.weight",
+  "encoder.block.14.layer.0.SelfAttention.k.weight",
+  "encoder.block.14.layer.0.SelfAttention.o.weight",
+  "encoder.block.14.layer.0.SelfAttention.q.weight",
+  "encoder.block.14.layer.0.SelfAttention.v.weight",
+  "encoder.block.14.layer.0.layer_norm.weight",
+  "encoder.block.14.layer.1.DenseReluDense.wi_0.weight",
+  "encoder.block.14.layer.1.DenseReluDense.wi_1.weight",
+  "encoder.block.14.layer.1.DenseReluDense.wo.weight",
+  "encoder.block.14.layer.1.layer_norm.weight",
+  "encoder.block.15.layer.0.SelfAttention.k.weight",
+  "encoder.block.15.layer.0.SelfAttention.o.weight",
+  "encoder.block.15.layer.0.SelfAttention.q.weight",
+  "encoder.block.15.layer.0.SelfAttention.v.weight",
+  "encoder.block.15.layer.0.layer_norm.weight",
+  "encoder.block.15.layer.1.DenseReluDense.wi_0.weight",
+  "encoder.block.15.layer.1.DenseReluDense.wi_1.weight",
+  "encoder.block.15.layer.1.DenseReluDense.wo.weight",
+  "encoder.block.15.layer.1.layer_norm.weight",
+  "encoder.block.16.layer.0.SelfAttention.k.weight",
+  "encoder.block.16.layer.0.SelfAttention.o.weight",
+  "encoder.block.16.layer.0.SelfAttention.q.weight",
+  "encoder.block.16.layer.0.SelfAttention.v.weight",
+  "encoder.block.16.layer.0.layer_norm.weight",
+  "encoder.block.16.layer.1.DenseReluDense.wi_0.weight",
+  "encoder.block.16.layer.1.DenseReluDense.wi_1.weight",
+  "encoder.block.16.layer.1.DenseReluDense.wo.weight",
+  "encoder.block.16.layer.1.layer_norm.weight",
+  "encoder.block.17.layer.0.SelfAttention.k.weight",
+  "encoder.block.17.layer.0.SelfAttention.o.weight",
+  "encoder.block.17.layer.0.SelfAttention.q.weight",
+  "encoder.block.17.layer.0.SelfAttention.v.weight",
+  "encoder.block.17.layer.0.layer_norm.weight",
+  "encoder.block.17.layer.1.DenseReluDense.wi_0.weight",
+  "encoder.block.17.layer.1.DenseReluDense.wi_1.weight",
+  "encoder.block.17.layer.1.DenseReluDense.wo.weight",
+  "encoder.block.17.layer.1.layer_norm.weight",
+  "encoder.block.18.layer.0.SelfAttention.k.weight",
+  "encoder.block.18.layer.0.SelfAttention.o.weight",
+  "encoder.block.18.layer.0.SelfAttention.q.weight",
+  "encoder.block.18.layer.0.SelfAttention.v.weight",
+  "encoder.block.18.layer.0.layer_norm.weight",
+  "encoder.block.18.layer.1.DenseReluDense.wi_0.weight",
+  "encoder.block.18.layer.1.DenseReluDense.wi_1.weight",
+  "encoder.block.18.layer.1.DenseReluDense.wo.weight",
+  "encoder.block.18.layer.1.layer_norm.weight",
+  "encoder.block.19.layer.0.SelfAttention.k.weight",
+  "encoder.block.19.layer.0.SelfAttention.o.weight",
+  "encoder.block.19.layer.0.SelfAttention.q.weight",
+  "encoder.block.19.layer.0.SelfAttention.v.weight",
+  "encoder.block.19.layer.0.layer_norm.weight",
+  "encoder.block.19.layer.1.DenseReluDense.wi_0.weight",
+  "encoder.block.19.layer.1.DenseReluDense.wi_1.weight",
+  "encoder.block.19.layer.1.DenseReluDense.wo.weight",
+  "encoder.block.19.layer.1.layer_norm.weight",
+  "encoder.block.2.layer.0.SelfAttention.k.weight",
+  "encoder.block.2.layer.0.SelfAttention.o.weight",
+  "encoder.block.2.layer.0.SelfAttention.q.weight",
+  "encoder.block.2.layer.0.SelfAttention.v.weight",
+  "encoder.block.2.layer.0.layer_norm.weight",
+  "encoder.block.2.layer.1.DenseReluDense.wi_0.weight",
+  "encoder.block.2.layer.1.DenseReluDense.wi_1.weight",
+  "encoder.block.2.layer.1.DenseReluDense.wo.weight",
+  "encoder.block.2.layer.1.layer_norm.weight",
+  "encoder.block.20.layer.0.SelfAttention.k.weight",
+  "encoder.block.20.layer.0.SelfAttention.o.weight",
+  "encoder.block.20.layer.0.SelfAttention.q.weight",
+  "encoder.block.20.layer.0.SelfAttention.v.weight",
+  "encoder.block.20.layer.0.layer_norm.weight",
+  "encoder.block.20.layer.1.DenseReluDense.wi_0.weight",
+  "encoder.block.20.layer.1.DenseReluDense.wi_1.weight",
+  "encoder.block.20.layer.1.DenseReluDense.wo.weight",
+  "encoder.block.20.layer.1.layer_norm.weight",
+  "encoder.block.21.layer.0.SelfAttention.k.weight",
+  "encoder.block.21.layer.0.SelfAttention.o.weight",
+  "encoder.block.21.layer.0.SelfAttention.q.weight",
+  "encoder.block.21.layer.0.SelfAttention.v.weight",
+  "encoder.block.21.layer.0.layer_norm.weight",
+  "encoder.block.21.layer.1.DenseReluDense.wi_0.weight",
+  "encoder.block.21.layer.1.DenseReluDense.wi_1.weight",
+  "encoder.block.21.layer.1.DenseReluDense.wo.weight",
+  "encoder.block.21.layer.1.layer_norm.weight",
+  "encoder.block.22.layer.0.SelfAttention.k.weight",
+  "encoder.block.22.layer.0.SelfAttention.o.weight",
+  "encoder.block.22.layer.0.SelfAttention.q.weight",
+  "encoder.block.22.layer.0.SelfAttention.v.weight",
+  "encoder.block.22.layer.0.layer_norm.weight",
+  "encoder.block.22.layer.1.DenseReluDense.wi_0.weight",
+  "encoder.block.22.layer.1.DenseReluDense.wi_1.weight",
+  "encoder.block.22.layer.1.DenseReluDense.wo.weight",
+  "encoder.block.22.layer.1.layer_norm.weight",
+  "encoder.block.23.layer.0.SelfAttention.k.weight",
+  "encoder.block.23.layer.0.SelfAttention.o.weight",
+  "encoder.block.23.layer.0.SelfAttention.q.weight",
+  "encoder.block.23.layer.0.SelfAttention.v.weight",
+  "encoder.block.23.layer.0.layer_norm.weight",
+  "encoder.block.23.layer.1.DenseReluDense.wi_0.weight",
+  "encoder.block.23.layer.1.DenseReluDense.wi_1.weight",
+  "encoder.block.23.layer.1.DenseReluDense.wo.weight",
+  "encoder.block.23.layer.1.layer_norm.weight",
+  "encoder.block.3.layer.0.SelfAttention.k.weight",
+  "encoder.block.3.layer.0.SelfAttention.o.weight",
+  "encoder.block.3.layer.0.SelfAttention.q.weight",
+  "encoder.block.3.layer.0.SelfAttention.v.weight",
+  "encoder.block.3.layer.0.layer_norm.weight",
+  "encoder.block.3.layer.1.DenseReluDense.wi_0.weight",
+  "encoder.block.3.layer.1.DenseReluDense.wi_1.weight",
+  "encoder.block.3.layer.1.DenseReluDense.wo.weight",
+  "encoder.block.3.layer.1.layer_norm.weight",
+  "encoder.block.4.layer.0.SelfAttention.k.weight",
+  "encoder.block.4.layer.0.SelfAttention.o.weight",
+  "encoder.block.4.layer.0.SelfAttention.q.weight",
+  "encoder.block.4.layer.0.SelfAttention.v.weight",
+  "encoder.block.4.layer.0.layer_norm.weight",
+  "encoder.block.4.layer.1.DenseReluDense.wi_0.weight",
+  "encoder.block.4.layer.1.DenseReluDense.wi_1.weight",
+  "encoder.block.4.layer.1.DenseReluDense.wo.weight",
+  "encoder.block.4.layer.1.layer_norm.weight",
+  "encoder.block.5.layer.0.SelfAttention.k.weight",
+  "encoder.block.5.layer.0.SelfAttention.o.weight",
+  "encoder.block.5.layer.0.SelfAttention.q.weight",
+  "encoder.block.5.layer.0.SelfAttention.v.weight",
+  "encoder.block.5.layer.0.layer_norm.weight",
+  "encoder.block.5.layer.1.DenseReluDense.wi_0.weight",
+  "encoder.block.5.layer.1.DenseReluDense.wi_1.weight",
+  "encoder.block.5.layer.1.DenseReluDense.wo.weight",
+  "encoder.block.5.layer.1.layer_norm.weight",
+  "encoder.block.6.layer.0.SelfAttention.k.weight",
+  "encoder.block.6.layer.0.SelfAttention.o.weight",
+  "encoder.block.6.layer.0.SelfAttention.q.weight",
+  "encoder.block.6.layer.0.SelfAttention.v.weight",
+  "encoder.block.6.layer.0.layer_norm.weight",
+  "encoder.block.6.layer.1.DenseReluDense.wi_0.weight",
+  "encoder.block.6.layer.1.DenseReluDense.wi_1.weight",
+  "encoder.block.6.layer.1.DenseReluDense.wo.weight",
+  "encoder.block.6.layer.1.layer_norm.weight",
+  "encoder.block.7.layer.0.SelfAttention.k.weight",
+  "encoder.block.7.layer.0.SelfAttention.o.weight",
+  "encoder.block.7.layer.0.SelfAttention.q.weight",
+  "encoder.block.7.layer.0.SelfAttention.v.weight",
+  "encoder.block.7.layer.0.layer_norm.weight",
+  "encoder.block.7.layer.1.DenseReluDense.wi_0.weight",
+  "encoder.block.7.layer.1.DenseReluDense.wi_1.weight",
+  "encoder.block.7.layer.1.DenseReluDense.wo.weight",
+  "encoder.block.7.layer.1.layer_norm.weight",
+  "encoder.block.8.layer.0.SelfAttention.k.weight",
+  "encoder.block.8.layer.0.SelfAttention.o.weight",
+  "encoder.block.8.layer.0.SelfAttention.q.weight",
+  "encoder.block.8.layer.0.SelfAttention.v.weight",
+  "encoder.block.8.layer.0.layer_norm.weight",
+  "encoder.block.8.layer.1.DenseReluDense.wi_0.weight",
+  "encoder.block.8.layer.1.DenseReluDense.wi_1.weight",
+  "encoder.block.8.layer.1.DenseReluDense.wo.weight",
+  "encoder.block.8.layer.1.layer_norm.weight",
+  "encoder.block.9.layer.0.SelfAttention.k.weight",
+  "encoder.block.9.layer.0.SelfAttention.o.weight",
+  "encoder.block.9.layer.0.SelfAttention.q.weight",
+  "encoder.block.9.layer.0.SelfAttention.v.weight",
+  "encoder.block.9.layer.0.layer_norm.weight",
+  "encoder.block.9.layer.1.DenseReluDense.wi_0.weight",
+  "encoder.block.9.layer.1.DenseReluDense.wi_1.weight",
+  "encoder.block.9.layer.1.DenseReluDense.wo.weight",
+  "encoder.block.9.layer.1.layer_norm.weight",
+  "encoder.final_layer_norm.weight",
+  "shared.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.0.layer.0.SelfAttention.k.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.0.layer.0.SelfAttention.o.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.0.layer.0.SelfAttention.q.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.0.layer.0.SelfAttention.relative_attention_bias.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.0.layer.0.SelfAttention.v.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.0.layer.0.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.0.layer.1.DenseReluDense.wi_0.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.0.layer.1.DenseReluDense.wi_1.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.0.layer.1.DenseReluDense.wo.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.0.layer.1.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.1.layer.0.SelfAttention.k.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.1.layer.0.SelfAttention.o.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.1.layer.0.SelfAttention.q.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.1.layer.0.SelfAttention.v.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.1.layer.0.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.1.layer.1.DenseReluDense.wi_0.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.1.layer.1.DenseReluDense.wi_1.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.1.layer.1.DenseReluDense.wo.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.1.layer.1.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.10.layer.0.SelfAttention.k.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.10.layer.0.SelfAttention.o.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.10.layer.0.SelfAttention.q.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.10.layer.0.SelfAttention.v.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.10.layer.0.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.10.layer.1.DenseReluDense.wi_0.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.10.layer.1.DenseReluDense.wi_1.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.10.layer.1.DenseReluDense.wo.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.10.layer.1.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.11.layer.0.SelfAttention.k.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.11.layer.0.SelfAttention.o.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.11.layer.0.SelfAttention.q.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.11.layer.0.SelfAttention.v.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.11.layer.0.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.11.layer.1.DenseReluDense.wi_0.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.11.layer.1.DenseReluDense.wi_1.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.11.layer.1.DenseReluDense.wo.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.11.layer.1.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.12.layer.0.SelfAttention.k.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.12.layer.0.SelfAttention.o.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.12.layer.0.SelfAttention.q.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.12.layer.0.SelfAttention.v.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.12.layer.0.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.12.layer.1.DenseReluDense.wi_0.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.12.layer.1.DenseReluDense.wi_1.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.12.layer.1.DenseReluDense.wo.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.12.layer.1.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.13.layer.0.SelfAttention.k.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.13.layer.0.SelfAttention.o.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.13.layer.0.SelfAttention.q.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.13.layer.0.SelfAttention.v.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.13.layer.0.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.13.layer.1.DenseReluDense.wi_0.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.13.layer.1.DenseReluDense.wi_1.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.13.layer.1.DenseReluDense.wo.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.13.layer.1.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.14.layer.0.SelfAttention.k.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.14.layer.0.SelfAttention.o.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.14.layer.0.SelfAttention.q.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.14.layer.0.SelfAttention.v.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.14.layer.0.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.14.layer.1.DenseReluDense.wi_0.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.14.layer.1.DenseReluDense.wi_1.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.14.layer.1.DenseReluDense.wo.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.14.layer.1.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.15.layer.0.SelfAttention.k.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.15.layer.0.SelfAttention.o.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.15.layer.0.SelfAttention.q.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.15.layer.0.SelfAttention.v.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.15.layer.0.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.15.layer.1.DenseReluDense.wi_0.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.15.layer.1.DenseReluDense.wi_1.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.15.layer.1.DenseReluDense.wo.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.15.layer.1.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.16.layer.0.SelfAttention.k.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.16.layer.0.SelfAttention.o.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.16.layer.0.SelfAttention.q.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.16.layer.0.SelfAttention.v.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.16.layer.0.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.16.layer.1.DenseReluDense.wi_0.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.16.layer.1.DenseReluDense.wi_1.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.16.layer.1.DenseReluDense.wo.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.16.layer.1.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.17.layer.0.SelfAttention.k.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.17.layer.0.SelfAttention.o.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.17.layer.0.SelfAttention.q.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.17.layer.0.SelfAttention.v.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.17.layer.0.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.17.layer.1.DenseReluDense.wi_0.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.17.layer.1.DenseReluDense.wi_1.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.17.layer.1.DenseReluDense.wo.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.17.layer.1.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.18.layer.0.SelfAttention.k.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.18.layer.0.SelfAttention.o.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.18.layer.0.SelfAttention.q.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.18.layer.0.SelfAttention.v.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.18.layer.0.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.18.layer.1.DenseReluDense.wi_0.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.18.layer.1.DenseReluDense.wi_1.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.18.layer.1.DenseReluDense.wo.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.18.layer.1.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.19.layer.0.SelfAttention.k.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.19.layer.0.SelfAttention.o.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.19.layer.0.SelfAttention.q.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.19.layer.0.SelfAttention.v.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.19.layer.0.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.19.layer.1.DenseReluDense.wi_0.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.19.layer.1.DenseReluDense.wi_1.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.19.layer.1.DenseReluDense.wo.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.19.layer.1.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.2.layer.0.SelfAttention.k.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.2.layer.0.SelfAttention.o.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.2.layer.0.SelfAttention.q.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.2.layer.0.SelfAttention.v.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.2.layer.0.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.2.layer.1.DenseReluDense.wi_0.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.2.layer.1.DenseReluDense.wi_1.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.2.layer.1.DenseReluDense.wo.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.2.layer.1.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.20.layer.0.SelfAttention.k.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.20.layer.0.SelfAttention.o.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.20.layer.0.SelfAttention.q.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.20.layer.0.SelfAttention.v.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.20.layer.0.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.20.layer.1.DenseReluDense.wi_0.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.20.layer.1.DenseReluDense.wi_1.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.20.layer.1.DenseReluDense.wo.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.20.layer.1.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.21.layer.0.SelfAttention.k.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.21.layer.0.SelfAttention.o.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.21.layer.0.SelfAttention.q.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.21.layer.0.SelfAttention.v.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.21.layer.0.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.21.layer.1.DenseReluDense.wi_0.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.21.layer.1.DenseReluDense.wi_1.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.21.layer.1.DenseReluDense.wo.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.21.layer.1.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.22.layer.0.SelfAttention.k.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.22.layer.0.SelfAttention.o.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.22.layer.0.SelfAttention.q.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.22.layer.0.SelfAttention.v.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.22.layer.0.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.22.layer.1.DenseReluDense.wi_0.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.22.layer.1.DenseReluDense.wi_1.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.22.layer.1.DenseReluDense.wo.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.22.layer.1.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.23.layer.0.SelfAttention.k.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.23.layer.0.SelfAttention.o.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.23.layer.0.SelfAttention.q.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.23.layer.0.SelfAttention.v.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.23.layer.0.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.23.layer.1.DenseReluDense.wi_0.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.23.layer.1.DenseReluDense.wi_1.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.23.layer.1.DenseReluDense.wo.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.23.layer.1.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.3.layer.0.SelfAttention.k.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.3.layer.0.SelfAttention.o.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.3.layer.0.SelfAttention.q.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.3.layer.0.SelfAttention.v.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.3.layer.0.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.3.layer.1.DenseReluDense.wi_0.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.3.layer.1.DenseReluDense.wi_1.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.3.layer.1.DenseReluDense.wo.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.3.layer.1.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.4.layer.0.SelfAttention.k.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.4.layer.0.SelfAttention.o.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.4.layer.0.SelfAttention.q.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.4.layer.0.SelfAttention.v.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.4.layer.0.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.4.layer.1.DenseReluDense.wi_0.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.4.layer.1.DenseReluDense.wi_1.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.4.layer.1.DenseReluDense.wo.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.4.layer.1.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.5.layer.0.SelfAttention.k.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.5.layer.0.SelfAttention.o.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.5.layer.0.SelfAttention.q.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.5.layer.0.SelfAttention.v.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.5.layer.0.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.5.layer.1.DenseReluDense.wi_0.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.5.layer.1.DenseReluDense.wi_1.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.5.layer.1.DenseReluDense.wo.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.5.layer.1.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.6.layer.0.SelfAttention.k.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.6.layer.0.SelfAttention.o.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.6.layer.0.SelfAttention.q.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.6.layer.0.SelfAttention.v.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.6.layer.0.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.6.layer.1.DenseReluDense.wi_0.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.6.layer.1.DenseReluDense.wi_1.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.6.layer.1.DenseReluDense.wo.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.6.layer.1.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.7.layer.0.SelfAttention.k.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.7.layer.0.SelfAttention.o.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.7.layer.0.SelfAttention.q.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.7.layer.0.SelfAttention.v.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.7.layer.0.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.7.layer.1.DenseReluDense.wi_0.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.7.layer.1.DenseReluDense.wi_1.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.7.layer.1.DenseReluDense.wo.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.7.layer.1.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.8.layer.0.SelfAttention.k.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.8.layer.0.SelfAttention.o.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.8.layer.0.SelfAttention.q.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.8.layer.0.SelfAttention.v.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.8.layer.0.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.8.layer.1.DenseReluDense.wi_0.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.8.layer.1.DenseReluDense.wi_1.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.8.layer.1.DenseReluDense.wo.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.8.layer.1.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.9.layer.0.SelfAttention.k.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.9.layer.0.SelfAttention.o.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.9.layer.0.SelfAttention.q.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.9.layer.0.SelfAttention.v.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.9.layer.0.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.9.layer.1.DenseReluDense.wi_0.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.9.layer.1.DenseReluDense.wi_1.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.9.layer.1.DenseReluDense.wo.weight",
+  "text_encoders.t5xxl.transformer.encoder.block.9.layer.1.layer_norm.weight",
+  "text_encoders.t5xxl.transformer.encoder.final_layer_norm.weight",
+  "text_encoders.t5xxl.transformer.shared.weight"
+]

flux_transformer_keys.json

@@ -0,0 +1,1562 @@
+[
+  "double_blocks.0.img_attn.norm.key_norm.scale",
+  "double_blocks.0.img_attn.norm.query_norm.scale",
+  "double_blocks.0.img_attn.proj.bias",
+  "double_blocks.0.img_attn.proj.weight",
+  "double_blocks.0.img_attn.qkv.bias",
+  "double_blocks.0.img_attn.qkv.weight",
+  "double_blocks.0.img_mlp.0.bias",
+  "double_blocks.0.img_mlp.0.weight",
+  "double_blocks.0.img_mlp.2.bias",
+  "double_blocks.0.img_mlp.2.weight",
+  "double_blocks.0.img_mod.lin.bias",
+  "double_blocks.0.img_mod.lin.weight",
+  "double_blocks.0.txt_attn.norm.key_norm.scale",
+  "double_blocks.0.txt_attn.norm.query_norm.scale",
+  "double_blocks.0.txt_attn.proj.bias",
+  "double_blocks.0.txt_attn.proj.weight",
+  "double_blocks.0.txt_attn.qkv.bias",
+  "double_blocks.0.txt_attn.qkv.weight",
+  "double_blocks.0.txt_mlp.0.bias",
+  "double_blocks.0.txt_mlp.0.weight",
+  "double_blocks.0.txt_mlp.2.bias",
+  "double_blocks.0.txt_mlp.2.weight",
+  "double_blocks.0.txt_mod.lin.bias",
+  "double_blocks.0.txt_mod.lin.weight",
+  "double_blocks.1.img_attn.norm.key_norm.scale",
+  "double_blocks.1.img_attn.norm.query_norm.scale",
+  "double_blocks.1.img_attn.proj.bias",
+  "double_blocks.1.img_attn.proj.weight",
+  "double_blocks.1.img_attn.qkv.bias",
+  "double_blocks.1.img_attn.qkv.weight",
+  "double_blocks.1.img_mlp.0.bias",
+  "double_blocks.1.img_mlp.0.weight",
+  "double_blocks.1.img_mlp.2.bias",
+  "double_blocks.1.img_mlp.2.weight",
+  "double_blocks.1.img_mod.lin.bias",
+  "double_blocks.1.img_mod.lin.weight",
+  "double_blocks.1.txt_attn.norm.key_norm.scale",
+  "double_blocks.1.txt_attn.norm.query_norm.scale",
+  "double_blocks.1.txt_attn.proj.bias",
+  "double_blocks.1.txt_attn.proj.weight",
+  "double_blocks.1.txt_attn.qkv.bias",
+  "double_blocks.1.txt_attn.qkv.weight",
+  "double_blocks.1.txt_mlp.0.bias",
+  "double_blocks.1.txt_mlp.0.weight",
+  "double_blocks.1.txt_mlp.2.bias",
+  "double_blocks.1.txt_mlp.2.weight",
+  "double_blocks.1.txt_mod.lin.bias",
+  "double_blocks.1.txt_mod.lin.weight",
+  "double_blocks.10.img_attn.norm.key_norm.scale",
+  "double_blocks.10.img_attn.norm.query_norm.scale",
+  "double_blocks.10.img_attn.proj.bias",
+  "double_blocks.10.img_attn.proj.weight",
+  "double_blocks.10.img_attn.qkv.bias",
+  "double_blocks.10.img_attn.qkv.weight",
+  "double_blocks.10.img_mlp.0.bias",
+  "double_blocks.10.img_mlp.0.weight",
+  "double_blocks.10.img_mlp.2.bias",
+  "double_blocks.10.img_mlp.2.weight",
+  "double_blocks.10.img_mod.lin.bias",
+  "double_blocks.10.img_mod.lin.weight",
+  "double_blocks.10.txt_attn.norm.key_norm.scale",
+  "double_blocks.10.txt_attn.norm.query_norm.scale",
+  "double_blocks.10.txt_attn.proj.bias",
+  "double_blocks.10.txt_attn.proj.weight",
+  "double_blocks.10.txt_attn.qkv.bias",
+  "double_blocks.10.txt_attn.qkv.weight",
+  "double_blocks.10.txt_mlp.0.bias",
+  "double_blocks.10.txt_mlp.0.weight",
+  "double_blocks.10.txt_mlp.2.bias",
+  "double_blocks.10.txt_mlp.2.weight",
+  "double_blocks.10.txt_mod.lin.bias",
+  "double_blocks.10.txt_mod.lin.weight",
+  "double_blocks.11.img_attn.norm.key_norm.scale",
+  "double_blocks.11.img_attn.norm.query_norm.scale",
+  "double_blocks.11.img_attn.proj.bias",
+  "double_blocks.11.img_attn.proj.weight",
+  "double_blocks.11.img_attn.qkv.bias",
+  "double_blocks.11.img_attn.qkv.weight",
+  "double_blocks.11.img_mlp.0.bias",
+  "double_blocks.11.img_mlp.0.weight",
+  "double_blocks.11.img_mlp.2.bias",
+  "double_blocks.11.img_mlp.2.weight",
+  "double_blocks.11.img_mod.lin.bias",
+  "double_blocks.11.img_mod.lin.weight",
+  "double_blocks.11.txt_attn.norm.key_norm.scale",
+  "double_blocks.11.txt_attn.norm.query_norm.scale",
+  "double_blocks.11.txt_attn.proj.bias",
+  "double_blocks.11.txt_attn.proj.weight",
+  "double_blocks.11.txt_attn.qkv.bias",
+  "double_blocks.11.txt_attn.qkv.weight",
+  "double_blocks.11.txt_mlp.0.bias",
+  "double_blocks.11.txt_mlp.0.weight",
+  "double_blocks.11.txt_mlp.2.bias",
+  "double_blocks.11.txt_mlp.2.weight",
+  "double_blocks.11.txt_mod.lin.bias",
+  "double_blocks.11.txt_mod.lin.weight",
+  "double_blocks.12.img_attn.norm.key_norm.scale",
+  "double_blocks.12.img_attn.norm.query_norm.scale",
+  "double_blocks.12.img_attn.proj.bias",
+  "double_blocks.12.img_attn.proj.weight",
+  "double_blocks.12.img_attn.qkv.bias",
+  "double_blocks.12.img_attn.qkv.weight",
+  "double_blocks.12.img_mlp.0.bias",
+  "double_blocks.12.img_mlp.0.weight",
+  "double_blocks.12.img_mlp.2.bias",
+  "double_blocks.12.img_mlp.2.weight",
+  "double_blocks.12.img_mod.lin.bias",
+  "double_blocks.12.img_mod.lin.weight",
+  "double_blocks.12.txt_attn.norm.key_norm.scale",
+  "double_blocks.12.txt_attn.norm.query_norm.scale",
+  "double_blocks.12.txt_attn.proj.bias",
+  "double_blocks.12.txt_attn.proj.weight",
+  "double_blocks.12.txt_attn.qkv.bias",
+  "double_blocks.12.txt_attn.qkv.weight",
+  "double_blocks.12.txt_mlp.0.bias",
+  "double_blocks.12.txt_mlp.0.weight",
+  "double_blocks.12.txt_mlp.2.bias",
+  "double_blocks.12.txt_mlp.2.weight",
+  "double_blocks.12.txt_mod.lin.bias",
+  "double_blocks.12.txt_mod.lin.weight",
+  "double_blocks.13.img_attn.norm.key_norm.scale",
+  "double_blocks.13.img_attn.norm.query_norm.scale",
+  "double_blocks.13.img_attn.proj.bias",
+  "double_blocks.13.img_attn.proj.weight",
+  "double_blocks.13.img_attn.qkv.bias",
+  "double_blocks.13.img_attn.qkv.weight",
+  "double_blocks.13.img_mlp.0.bias",
+  "double_blocks.13.img_mlp.0.weight",
+  "double_blocks.13.img_mlp.2.bias",
+  "double_blocks.13.img_mlp.2.weight",
+  "double_blocks.13.img_mod.lin.bias",
+  "double_blocks.13.img_mod.lin.weight",
+  "double_blocks.13.txt_attn.norm.key_norm.scale",
+  "double_blocks.13.txt_attn.norm.query_norm.scale",
+  "double_blocks.13.txt_attn.proj.bias",
+  "double_blocks.13.txt_attn.proj.weight",
+  "double_blocks.13.txt_attn.qkv.bias",
+  "double_blocks.13.txt_attn.qkv.weight",
+  "double_blocks.13.txt_mlp.0.bias",
+  "double_blocks.13.txt_mlp.0.weight",
+  "double_blocks.13.txt_mlp.2.bias",
+  "double_blocks.13.txt_mlp.2.weight",
+  "double_blocks.13.txt_mod.lin.bias",
+  "double_blocks.13.txt_mod.lin.weight",
+  "double_blocks.14.img_attn.norm.key_norm.scale",
+  "double_blocks.14.img_attn.norm.query_norm.scale",
+  "double_blocks.14.img_attn.proj.bias",
+  "double_blocks.14.img_attn.proj.weight",
+  "double_blocks.14.img_attn.qkv.bias",
+  "double_blocks.14.img_attn.qkv.weight",
+  "double_blocks.14.img_mlp.0.bias",
+  "double_blocks.14.img_mlp.0.weight",
+  "double_blocks.14.img_mlp.2.bias",
+  "double_blocks.14.img_mlp.2.weight",
+  "double_blocks.14.img_mod.lin.bias",
+  "double_blocks.14.img_mod.lin.weight",
+  "double_blocks.14.txt_attn.norm.key_norm.scale",
+  "double_blocks.14.txt_attn.norm.query_norm.scale",
+  "double_blocks.14.txt_attn.proj.bias",
+  "double_blocks.14.txt_attn.proj.weight",
+  "double_blocks.14.txt_attn.qkv.bias",
+  "double_blocks.14.txt_attn.qkv.weight",
+  "double_blocks.14.txt_mlp.0.bias",
+  "double_blocks.14.txt_mlp.0.weight",
+  "double_blocks.14.txt_mlp.2.bias",
+  "double_blocks.14.txt_mlp.2.weight",
+  "double_blocks.14.txt_mod.lin.bias",
+  "double_blocks.14.txt_mod.lin.weight",
+  "double_blocks.15.img_attn.norm.key_norm.scale",
+  "double_blocks.15.img_attn.norm.query_norm.scale",
+  "double_blocks.15.img_attn.proj.bias",
+  "double_blocks.15.img_attn.proj.weight",
+  "double_blocks.15.img_attn.qkv.bias",
+  "double_blocks.15.img_attn.qkv.weight",
+  "double_blocks.15.img_mlp.0.bias",
+  "double_blocks.15.img_mlp.0.weight",
+  "double_blocks.15.img_mlp.2.bias",
+  "double_blocks.15.img_mlp.2.weight",
+  "double_blocks.15.img_mod.lin.bias",
+  "double_blocks.15.img_mod.lin.weight",
+  "double_blocks.15.txt_attn.norm.key_norm.scale",
+  "double_blocks.15.txt_attn.norm.query_norm.scale",
+  "double_blocks.15.txt_attn.proj.bias",
+  "double_blocks.15.txt_attn.proj.weight",
+  "double_blocks.15.txt_attn.qkv.bias",
+  "double_blocks.15.txt_attn.qkv.weight",
+  "double_blocks.15.txt_mlp.0.bias",
+  "double_blocks.15.txt_mlp.0.weight",
+  "double_blocks.15.txt_mlp.2.bias",
+  "double_blocks.15.txt_mlp.2.weight",
+  "double_blocks.15.txt_mod.lin.bias",
+  "double_blocks.15.txt_mod.lin.weight",
+  "double_blocks.16.img_attn.norm.key_norm.scale",
+  "double_blocks.16.img_attn.norm.query_norm.scale",
+  "double_blocks.16.img_attn.proj.bias",
+  "double_blocks.16.img_attn.proj.weight",
+  "double_blocks.16.img_attn.qkv.bias",
+  "double_blocks.16.img_attn.qkv.weight",
+  "double_blocks.16.img_mlp.0.bias",
+  "double_blocks.16.img_mlp.0.weight",
+  "double_blocks.16.img_mlp.2.bias",
+  "double_blocks.16.img_mlp.2.weight",
+  "double_blocks.16.img_mod.lin.bias",
+  "double_blocks.16.img_mod.lin.weight",
+  "double_blocks.16.txt_attn.norm.key_norm.scale",
+  "double_blocks.16.txt_attn.norm.query_norm.scale",
+  "double_blocks.16.txt_attn.proj.bias",
+  "double_blocks.16.txt_attn.proj.weight",
+  "double_blocks.16.txt_attn.qkv.bias",
+  "double_blocks.16.txt_attn.qkv.weight",
+  "double_blocks.16.txt_mlp.0.bias",
+  "double_blocks.16.txt_mlp.0.weight",
+  "double_blocks.16.txt_mlp.2.bias",
+  "double_blocks.16.txt_mlp.2.weight",
+  "double_blocks.16.txt_mod.lin.bias",
+  "double_blocks.16.txt_mod.lin.weight",
+  "double_blocks.17.img_attn.norm.key_norm.scale",
+  "double_blocks.17.img_attn.norm.query_norm.scale",
+  "double_blocks.17.img_attn.proj.bias",
+  "double_blocks.17.img_attn.proj.weight",
+  "double_blocks.17.img_attn.qkv.bias",
+  "double_blocks.17.img_attn.qkv.weight",
+  "double_blocks.17.img_mlp.0.bias",
+  "double_blocks.17.img_mlp.0.weight",
+  "double_blocks.17.img_mlp.2.bias",
+  "double_blocks.17.img_mlp.2.weight",
+  "double_blocks.17.img_mod.lin.bias",
+  "double_blocks.17.img_mod.lin.weight",
+  "double_blocks.17.txt_attn.norm.key_norm.scale",
+  "double_blocks.17.txt_attn.norm.query_norm.scale",
+  "double_blocks.17.txt_attn.proj.bias",
+  "double_blocks.17.txt_attn.proj.weight",
+  "double_blocks.17.txt_attn.qkv.bias",
+  "double_blocks.17.txt_attn.qkv.weight",
+  "double_blocks.17.txt_mlp.0.bias",
+  "double_blocks.17.txt_mlp.0.weight",
+  "double_blocks.17.txt_mlp.2.bias",
+  "double_blocks.17.txt_mlp.2.weight",
+  "double_blocks.17.txt_mod.lin.bias",
+  "double_blocks.17.txt_mod.lin.weight",
+  "double_blocks.18.img_attn.norm.key_norm.scale",
+  "double_blocks.18.img_attn.norm.query_norm.scale",
+  "double_blocks.18.img_attn.proj.bias",
+  "double_blocks.18.img_attn.proj.weight",
+  "double_blocks.18.img_attn.qkv.bias",
+  "double_blocks.18.img_attn.qkv.weight",
+  "double_blocks.18.img_mlp.0.bias",
+  "double_blocks.18.img_mlp.0.weight",
+  "double_blocks.18.img_mlp.2.bias",
+  "double_blocks.18.img_mlp.2.weight",
+  "double_blocks.18.img_mod.lin.bias",
+  "double_blocks.18.img_mod.lin.weight",
+  "double_blocks.18.txt_attn.norm.key_norm.scale",
+  "double_blocks.18.txt_attn.norm.query_norm.scale",
+  "double_blocks.18.txt_attn.proj.bias",
+  "double_blocks.18.txt_attn.proj.weight",
+  "double_blocks.18.txt_attn.qkv.bias",
+  "double_blocks.18.txt_attn.qkv.weight",
+  "double_blocks.18.txt_mlp.0.bias",
+  "double_blocks.18.txt_mlp.0.weight",
+  "double_blocks.18.txt_mlp.2.bias",
+  "double_blocks.18.txt_mlp.2.weight",
+  "double_blocks.18.txt_mod.lin.bias",
+  "double_blocks.18.txt_mod.lin.weight",
+  "double_blocks.2.img_attn.norm.key_norm.scale",
+  "double_blocks.2.img_attn.norm.query_norm.scale",
+  "double_blocks.2.img_attn.proj.bias",
+  "double_blocks.2.img_attn.proj.weight",
+  "double_blocks.2.img_attn.qkv.bias",
+  "double_blocks.2.img_attn.qkv.weight",
+  "double_blocks.2.img_mlp.0.bias",
+  "double_blocks.2.img_mlp.0.weight",
+  "double_blocks.2.img_mlp.2.bias",
+  "double_blocks.2.img_mlp.2.weight",
+  "double_blocks.2.img_mod.lin.bias",
+  "double_blocks.2.img_mod.lin.weight",
+  "double_blocks.2.txt_attn.norm.key_norm.scale",
+  "double_blocks.2.txt_attn.norm.query_norm.scale",
+  "double_blocks.2.txt_attn.proj.bias",
+  "double_blocks.2.txt_attn.proj.weight",
+  "double_blocks.2.txt_attn.qkv.bias",
+  "double_blocks.2.txt_attn.qkv.weight",
+  "double_blocks.2.txt_mlp.0.bias",
+  "double_blocks.2.txt_mlp.0.weight",
+  "double_blocks.2.txt_mlp.2.bias",
+  "double_blocks.2.txt_mlp.2.weight",
+  "double_blocks.2.txt_mod.lin.bias",
+  "double_blocks.2.txt_mod.lin.weight",
+  "double_blocks.3.img_attn.norm.key_norm.scale",
+  "double_blocks.3.img_attn.norm.query_norm.scale",
+  "double_blocks.3.img_attn.proj.bias",
+  "double_blocks.3.img_attn.proj.weight",
+  "double_blocks.3.img_attn.qkv.bias",
+  "double_blocks.3.img_attn.qkv.weight",
+  "double_blocks.3.img_mlp.0.bias",
+  "double_blocks.3.img_mlp.0.weight",
+  "double_blocks.3.img_mlp.2.bias",
+  "double_blocks.3.img_mlp.2.weight",
+  "double_blocks.3.img_mod.lin.bias",
+  "double_blocks.3.img_mod.lin.weight",
+  "double_blocks.3.txt_attn.norm.key_norm.scale",
+  "double_blocks.3.txt_attn.norm.query_norm.scale",
+  "double_blocks.3.txt_attn.proj.bias",
+  "double_blocks.3.txt_attn.proj.weight",
+  "double_blocks.3.txt_attn.qkv.bias",
+  "double_blocks.3.txt_attn.qkv.weight",
+  "double_blocks.3.txt_mlp.0.bias",
+  "double_blocks.3.txt_mlp.0.weight",
+  "double_blocks.3.txt_mlp.2.bias",
+  "double_blocks.3.txt_mlp.2.weight",
+  "double_blocks.3.txt_mod.lin.bias",
+  "double_blocks.3.txt_mod.lin.weight",
+  "double_blocks.4.img_attn.norm.key_norm.scale",
+  "double_blocks.4.img_attn.norm.query_norm.scale",
+  "double_blocks.4.img_attn.proj.bias",
+  "double_blocks.4.img_attn.proj.weight",
+  "double_blocks.4.img_attn.qkv.bias",
+  "double_blocks.4.img_attn.qkv.weight",
+  "double_blocks.4.img_mlp.0.bias",
+  "double_blocks.4.img_mlp.0.weight",
+  "double_blocks.4.img_mlp.2.bias",
+  "double_blocks.4.img_mlp.2.weight",
+  "double_blocks.4.img_mod.lin.bias",
+  "double_blocks.4.img_mod.lin.weight",
+  "double_blocks.4.txt_attn.norm.key_norm.scale",
+  "double_blocks.4.txt_attn.norm.query_norm.scale",
+  "double_blocks.4.txt_attn.proj.bias",
+  "double_blocks.4.txt_attn.proj.weight",
+  "double_blocks.4.txt_attn.qkv.bias",
+  "double_blocks.4.txt_attn.qkv.weight",
+  "double_blocks.4.txt_mlp.0.bias",
+  "double_blocks.4.txt_mlp.0.weight",
+  "double_blocks.4.txt_mlp.2.bias",
+  "double_blocks.4.txt_mlp.2.weight",
+  "double_blocks.4.txt_mod.lin.bias",
+  "double_blocks.4.txt_mod.lin.weight",
+  "double_blocks.5.img_attn.norm.key_norm.scale",
+  "double_blocks.5.img_attn.norm.query_norm.scale",
+  "double_blocks.5.img_attn.proj.bias",
+  "double_blocks.5.img_attn.proj.weight",
+  "double_blocks.5.img_attn.qkv.bias",
+  "double_blocks.5.img_attn.qkv.weight",
+  "double_blocks.5.img_mlp.0.bias",
+  "double_blocks.5.img_mlp.0.weight",
+  "double_blocks.5.img_mlp.2.bias",
+  "double_blocks.5.img_mlp.2.weight",
+  "double_blocks.5.img_mod.lin.bias",
+  "double_blocks.5.img_mod.lin.weight",
+  "double_blocks.5.txt_attn.norm.key_norm.scale",
+  "double_blocks.5.txt_attn.norm.query_norm.scale",
+  "double_blocks.5.txt_attn.proj.bias",
+  "double_blocks.5.txt_attn.proj.weight",
+  "double_blocks.5.txt_attn.qkv.bias",
+  "double_blocks.5.txt_attn.qkv.weight",
+  "double_blocks.5.txt_mlp.0.bias",
+  "double_blocks.5.txt_mlp.0.weight",
+  "double_blocks.5.txt_mlp.2.bias",
+  "double_blocks.5.txt_mlp.2.weight",
+  "double_blocks.5.txt_mod.lin.bias",
+  "double_blocks.5.txt_mod.lin.weight",
+  "double_blocks.6.img_attn.norm.key_norm.scale",
+  "double_blocks.6.img_attn.norm.query_norm.scale",
+  "double_blocks.6.img_attn.proj.bias",
+  "double_blocks.6.img_attn.proj.weight",
+  "double_blocks.6.img_attn.qkv.bias",
+  "double_blocks.6.img_attn.qkv.weight",
+  "double_blocks.6.img_mlp.0.bias",
+  "double_blocks.6.img_mlp.0.weight",
+  "double_blocks.6.img_mlp.2.bias",
+  "double_blocks.6.img_mlp.2.weight",
+  "double_blocks.6.img_mod.lin.bias",
+  "double_blocks.6.img_mod.lin.weight",
+  "double_blocks.6.txt_attn.norm.key_norm.scale",
+  "double_blocks.6.txt_attn.norm.query_norm.scale",
+  "double_blocks.6.txt_attn.proj.bias",
+  "double_blocks.6.txt_attn.proj.weight",
+  "double_blocks.6.txt_attn.qkv.bias",
+  "double_blocks.6.txt_attn.qkv.weight",
+  "double_blocks.6.txt_mlp.0.bias",
+  "double_blocks.6.txt_mlp.0.weight",
+  "double_blocks.6.txt_mlp.2.bias",
+  "double_blocks.6.txt_mlp.2.weight",
+  "double_blocks.6.txt_mod.lin.bias",
+  "double_blocks.6.txt_mod.lin.weight",
+  "double_blocks.7.img_attn.norm.key_norm.scale",
+  "double_blocks.7.img_attn.norm.query_norm.scale",
+  "double_blocks.7.img_attn.proj.bias",
+  "double_blocks.7.img_attn.proj.weight",
+  "double_blocks.7.img_attn.qkv.bias",
+  "double_blocks.7.img_attn.qkv.weight",
+  "double_blocks.7.img_mlp.0.bias",
+  "double_blocks.7.img_mlp.0.weight",
+  "double_blocks.7.img_mlp.2.bias",
+  "double_blocks.7.img_mlp.2.weight",
+  "double_blocks.7.img_mod.lin.bias",
+  "double_blocks.7.img_mod.lin.weight",
+  "double_blocks.7.txt_attn.norm.key_norm.scale",
+  "double_blocks.7.txt_attn.norm.query_norm.scale",
+  "double_blocks.7.txt_attn.proj.bias",
+  "double_blocks.7.txt_attn.proj.weight",
+  "double_blocks.7.txt_attn.qkv.bias",
+  "double_blocks.7.txt_attn.qkv.weight",
+  "double_blocks.7.txt_mlp.0.bias",
+  "double_blocks.7.txt_mlp.0.weight",
+  "double_blocks.7.txt_mlp.2.bias",
+  "double_blocks.7.txt_mlp.2.weight",
+  "double_blocks.7.txt_mod.lin.bias",
+  "double_blocks.7.txt_mod.lin.weight",
+  "double_blocks.8.img_attn.norm.key_norm.scale",
+  "double_blocks.8.img_attn.norm.query_norm.scale",
+  "double_blocks.8.img_attn.proj.bias",
+  "double_blocks.8.img_attn.proj.weight",
+  "double_blocks.8.img_attn.qkv.bias",
+  "double_blocks.8.img_attn.qkv.weight",
+  "double_blocks.8.img_mlp.0.bias",
+  "double_blocks.8.img_mlp.0.weight",
+  "double_blocks.8.img_mlp.2.bias",
+  "double_blocks.8.img_mlp.2.weight",
+  "double_blocks.8.img_mod.lin.bias",
+  "double_blocks.8.img_mod.lin.weight",
+  "double_blocks.8.txt_attn.norm.key_norm.scale",
+  "double_blocks.8.txt_attn.norm.query_norm.scale",
+  "double_blocks.8.txt_attn.proj.bias",
+  "double_blocks.8.txt_attn.proj.weight",
+  "double_blocks.8.txt_attn.qkv.bias",
+  "double_blocks.8.txt_attn.qkv.weight",
+  "double_blocks.8.txt_mlp.0.bias",
+  "double_blocks.8.txt_mlp.0.weight",
+  "double_blocks.8.txt_mlp.2.bias",
+  "double_blocks.8.txt_mlp.2.weight",
+  "double_blocks.8.txt_mod.lin.bias",
+  "double_blocks.8.txt_mod.lin.weight",
+  "double_blocks.9.img_attn.norm.key_norm.scale",
+  "double_blocks.9.img_attn.norm.query_norm.scale",
+  "double_blocks.9.img_attn.proj.bias",
+  "double_blocks.9.img_attn.proj.weight",
+  "double_blocks.9.img_attn.qkv.bias",
+  "double_blocks.9.img_attn.qkv.weight",
+  "double_blocks.9.img_mlp.0.bias",
+  "double_blocks.9.img_mlp.0.weight",
+  "double_blocks.9.img_mlp.2.bias",
+  "double_blocks.9.img_mlp.2.weight",
+  "double_blocks.9.img_mod.lin.bias",
+  "double_blocks.9.img_mod.lin.weight",
+  "double_blocks.9.txt_attn.norm.key_norm.scale",
+  "double_blocks.9.txt_attn.norm.query_norm.scale",
+  "double_blocks.9.txt_attn.proj.bias",
+  "double_blocks.9.txt_attn.proj.weight",
+  "double_blocks.9.txt_attn.qkv.bias",
+  "double_blocks.9.txt_attn.qkv.weight",
+  "double_blocks.9.txt_mlp.0.bias",
+  "double_blocks.9.txt_mlp.0.weight",
+  "double_blocks.9.txt_mlp.2.bias",
+  "double_blocks.9.txt_mlp.2.weight",
+  "double_blocks.9.txt_mod.lin.bias",
+  "double_blocks.9.txt_mod.lin.weight",
+  "final_layer.adaLN_modulation.1.bias",
+  "final_layer.adaLN_modulation.1.weight",
+  "final_layer.linear.bias",
+  "final_layer.linear.weight",
+  "guidance_in.in_layer.bias",
+  "guidance_in.in_layer.weight",
+  "guidance_in.out_layer.bias",
+  "guidance_in.out_layer.weight",
+  "img_in.bias",
+  "img_in.weight",
+  "single_blocks.0.linear1.bias",
+  "single_blocks.0.linear1.weight",
+  "single_blocks.0.linear2.bias",
+  "single_blocks.0.linear2.weight",
+  "single_blocks.0.modulation.lin.bias",
+  "single_blocks.0.modulation.lin.weight",
+  "single_blocks.0.norm.key_norm.scale",
+  "single_blocks.0.norm.query_norm.scale",
+  "single_blocks.1.linear1.bias",
+  "single_blocks.1.linear1.weight",
+  "single_blocks.1.linear2.bias",
+  "single_blocks.1.linear2.weight",
+  "single_blocks.1.modulation.lin.bias",
+  "single_blocks.1.modulation.lin.weight",
+  "single_blocks.1.norm.key_norm.scale",
+  "single_blocks.1.norm.query_norm.scale",
+  "single_blocks.10.linear1.bias",
+  "single_blocks.10.linear1.weight",
+  "single_blocks.10.linear2.bias",
+  "single_blocks.10.linear2.weight",
+  "single_blocks.10.modulation.lin.bias",
+  "single_blocks.10.modulation.lin.weight",
+  "single_blocks.10.norm.key_norm.scale",
+  "single_blocks.10.norm.query_norm.scale",
+  "single_blocks.11.linear1.bias",
+  "single_blocks.11.linear1.weight",
+  "single_blocks.11.linear2.bias",
+  "single_blocks.11.linear2.weight",
+  "single_blocks.11.modulation.lin.bias",
+  "single_blocks.11.modulation.lin.weight",
+  "single_blocks.11.norm.key_norm.scale",
+  "single_blocks.11.norm.query_norm.scale",
+  "single_blocks.12.linear1.bias",
+  "single_blocks.12.linear1.weight",
+  "single_blocks.12.linear2.bias",
+  "single_blocks.12.linear2.weight",
+  "single_blocks.12.modulation.lin.bias",
+  "single_blocks.12.modulation.lin.weight",
+  "single_blocks.12.norm.key_norm.scale",
+  "single_blocks.12.norm.query_norm.scale",
+  "single_blocks.13.linear1.bias",
+  "single_blocks.13.linear1.weight",
+  "single_blocks.13.linear2.bias",
+  "single_blocks.13.linear2.weight",
+  "single_blocks.13.modulation.lin.bias",
+  "single_blocks.13.modulation.lin.weight",
+  "single_blocks.13.norm.key_norm.scale",
+  "single_blocks.13.norm.query_norm.scale",
+  "single_blocks.14.linear1.bias",
+  "single_blocks.14.linear1.weight",
+  "single_blocks.14.linear2.bias",
+  "single_blocks.14.linear2.weight",
+  "single_blocks.14.modulation.lin.bias",
+  "single_blocks.14.modulation.lin.weight",
+  "single_blocks.14.norm.key_norm.scale",
+  "single_blocks.14.norm.query_norm.scale",
+  "single_blocks.15.linear1.bias",
+  "single_blocks.15.linear1.weight",
+  "single_blocks.15.linear2.bias",
+  "single_blocks.15.linear2.weight",
+  "single_blocks.15.modulation.lin.bias",
+  "single_blocks.15.modulation.lin.weight",
+  "single_blocks.15.norm.key_norm.scale",
+  "single_blocks.15.norm.query_norm.scale",
+  "single_blocks.16.linear1.bias",
+  "single_blocks.16.linear1.weight",
+  "single_blocks.16.linear2.bias",
+  "single_blocks.16.linear2.weight",
+  "single_blocks.16.modulation.lin.bias",
+  "single_blocks.16.modulation.lin.weight",
+  "single_blocks.16.norm.key_norm.scale",
+  "single_blocks.16.norm.query_norm.scale",
+  "single_blocks.17.linear1.bias",
+  "single_blocks.17.linear1.weight",
+  "single_blocks.17.linear2.bias",
+  "single_blocks.17.linear2.weight",
+  "single_blocks.17.modulation.lin.bias",
+  "single_blocks.17.modulation.lin.weight",
+  "single_blocks.17.norm.key_norm.scale",
+  "single_blocks.17.norm.query_norm.scale",
+  "single_blocks.18.linear1.bias",
+  "single_blocks.18.linear1.weight",
+  "single_blocks.18.linear2.bias",
+  "single_blocks.18.linear2.weight",
+  "single_blocks.18.modulation.lin.bias",
+  "single_blocks.18.modulation.lin.weight",
+  "single_blocks.18.norm.key_norm.scale",
+  "single_blocks.18.norm.query_norm.scale",
+  "single_blocks.19.linear1.bias",
+  "single_blocks.19.linear1.weight",
+  "single_blocks.19.linear2.bias",
+  "single_blocks.19.linear2.weight",
+  "single_blocks.19.modulation.lin.bias",
+  "single_blocks.19.modulation.lin.weight",
+  "single_blocks.19.norm.key_norm.scale",
+  "single_blocks.19.norm.query_norm.scale",
+  "single_blocks.2.linear1.bias",
+  "single_blocks.2.linear1.weight",
+  "single_blocks.2.linear2.bias",
+  "single_blocks.2.linear2.weight",
+  "single_blocks.2.modulation.lin.bias",
+  "single_blocks.2.modulation.lin.weight",
+  "single_blocks.2.norm.key_norm.scale",
+  "single_blocks.2.norm.query_norm.scale",
+  "single_blocks.20.linear1.bias",
+  "single_blocks.20.linear1.weight",
+  "single_blocks.20.linear2.bias",
+  "single_blocks.20.linear2.weight",
+  "single_blocks.20.modulation.lin.bias",
+  "single_blocks.20.modulation.lin.weight",
+  "single_blocks.20.norm.key_norm.scale",
+  "single_blocks.20.norm.query_norm.scale",
+  "single_blocks.21.linear1.bias",
+  "single_blocks.21.linear1.weight",
+  "single_blocks.21.linear2.bias",
+  "single_blocks.21.linear2.weight",
+  "single_blocks.21.modulation.lin.bias",
+  "single_blocks.21.modulation.lin.weight",
+  "single_blocks.21.norm.key_norm.scale",
+  "single_blocks.21.norm.query_norm.scale",
+  "single_blocks.22.linear1.bias",
+  "single_blocks.22.linear1.weight",
+  "single_blocks.22.linear2.bias",
+  "single_blocks.22.linear2.weight",
+  "single_blocks.22.modulation.lin.bias",
+  "single_blocks.22.modulation.lin.weight",
+  "single_blocks.22.norm.key_norm.scale",
+  "single_blocks.22.norm.query_norm.scale",
+  "single_blocks.23.linear1.bias",
+  "single_blocks.23.linear1.weight",
+  "single_blocks.23.linear2.bias",
+  "single_blocks.23.linear2.weight",
+  "single_blocks.23.modulation.lin.bias",
+  "single_blocks.23.modulation.lin.weight",
+  "single_blocks.23.norm.key_norm.scale",
+  "single_blocks.23.norm.query_norm.scale",
+  "single_blocks.24.linear1.bias",
+  "single_blocks.24.linear1.weight",
+  "single_blocks.24.linear2.bias",
+  "single_blocks.24.linear2.weight",
+  "single_blocks.24.modulation.lin.bias",
+  "single_blocks.24.modulation.lin.weight",
+  "single_blocks.24.norm.key_norm.scale",
+  "single_blocks.24.norm.query_norm.scale",
+  "single_blocks.25.linear1.bias",
+  "single_blocks.25.linear1.weight",
+  "single_blocks.25.linear2.bias",
+  "single_blocks.25.linear2.weight",
+  "single_blocks.25.modulation.lin.bias",
+  "single_blocks.25.modulation.lin.weight",
+  "single_blocks.25.norm.key_norm.scale",
+  "single_blocks.25.norm.query_norm.scale",
+  "single_blocks.26.linear1.bias",
+  "single_blocks.26.linear1.weight",
+  "single_blocks.26.linear2.bias",
+  "single_blocks.26.linear2.weight",
+  "single_blocks.26.modulation.lin.bias",
+  "single_blocks.26.modulation.lin.weight",
+  "single_blocks.26.norm.key_norm.scale",
+  "single_blocks.26.norm.query_norm.scale",
+  "single_blocks.27.linear1.bias",
+  "single_blocks.27.linear1.weight",
+  "single_blocks.27.linear2.bias",
+  "single_blocks.27.linear2.weight",
+  "single_blocks.27.modulation.lin.bias",
+  "single_blocks.27.modulation.lin.weight",
+  "single_blocks.27.norm.key_norm.scale",
+  "single_blocks.27.norm.query_norm.scale",
+  "single_blocks.28.linear1.bias",
+  "single_blocks.28.linear1.weight",
+  "single_blocks.28.linear2.bias",
+  "single_blocks.28.linear2.weight",
+  "single_blocks.28.modulation.lin.bias",
+  "single_blocks.28.modulation.lin.weight",
+  "single_blocks.28.norm.key_norm.scale",
+  "single_blocks.28.norm.query_norm.scale",
+  "single_blocks.29.linear1.bias",
+  "single_blocks.29.linear1.weight",
+  "single_blocks.29.linear2.bias",
+  "single_blocks.29.linear2.weight",
+  "single_blocks.29.modulation.lin.bias",
+  "single_blocks.29.modulation.lin.weight",
+  "single_blocks.29.norm.key_norm.scale",
+  "single_blocks.29.norm.query_norm.scale",
+  "single_blocks.3.linear1.bias",
+  "single_blocks.3.linear1.weight",
+  "single_blocks.3.linear2.bias",
+  "single_blocks.3.linear2.weight",
+  "single_blocks.3.modulation.lin.bias",
+  "single_blocks.3.modulation.lin.weight",
+  "single_blocks.3.norm.key_norm.scale",
+  "single_blocks.3.norm.query_norm.scale",
+  "single_blocks.30.linear1.bias",
+  "single_blocks.30.linear1.weight",
+  "single_blocks.30.linear2.bias",
+  "single_blocks.30.linear2.weight",
+  "single_blocks.30.modulation.lin.bias",
+  "single_blocks.30.modulation.lin.weight",
+  "single_blocks.30.norm.key_norm.scale",
+  "single_blocks.30.norm.query_norm.scale",
+  "single_blocks.31.linear1.bias",
+  "single_blocks.31.linear1.weight",
+  "single_blocks.31.linear2.bias",
+  "single_blocks.31.linear2.weight",
+  "single_blocks.31.modulation.lin.bias",
+  "single_blocks.31.modulation.lin.weight",
+  "single_blocks.31.norm.key_norm.scale",
+  "single_blocks.31.norm.query_norm.scale",
+  "single_blocks.32.linear1.bias",
+  "single_blocks.32.linear1.weight",
+  "single_blocks.32.linear2.bias",
+  "single_blocks.32.linear2.weight",
+  "single_blocks.32.modulation.lin.bias",
+  "single_blocks.32.modulation.lin.weight",
+  "single_blocks.32.norm.key_norm.scale",
+  "single_blocks.32.norm.query_norm.scale",
+  "single_blocks.33.linear1.bias",
+  "single_blocks.33.linear1.weight",
+  "single_blocks.33.linear2.bias",
+  "single_blocks.33.linear2.weight",
+  "single_blocks.33.modulation.lin.bias",
+  "single_blocks.33.modulation.lin.weight",
+  "single_blocks.33.norm.key_norm.scale",
+  "single_blocks.33.norm.query_norm.scale",
+  "single_blocks.34.linear1.bias",
+  "single_blocks.34.linear1.weight",
+  "single_blocks.34.linear2.bias",
+  "single_blocks.34.linear2.weight",
+  "single_blocks.34.modulation.lin.bias",
+  "single_blocks.34.modulation.lin.weight",
+  "single_blocks.34.norm.key_norm.scale",
+  "single_blocks.34.norm.query_norm.scale",
+  "single_blocks.35.linear1.bias",
+  "single_blocks.35.linear1.weight",
+  "single_blocks.35.linear2.bias",
+  "single_blocks.35.linear2.weight",
+  "single_blocks.35.modulation.lin.bias",
+  "single_blocks.35.modulation.lin.weight",
+  "single_blocks.35.norm.key_norm.scale",
+  "single_blocks.35.norm.query_norm.scale",
+  "single_blocks.36.linear1.bias",
+  "single_blocks.36.linear1.weight",
+  "single_blocks.36.linear2.bias",
+  "single_blocks.36.linear2.weight",
+  "single_blocks.36.modulation.lin.bias",
+  "single_blocks.36.modulation.lin.weight",
+  "single_blocks.36.norm.key_norm.scale",
+  "single_blocks.36.norm.query_norm.scale",
+  "single_blocks.37.linear1.bias",
+  "single_blocks.37.linear1.weight",
+  "single_blocks.37.linear2.bias",
+  "single_blocks.37.linear2.weight",
+  "single_blocks.37.modulation.lin.bias",
+  "single_blocks.37.modulation.lin.weight",
+  "single_blocks.37.norm.key_norm.scale",
+  "single_blocks.37.norm.query_norm.scale",
+  "single_blocks.4.linear1.bias",
+  "single_blocks.4.linear1.weight",
+  "single_blocks.4.linear2.bias",
+  "single_blocks.4.linear2.weight",
+  "single_blocks.4.modulation.lin.bias",
+  "single_blocks.4.modulation.lin.weight",
+  "single_blocks.4.norm.key_norm.scale",
+  "single_blocks.4.norm.query_norm.scale",
+  "single_blocks.5.linear1.bias",
+  "single_blocks.5.linear1.weight",
+  "single_blocks.5.linear2.bias",
+  "single_blocks.5.linear2.weight",
+  "single_blocks.5.modulation.lin.bias",
+  "single_blocks.5.modulation.lin.weight",
+  "single_blocks.5.norm.key_norm.scale",
+  "single_blocks.5.norm.query_norm.scale",
+  "single_blocks.6.linear1.bias",
+  "single_blocks.6.linear1.weight",
+  "single_blocks.6.linear2.bias",
+  "single_blocks.6.linear2.weight",
+  "single_blocks.6.modulation.lin.bias",
+  "single_blocks.6.modulation.lin.weight",
+  "single_blocks.6.norm.key_norm.scale",
+  "single_blocks.6.norm.query_norm.scale",
+  "single_blocks.7.linear1.bias",
+  "single_blocks.7.linear1.weight",
+  "single_blocks.7.linear2.bias",
+  "single_blocks.7.linear2.weight",
+  "single_blocks.7.modulation.lin.bias",
+  "single_blocks.7.modulation.lin.weight",
+  "single_blocks.7.norm.key_norm.scale",
+  "single_blocks.7.norm.query_norm.scale",
+  "single_blocks.8.linear1.bias",
+  "single_blocks.8.linear1.weight",
+  "single_blocks.8.linear2.bias",
+  "single_blocks.8.linear2.weight",
+  "single_blocks.8.modulation.lin.bias",
+  "single_blocks.8.modulation.lin.weight",
+  "single_blocks.8.norm.key_norm.scale",
+  "single_blocks.8.norm.query_norm.scale",
+  "single_blocks.9.linear1.bias",
+  "single_blocks.9.linear1.weight",
+  "single_blocks.9.linear2.bias",
+  "single_blocks.9.linear2.weight",
+  "single_blocks.9.modulation.lin.bias",
+  "single_blocks.9.modulation.lin.weight",
+  "single_blocks.9.norm.key_norm.scale",
+  "single_blocks.9.norm.query_norm.scale",
+  "time_in.in_layer.bias",
+  "time_in.in_layer.weight",
+  "time_in.out_layer.bias",
+  "time_in.out_layer.weight",
+  "txt_in.bias",
+  "txt_in.weight",
+  "vector_in.in_layer.bias",
+  "vector_in.in_layer.weight",
+  "vector_in.out_layer.bias",
+  "vector_in.out_layer.weight",
+  "model.diffusion_model.double_blocks.0.img_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.0.img_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.0.img_attn.proj.bias",
+  "model.diffusion_model.double_blocks.0.img_attn.proj.weight",
+  "model.diffusion_model.double_blocks.0.img_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.0.img_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.0.img_mlp.0.bias",
+  "model.diffusion_model.double_blocks.0.img_mlp.0.weight",
+  "model.diffusion_model.double_blocks.0.img_mlp.2.bias",
+  "model.diffusion_model.double_blocks.0.img_mlp.2.weight",
+  "model.diffusion_model.double_blocks.0.img_mod.lin.bias",
+  "model.diffusion_model.double_blocks.0.img_mod.lin.weight",
+  "model.diffusion_model.double_blocks.0.txt_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.0.txt_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.0.txt_attn.proj.bias",
+  "model.diffusion_model.double_blocks.0.txt_attn.proj.weight",
+  "model.diffusion_model.double_blocks.0.txt_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.0.txt_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.0.txt_mlp.0.bias",
+  "model.diffusion_model.double_blocks.0.txt_mlp.0.weight",
+  "model.diffusion_model.double_blocks.0.txt_mlp.2.bias",
+  "model.diffusion_model.double_blocks.0.txt_mlp.2.weight",
+  "model.diffusion_model.double_blocks.0.txt_mod.lin.bias",
+  "model.diffusion_model.double_blocks.0.txt_mod.lin.weight",
+  "model.diffusion_model.double_blocks.1.img_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.1.img_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.1.img_attn.proj.bias",
+  "model.diffusion_model.double_blocks.1.img_attn.proj.weight",
+  "model.diffusion_model.double_blocks.1.img_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.1.img_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.1.img_mlp.0.bias",
+  "model.diffusion_model.double_blocks.1.img_mlp.0.weight",
+  "model.diffusion_model.double_blocks.1.img_mlp.2.bias",
+  "model.diffusion_model.double_blocks.1.img_mlp.2.weight",
+  "model.diffusion_model.double_blocks.1.img_mod.lin.bias",
+  "model.diffusion_model.double_blocks.1.img_mod.lin.weight",
+  "model.diffusion_model.double_blocks.1.txt_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.1.txt_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.1.txt_attn.proj.bias",
+  "model.diffusion_model.double_blocks.1.txt_attn.proj.weight",
+  "model.diffusion_model.double_blocks.1.txt_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.1.txt_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.1.txt_mlp.0.bias",
+  "model.diffusion_model.double_blocks.1.txt_mlp.0.weight",
+  "model.diffusion_model.double_blocks.1.txt_mlp.2.bias",
+  "model.diffusion_model.double_blocks.1.txt_mlp.2.weight",
+  "model.diffusion_model.double_blocks.1.txt_mod.lin.bias",
+  "model.diffusion_model.double_blocks.1.txt_mod.lin.weight",
+  "model.diffusion_model.double_blocks.10.img_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.10.img_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.10.img_attn.proj.bias",
+  "model.diffusion_model.double_blocks.10.img_attn.proj.weight",
+  "model.diffusion_model.double_blocks.10.img_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.10.img_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.10.img_mlp.0.bias",
+  "model.diffusion_model.double_blocks.10.img_mlp.0.weight",
+  "model.diffusion_model.double_blocks.10.img_mlp.2.bias",
+  "model.diffusion_model.double_blocks.10.img_mlp.2.weight",
+  "model.diffusion_model.double_blocks.10.img_mod.lin.bias",
+  "model.diffusion_model.double_blocks.10.img_mod.lin.weight",
+  "model.diffusion_model.double_blocks.10.txt_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.10.txt_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.10.txt_attn.proj.bias",
+  "model.diffusion_model.double_blocks.10.txt_attn.proj.weight",
+  "model.diffusion_model.double_blocks.10.txt_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.10.txt_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.10.txt_mlp.0.bias",
+  "model.diffusion_model.double_blocks.10.txt_mlp.0.weight",
+  "model.diffusion_model.double_blocks.10.txt_mlp.2.bias",
+  "model.diffusion_model.double_blocks.10.txt_mlp.2.weight",
+  "model.diffusion_model.double_blocks.10.txt_mod.lin.bias",
+  "model.diffusion_model.double_blocks.10.txt_mod.lin.weight",
+  "model.diffusion_model.double_blocks.11.img_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.11.img_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.11.img_attn.proj.bias",
+  "model.diffusion_model.double_blocks.11.img_attn.proj.weight",
+  "model.diffusion_model.double_blocks.11.img_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.11.img_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.11.img_mlp.0.bias",
+  "model.diffusion_model.double_blocks.11.img_mlp.0.weight",
+  "model.diffusion_model.double_blocks.11.img_mlp.2.bias",
+  "model.diffusion_model.double_blocks.11.img_mlp.2.weight",
+  "model.diffusion_model.double_blocks.11.img_mod.lin.bias",
+  "model.diffusion_model.double_blocks.11.img_mod.lin.weight",
+  "model.diffusion_model.double_blocks.11.txt_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.11.txt_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.11.txt_attn.proj.bias",
+  "model.diffusion_model.double_blocks.11.txt_attn.proj.weight",
+  "model.diffusion_model.double_blocks.11.txt_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.11.txt_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.11.txt_mlp.0.bias",
+  "model.diffusion_model.double_blocks.11.txt_mlp.0.weight",
+  "model.diffusion_model.double_blocks.11.txt_mlp.2.bias",
+  "model.diffusion_model.double_blocks.11.txt_mlp.2.weight",
+  "model.diffusion_model.double_blocks.11.txt_mod.lin.bias",
+  "model.diffusion_model.double_blocks.11.txt_mod.lin.weight",
+  "model.diffusion_model.double_blocks.12.img_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.12.img_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.12.img_attn.proj.bias",
+  "model.diffusion_model.double_blocks.12.img_attn.proj.weight",
+  "model.diffusion_model.double_blocks.12.img_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.12.img_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.12.img_mlp.0.bias",
+  "model.diffusion_model.double_blocks.12.img_mlp.0.weight",
+  "model.diffusion_model.double_blocks.12.img_mlp.2.bias",
+  "model.diffusion_model.double_blocks.12.img_mlp.2.weight",
+  "model.diffusion_model.double_blocks.12.img_mod.lin.bias",
+  "model.diffusion_model.double_blocks.12.img_mod.lin.weight",
+  "model.diffusion_model.double_blocks.12.txt_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.12.txt_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.12.txt_attn.proj.bias",
+  "model.diffusion_model.double_blocks.12.txt_attn.proj.weight",
+  "model.diffusion_model.double_blocks.12.txt_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.12.txt_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.12.txt_mlp.0.bias",
+  "model.diffusion_model.double_blocks.12.txt_mlp.0.weight",
+  "model.diffusion_model.double_blocks.12.txt_mlp.2.bias",
+  "model.diffusion_model.double_blocks.12.txt_mlp.2.weight",
+  "model.diffusion_model.double_blocks.12.txt_mod.lin.bias",
+  "model.diffusion_model.double_blocks.12.txt_mod.lin.weight",
+  "model.diffusion_model.double_blocks.13.img_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.13.img_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.13.img_attn.proj.bias",
+  "model.diffusion_model.double_blocks.13.img_attn.proj.weight",
+  "model.diffusion_model.double_blocks.13.img_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.13.img_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.13.img_mlp.0.bias",
+  "model.diffusion_model.double_blocks.13.img_mlp.0.weight",
+  "model.diffusion_model.double_blocks.13.img_mlp.2.bias",
+  "model.diffusion_model.double_blocks.13.img_mlp.2.weight",
+  "model.diffusion_model.double_blocks.13.img_mod.lin.bias",
+  "model.diffusion_model.double_blocks.13.img_mod.lin.weight",
+  "model.diffusion_model.double_blocks.13.txt_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.13.txt_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.13.txt_attn.proj.bias",
+  "model.diffusion_model.double_blocks.13.txt_attn.proj.weight",
+  "model.diffusion_model.double_blocks.13.txt_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.13.txt_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.13.txt_mlp.0.bias",
+  "model.diffusion_model.double_blocks.13.txt_mlp.0.weight",
+  "model.diffusion_model.double_blocks.13.txt_mlp.2.bias",
+  "model.diffusion_model.double_blocks.13.txt_mlp.2.weight",
+  "model.diffusion_model.double_blocks.13.txt_mod.lin.bias",
+  "model.diffusion_model.double_blocks.13.txt_mod.lin.weight",
+  "model.diffusion_model.double_blocks.14.img_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.14.img_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.14.img_attn.proj.bias",
+  "model.diffusion_model.double_blocks.14.img_attn.proj.weight",
+  "model.diffusion_model.double_blocks.14.img_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.14.img_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.14.img_mlp.0.bias",
+  "model.diffusion_model.double_blocks.14.img_mlp.0.weight",
+  "model.diffusion_model.double_blocks.14.img_mlp.2.bias",
+  "model.diffusion_model.double_blocks.14.img_mlp.2.weight",
+  "model.diffusion_model.double_blocks.14.img_mod.lin.bias",
+  "model.diffusion_model.double_blocks.14.img_mod.lin.weight",
+  "model.diffusion_model.double_blocks.14.txt_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.14.txt_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.14.txt_attn.proj.bias",
+  "model.diffusion_model.double_blocks.14.txt_attn.proj.weight",
+  "model.diffusion_model.double_blocks.14.txt_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.14.txt_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.14.txt_mlp.0.bias",
+  "model.diffusion_model.double_blocks.14.txt_mlp.0.weight",
+  "model.diffusion_model.double_blocks.14.txt_mlp.2.bias",
+  "model.diffusion_model.double_blocks.14.txt_mlp.2.weight",
+  "model.diffusion_model.double_blocks.14.txt_mod.lin.bias",
+  "model.diffusion_model.double_blocks.14.txt_mod.lin.weight",
+  "model.diffusion_model.double_blocks.15.img_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.15.img_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.15.img_attn.proj.bias",
+  "model.diffusion_model.double_blocks.15.img_attn.proj.weight",
+  "model.diffusion_model.double_blocks.15.img_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.15.img_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.15.img_mlp.0.bias",
+  "model.diffusion_model.double_blocks.15.img_mlp.0.weight",
+  "model.diffusion_model.double_blocks.15.img_mlp.2.bias",
+  "model.diffusion_model.double_blocks.15.img_mlp.2.weight",
+  "model.diffusion_model.double_blocks.15.img_mod.lin.bias",
+  "model.diffusion_model.double_blocks.15.img_mod.lin.weight",
+  "model.diffusion_model.double_blocks.15.txt_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.15.txt_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.15.txt_attn.proj.bias",
+  "model.diffusion_model.double_blocks.15.txt_attn.proj.weight",
+  "model.diffusion_model.double_blocks.15.txt_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.15.txt_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.15.txt_mlp.0.bias",
+  "model.diffusion_model.double_blocks.15.txt_mlp.0.weight",
+  "model.diffusion_model.double_blocks.15.txt_mlp.2.bias",
+  "model.diffusion_model.double_blocks.15.txt_mlp.2.weight",
+  "model.diffusion_model.double_blocks.15.txt_mod.lin.bias",
+  "model.diffusion_model.double_blocks.15.txt_mod.lin.weight",
+  "model.diffusion_model.double_blocks.16.img_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.16.img_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.16.img_attn.proj.bias",
+  "model.diffusion_model.double_blocks.16.img_attn.proj.weight",
+  "model.diffusion_model.double_blocks.16.img_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.16.img_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.16.img_mlp.0.bias",
+  "model.diffusion_model.double_blocks.16.img_mlp.0.weight",
+  "model.diffusion_model.double_blocks.16.img_mlp.2.bias",
+  "model.diffusion_model.double_blocks.16.img_mlp.2.weight",
+  "model.diffusion_model.double_blocks.16.img_mod.lin.bias",
+  "model.diffusion_model.double_blocks.16.img_mod.lin.weight",
+  "model.diffusion_model.double_blocks.16.txt_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.16.txt_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.16.txt_attn.proj.bias",
+  "model.diffusion_model.double_blocks.16.txt_attn.proj.weight",
+  "model.diffusion_model.double_blocks.16.txt_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.16.txt_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.16.txt_mlp.0.bias",
+  "model.diffusion_model.double_blocks.16.txt_mlp.0.weight",
+  "model.diffusion_model.double_blocks.16.txt_mlp.2.bias",
+  "model.diffusion_model.double_blocks.16.txt_mlp.2.weight",
+  "model.diffusion_model.double_blocks.16.txt_mod.lin.bias",
+  "model.diffusion_model.double_blocks.16.txt_mod.lin.weight",
+  "model.diffusion_model.double_blocks.17.img_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.17.img_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.17.img_attn.proj.bias",
+  "model.diffusion_model.double_blocks.17.img_attn.proj.weight",
+  "model.diffusion_model.double_blocks.17.img_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.17.img_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.17.img_mlp.0.bias",
+  "model.diffusion_model.double_blocks.17.img_mlp.0.weight",
+  "model.diffusion_model.double_blocks.17.img_mlp.2.bias",
+  "model.diffusion_model.double_blocks.17.img_mlp.2.weight",
+  "model.diffusion_model.double_blocks.17.img_mod.lin.bias",
+  "model.diffusion_model.double_blocks.17.img_mod.lin.weight",
+  "model.diffusion_model.double_blocks.17.txt_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.17.txt_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.17.txt_attn.proj.bias",
+  "model.diffusion_model.double_blocks.17.txt_attn.proj.weight",
+  "model.diffusion_model.double_blocks.17.txt_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.17.txt_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.17.txt_mlp.0.bias",
+  "model.diffusion_model.double_blocks.17.txt_mlp.0.weight",
+  "model.diffusion_model.double_blocks.17.txt_mlp.2.bias",
+  "model.diffusion_model.double_blocks.17.txt_mlp.2.weight",
+  "model.diffusion_model.double_blocks.17.txt_mod.lin.bias",
+  "model.diffusion_model.double_blocks.17.txt_mod.lin.weight",
+  "model.diffusion_model.double_blocks.18.img_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.18.img_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.18.img_attn.proj.bias",
+  "model.diffusion_model.double_blocks.18.img_attn.proj.weight",
+  "model.diffusion_model.double_blocks.18.img_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.18.img_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.18.img_mlp.0.bias",
+  "model.diffusion_model.double_blocks.18.img_mlp.0.weight",
+  "model.diffusion_model.double_blocks.18.img_mlp.2.bias",
+  "model.diffusion_model.double_blocks.18.img_mlp.2.weight",
+  "model.diffusion_model.double_blocks.18.img_mod.lin.bias",
+  "model.diffusion_model.double_blocks.18.img_mod.lin.weight",
+  "model.diffusion_model.double_blocks.18.txt_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.18.txt_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.18.txt_attn.proj.bias",
+  "model.diffusion_model.double_blocks.18.txt_attn.proj.weight",
+  "model.diffusion_model.double_blocks.18.txt_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.18.txt_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.18.txt_mlp.0.bias",
+  "model.diffusion_model.double_blocks.18.txt_mlp.0.weight",
+  "model.diffusion_model.double_blocks.18.txt_mlp.2.bias",
+  "model.diffusion_model.double_blocks.18.txt_mlp.2.weight",
+  "model.diffusion_model.double_blocks.18.txt_mod.lin.bias",
+  "model.diffusion_model.double_blocks.18.txt_mod.lin.weight",
+  "model.diffusion_model.double_blocks.2.img_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.2.img_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.2.img_attn.proj.bias",
+  "model.diffusion_model.double_blocks.2.img_attn.proj.weight",
+  "model.diffusion_model.double_blocks.2.img_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.2.img_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.2.img_mlp.0.bias",
+  "model.diffusion_model.double_blocks.2.img_mlp.0.weight",
+  "model.diffusion_model.double_blocks.2.img_mlp.2.bias",
+  "model.diffusion_model.double_blocks.2.img_mlp.2.weight",
+  "model.diffusion_model.double_blocks.2.img_mod.lin.bias",
+  "model.diffusion_model.double_blocks.2.img_mod.lin.weight",
+  "model.diffusion_model.double_blocks.2.txt_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.2.txt_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.2.txt_attn.proj.bias",
+  "model.diffusion_model.double_blocks.2.txt_attn.proj.weight",
+  "model.diffusion_model.double_blocks.2.txt_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.2.txt_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.2.txt_mlp.0.bias",
+  "model.diffusion_model.double_blocks.2.txt_mlp.0.weight",
+  "model.diffusion_model.double_blocks.2.txt_mlp.2.bias",
+  "model.diffusion_model.double_blocks.2.txt_mlp.2.weight",
+  "model.diffusion_model.double_blocks.2.txt_mod.lin.bias",
+  "model.diffusion_model.double_blocks.2.txt_mod.lin.weight",
+  "model.diffusion_model.double_blocks.3.img_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.3.img_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.3.img_attn.proj.bias",
+  "model.diffusion_model.double_blocks.3.img_attn.proj.weight",
+  "model.diffusion_model.double_blocks.3.img_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.3.img_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.3.img_mlp.0.bias",
+  "model.diffusion_model.double_blocks.3.img_mlp.0.weight",
+  "model.diffusion_model.double_blocks.3.img_mlp.2.bias",
+  "model.diffusion_model.double_blocks.3.img_mlp.2.weight",
+  "model.diffusion_model.double_blocks.3.img_mod.lin.bias",
+  "model.diffusion_model.double_blocks.3.img_mod.lin.weight",
+  "model.diffusion_model.double_blocks.3.txt_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.3.txt_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.3.txt_attn.proj.bias",
+  "model.diffusion_model.double_blocks.3.txt_attn.proj.weight",
+  "model.diffusion_model.double_blocks.3.txt_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.3.txt_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.3.txt_mlp.0.bias",
+  "model.diffusion_model.double_blocks.3.txt_mlp.0.weight",
+  "model.diffusion_model.double_blocks.3.txt_mlp.2.bias",
+  "model.diffusion_model.double_blocks.3.txt_mlp.2.weight",
+  "model.diffusion_model.double_blocks.3.txt_mod.lin.bias",
+  "model.diffusion_model.double_blocks.3.txt_mod.lin.weight",
+  "model.diffusion_model.double_blocks.4.img_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.4.img_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.4.img_attn.proj.bias",
+  "model.diffusion_model.double_blocks.4.img_attn.proj.weight",
+  "model.diffusion_model.double_blocks.4.img_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.4.img_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.4.img_mlp.0.bias",
+  "model.diffusion_model.double_blocks.4.img_mlp.0.weight",
+  "model.diffusion_model.double_blocks.4.img_mlp.2.bias",
+  "model.diffusion_model.double_blocks.4.img_mlp.2.weight",
+  "model.diffusion_model.double_blocks.4.img_mod.lin.bias",
+  "model.diffusion_model.double_blocks.4.img_mod.lin.weight",
+  "model.diffusion_model.double_blocks.4.txt_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.4.txt_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.4.txt_attn.proj.bias",
+  "model.diffusion_model.double_blocks.4.txt_attn.proj.weight",
+  "model.diffusion_model.double_blocks.4.txt_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.4.txt_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.4.txt_mlp.0.bias",
+  "model.diffusion_model.double_blocks.4.txt_mlp.0.weight",
+  "model.diffusion_model.double_blocks.4.txt_mlp.2.bias",
+  "model.diffusion_model.double_blocks.4.txt_mlp.2.weight",
+  "model.diffusion_model.double_blocks.4.txt_mod.lin.bias",
+  "model.diffusion_model.double_blocks.4.txt_mod.lin.weight",
+  "model.diffusion_model.double_blocks.5.img_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.5.img_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.5.img_attn.proj.bias",
+  "model.diffusion_model.double_blocks.5.img_attn.proj.weight",
+  "model.diffusion_model.double_blocks.5.img_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.5.img_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.5.img_mlp.0.bias",
+  "model.diffusion_model.double_blocks.5.img_mlp.0.weight",
+  "model.diffusion_model.double_blocks.5.img_mlp.2.bias",
+  "model.diffusion_model.double_blocks.5.img_mlp.2.weight",
+  "model.diffusion_model.double_blocks.5.img_mod.lin.bias",
+  "model.diffusion_model.double_blocks.5.img_mod.lin.weight",
+  "model.diffusion_model.double_blocks.5.txt_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.5.txt_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.5.txt_attn.proj.bias",
+  "model.diffusion_model.double_blocks.5.txt_attn.proj.weight",
+  "model.diffusion_model.double_blocks.5.txt_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.5.txt_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.5.txt_mlp.0.bias",
+  "model.diffusion_model.double_blocks.5.txt_mlp.0.weight",
+  "model.diffusion_model.double_blocks.5.txt_mlp.2.bias",
+  "model.diffusion_model.double_blocks.5.txt_mlp.2.weight",
+  "model.diffusion_model.double_blocks.5.txt_mod.lin.bias",
+  "model.diffusion_model.double_blocks.5.txt_mod.lin.weight",
+  "model.diffusion_model.double_blocks.6.img_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.6.img_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.6.img_attn.proj.bias",
+  "model.diffusion_model.double_blocks.6.img_attn.proj.weight",
+  "model.diffusion_model.double_blocks.6.img_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.6.img_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.6.img_mlp.0.bias",
+  "model.diffusion_model.double_blocks.6.img_mlp.0.weight",
+  "model.diffusion_model.double_blocks.6.img_mlp.2.bias",
+  "model.diffusion_model.double_blocks.6.img_mlp.2.weight",
+  "model.diffusion_model.double_blocks.6.img_mod.lin.bias",
+  "model.diffusion_model.double_blocks.6.img_mod.lin.weight",
+  "model.diffusion_model.double_blocks.6.txt_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.6.txt_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.6.txt_attn.proj.bias",
+  "model.diffusion_model.double_blocks.6.txt_attn.proj.weight",
+  "model.diffusion_model.double_blocks.6.txt_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.6.txt_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.6.txt_mlp.0.bias",
+  "model.diffusion_model.double_blocks.6.txt_mlp.0.weight",
+  "model.diffusion_model.double_blocks.6.txt_mlp.2.bias",
+  "model.diffusion_model.double_blocks.6.txt_mlp.2.weight",
+  "model.diffusion_model.double_blocks.6.txt_mod.lin.bias",
+  "model.diffusion_model.double_blocks.6.txt_mod.lin.weight",
+  "model.diffusion_model.double_blocks.7.img_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.7.img_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.7.img_attn.proj.bias",
+  "model.diffusion_model.double_blocks.7.img_attn.proj.weight",
+  "model.diffusion_model.double_blocks.7.img_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.7.img_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.7.img_mlp.0.bias",
+  "model.diffusion_model.double_blocks.7.img_mlp.0.weight",
+  "model.diffusion_model.double_blocks.7.img_mlp.2.bias",
+  "model.diffusion_model.double_blocks.7.img_mlp.2.weight",
+  "model.diffusion_model.double_blocks.7.img_mod.lin.bias",
+  "model.diffusion_model.double_blocks.7.img_mod.lin.weight",
+  "model.diffusion_model.double_blocks.7.txt_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.7.txt_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.7.txt_attn.proj.bias",
+  "model.diffusion_model.double_blocks.7.txt_attn.proj.weight",
+  "model.diffusion_model.double_blocks.7.txt_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.7.txt_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.7.txt_mlp.0.bias",
+  "model.diffusion_model.double_blocks.7.txt_mlp.0.weight",
+  "model.diffusion_model.double_blocks.7.txt_mlp.2.bias",
+  "model.diffusion_model.double_blocks.7.txt_mlp.2.weight",
+  "model.diffusion_model.double_blocks.7.txt_mod.lin.bias",
+  "model.diffusion_model.double_blocks.7.txt_mod.lin.weight",
+  "model.diffusion_model.double_blocks.8.img_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.8.img_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.8.img_attn.proj.bias",
+  "model.diffusion_model.double_blocks.8.img_attn.proj.weight",
+  "model.diffusion_model.double_blocks.8.img_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.8.img_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.8.img_mlp.0.bias",
+  "model.diffusion_model.double_blocks.8.img_mlp.0.weight",
+  "model.diffusion_model.double_blocks.8.img_mlp.2.bias",
+  "model.diffusion_model.double_blocks.8.img_mlp.2.weight",
+  "model.diffusion_model.double_blocks.8.img_mod.lin.bias",
+  "model.diffusion_model.double_blocks.8.img_mod.lin.weight",
+  "model.diffusion_model.double_blocks.8.txt_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.8.txt_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.8.txt_attn.proj.bias",
+  "model.diffusion_model.double_blocks.8.txt_attn.proj.weight",
+  "model.diffusion_model.double_blocks.8.txt_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.8.txt_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.8.txt_mlp.0.bias",
+  "model.diffusion_model.double_blocks.8.txt_mlp.0.weight",
+  "model.diffusion_model.double_blocks.8.txt_mlp.2.bias",
+  "model.diffusion_model.double_blocks.8.txt_mlp.2.weight",
+  "model.diffusion_model.double_blocks.8.txt_mod.lin.bias",
+  "model.diffusion_model.double_blocks.8.txt_mod.lin.weight",
+  "model.diffusion_model.double_blocks.9.img_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.9.img_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.9.img_attn.proj.bias",
+  "model.diffusion_model.double_blocks.9.img_attn.proj.weight",
+  "model.diffusion_model.double_blocks.9.img_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.9.img_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.9.img_mlp.0.bias",
+  "model.diffusion_model.double_blocks.9.img_mlp.0.weight",
+  "model.diffusion_model.double_blocks.9.img_mlp.2.bias",
+  "model.diffusion_model.double_blocks.9.img_mlp.2.weight",
+  "model.diffusion_model.double_blocks.9.img_mod.lin.bias",
+  "model.diffusion_model.double_blocks.9.img_mod.lin.weight",
+  "model.diffusion_model.double_blocks.9.txt_attn.norm.key_norm.scale",
+  "model.diffusion_model.double_blocks.9.txt_attn.norm.query_norm.scale",
+  "model.diffusion_model.double_blocks.9.txt_attn.proj.bias",
+  "model.diffusion_model.double_blocks.9.txt_attn.proj.weight",
+  "model.diffusion_model.double_blocks.9.txt_attn.qkv.bias",
+  "model.diffusion_model.double_blocks.9.txt_attn.qkv.weight",
+  "model.diffusion_model.double_blocks.9.txt_mlp.0.bias",
+  "model.diffusion_model.double_blocks.9.txt_mlp.0.weight",
+  "model.diffusion_model.double_blocks.9.txt_mlp.2.bias",
+  "model.diffusion_model.double_blocks.9.txt_mlp.2.weight",
+  "model.diffusion_model.double_blocks.9.txt_mod.lin.bias",
+  "model.diffusion_model.double_blocks.9.txt_mod.lin.weight",
+  "model.diffusion_model.final_layer.adaLN_modulation.1.bias",
+  "model.diffusion_model.final_layer.adaLN_modulation.1.weight",
+  "model.diffusion_model.final_layer.linear.bias",
+  "model.diffusion_model.final_layer.linear.weight",
+  "model.diffusion_model.guidance_in.in_layer.bias",
+  "model.diffusion_model.guidance_in.in_layer.weight",
+  "model.diffusion_model.guidance_in.out_layer.bias",
+  "model.diffusion_model.guidance_in.out_layer.weight",
+  "model.diffusion_model.img_in.bias",
+  "model.diffusion_model.img_in.weight",
+  "model.diffusion_model.single_blocks.0.linear1.bias",
+  "model.diffusion_model.single_blocks.0.linear1.weight",
+  "model.diffusion_model.single_blocks.0.linear2.bias",
+  "model.diffusion_model.single_blocks.0.linear2.weight",
+  "model.diffusion_model.single_blocks.0.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.0.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.0.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.0.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.1.linear1.bias",
+  "model.diffusion_model.single_blocks.1.linear1.weight",
+  "model.diffusion_model.single_blocks.1.linear2.bias",
+  "model.diffusion_model.single_blocks.1.linear2.weight",
+  "model.diffusion_model.single_blocks.1.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.1.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.1.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.1.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.10.linear1.bias",
+  "model.diffusion_model.single_blocks.10.linear1.weight",
+  "model.diffusion_model.single_blocks.10.linear2.bias",
+  "model.diffusion_model.single_blocks.10.linear2.weight",
+  "model.diffusion_model.single_blocks.10.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.10.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.10.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.10.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.11.linear1.bias",
+  "model.diffusion_model.single_blocks.11.linear1.weight",
+  "model.diffusion_model.single_blocks.11.linear2.bias",
+  "model.diffusion_model.single_blocks.11.linear2.weight",
+  "model.diffusion_model.single_blocks.11.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.11.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.11.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.11.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.12.linear1.bias",
+  "model.diffusion_model.single_blocks.12.linear1.weight",
+  "model.diffusion_model.single_blocks.12.linear2.bias",
+  "model.diffusion_model.single_blocks.12.linear2.weight",
+  "model.diffusion_model.single_blocks.12.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.12.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.12.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.12.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.13.linear1.bias",
+  "model.diffusion_model.single_blocks.13.linear1.weight",
+  "model.diffusion_model.single_blocks.13.linear2.bias",
+  "model.diffusion_model.single_blocks.13.linear2.weight",
+  "model.diffusion_model.single_blocks.13.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.13.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.13.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.13.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.14.linear1.bias",
+  "model.diffusion_model.single_blocks.14.linear1.weight",
+  "model.diffusion_model.single_blocks.14.linear2.bias",
+  "model.diffusion_model.single_blocks.14.linear2.weight",
+  "model.diffusion_model.single_blocks.14.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.14.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.14.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.14.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.15.linear1.bias",
+  "model.diffusion_model.single_blocks.15.linear1.weight",
+  "model.diffusion_model.single_blocks.15.linear2.bias",
+  "model.diffusion_model.single_blocks.15.linear2.weight",
+  "model.diffusion_model.single_blocks.15.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.15.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.15.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.15.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.16.linear1.bias",
+  "model.diffusion_model.single_blocks.16.linear1.weight",
+  "model.diffusion_model.single_blocks.16.linear2.bias",
+  "model.diffusion_model.single_blocks.16.linear2.weight",
+  "model.diffusion_model.single_blocks.16.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.16.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.16.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.16.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.17.linear1.bias",
+  "model.diffusion_model.single_blocks.17.linear1.weight",
+  "model.diffusion_model.single_blocks.17.linear2.bias",
+  "model.diffusion_model.single_blocks.17.linear2.weight",
+  "model.diffusion_model.single_blocks.17.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.17.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.17.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.17.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.18.linear1.bias",
+  "model.diffusion_model.single_blocks.18.linear1.weight",
+  "model.diffusion_model.single_blocks.18.linear2.bias",
+  "model.diffusion_model.single_blocks.18.linear2.weight",
+  "model.diffusion_model.single_blocks.18.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.18.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.18.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.18.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.19.linear1.bias",
+  "model.diffusion_model.single_blocks.19.linear1.weight",
+  "model.diffusion_model.single_blocks.19.linear2.bias",
+  "model.diffusion_model.single_blocks.19.linear2.weight",
+  "model.diffusion_model.single_blocks.19.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.19.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.19.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.19.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.2.linear1.bias",
+  "model.diffusion_model.single_blocks.2.linear1.weight",
+  "model.diffusion_model.single_blocks.2.linear2.bias",
+  "model.diffusion_model.single_blocks.2.linear2.weight",
+  "model.diffusion_model.single_blocks.2.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.2.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.2.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.2.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.20.linear1.bias",
+  "model.diffusion_model.single_blocks.20.linear1.weight",
+  "model.diffusion_model.single_blocks.20.linear2.bias",
+  "model.diffusion_model.single_blocks.20.linear2.weight",
+  "model.diffusion_model.single_blocks.20.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.20.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.20.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.20.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.21.linear1.bias",
+  "model.diffusion_model.single_blocks.21.linear1.weight",
+  "model.diffusion_model.single_blocks.21.linear2.bias",
+  "model.diffusion_model.single_blocks.21.linear2.weight",
+  "model.diffusion_model.single_blocks.21.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.21.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.21.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.21.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.22.linear1.bias",
+  "model.diffusion_model.single_blocks.22.linear1.weight",
+  "model.diffusion_model.single_blocks.22.linear2.bias",
+  "model.diffusion_model.single_blocks.22.linear2.weight",
+  "model.diffusion_model.single_blocks.22.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.22.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.22.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.22.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.23.linear1.bias",
+  "model.diffusion_model.single_blocks.23.linear1.weight",
+  "model.diffusion_model.single_blocks.23.linear2.bias",
+  "model.diffusion_model.single_blocks.23.linear2.weight",
+  "model.diffusion_model.single_blocks.23.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.23.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.23.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.23.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.24.linear1.bias",
+  "model.diffusion_model.single_blocks.24.linear1.weight",
+  "model.diffusion_model.single_blocks.24.linear2.bias",
+  "model.diffusion_model.single_blocks.24.linear2.weight",
+  "model.diffusion_model.single_blocks.24.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.24.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.24.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.24.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.25.linear1.bias",
+  "model.diffusion_model.single_blocks.25.linear1.weight",
+  "model.diffusion_model.single_blocks.25.linear2.bias",
+  "model.diffusion_model.single_blocks.25.linear2.weight",
+  "model.diffusion_model.single_blocks.25.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.25.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.25.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.25.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.26.linear1.bias",
+  "model.diffusion_model.single_blocks.26.linear1.weight",
+  "model.diffusion_model.single_blocks.26.linear2.bias",
+  "model.diffusion_model.single_blocks.26.linear2.weight",
+  "model.diffusion_model.single_blocks.26.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.26.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.26.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.26.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.27.linear1.bias",
+  "model.diffusion_model.single_blocks.27.linear1.weight",
+  "model.diffusion_model.single_blocks.27.linear2.bias",
+  "model.diffusion_model.single_blocks.27.linear2.weight",
+  "model.diffusion_model.single_blocks.27.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.27.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.27.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.27.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.28.linear1.bias",
+  "model.diffusion_model.single_blocks.28.linear1.weight",
+  "model.diffusion_model.single_blocks.28.linear2.bias",
+  "model.diffusion_model.single_blocks.28.linear2.weight",
+  "model.diffusion_model.single_blocks.28.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.28.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.28.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.28.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.29.linear1.bias",
+  "model.diffusion_model.single_blocks.29.linear1.weight",
+  "model.diffusion_model.single_blocks.29.linear2.bias",
+  "model.diffusion_model.single_blocks.29.linear2.weight",
+  "model.diffusion_model.single_blocks.29.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.29.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.29.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.29.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.3.linear1.bias",
+  "model.diffusion_model.single_blocks.3.linear1.weight",
+  "model.diffusion_model.single_blocks.3.linear2.bias",
+  "model.diffusion_model.single_blocks.3.linear2.weight",
+  "model.diffusion_model.single_blocks.3.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.3.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.3.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.3.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.30.linear1.bias",
+  "model.diffusion_model.single_blocks.30.linear1.weight",
+  "model.diffusion_model.single_blocks.30.linear2.bias",
+  "model.diffusion_model.single_blocks.30.linear2.weight",
+  "model.diffusion_model.single_blocks.30.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.30.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.30.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.30.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.31.linear1.bias",
+  "model.diffusion_model.single_blocks.31.linear1.weight",
+  "model.diffusion_model.single_blocks.31.linear2.bias",
+  "model.diffusion_model.single_blocks.31.linear2.weight",
+  "model.diffusion_model.single_blocks.31.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.31.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.31.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.31.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.32.linear1.bias",
+  "model.diffusion_model.single_blocks.32.linear1.weight",
+  "model.diffusion_model.single_blocks.32.linear2.bias",
+  "model.diffusion_model.single_blocks.32.linear2.weight",
+  "model.diffusion_model.single_blocks.32.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.32.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.32.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.32.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.33.linear1.bias",
+  "model.diffusion_model.single_blocks.33.linear1.weight",
+  "model.diffusion_model.single_blocks.33.linear2.bias",
+  "model.diffusion_model.single_blocks.33.linear2.weight",
+  "model.diffusion_model.single_blocks.33.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.33.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.33.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.33.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.34.linear1.bias",
+  "model.diffusion_model.single_blocks.34.linear1.weight",
+  "model.diffusion_model.single_blocks.34.linear2.bias",
+  "model.diffusion_model.single_blocks.34.linear2.weight",
+  "model.diffusion_model.single_blocks.34.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.34.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.34.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.34.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.35.linear1.bias",
+  "model.diffusion_model.single_blocks.35.linear1.weight",
+  "model.diffusion_model.single_blocks.35.linear2.bias",
+  "model.diffusion_model.single_blocks.35.linear2.weight",
+  "model.diffusion_model.single_blocks.35.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.35.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.35.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.35.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.36.linear1.bias",
+  "model.diffusion_model.single_blocks.36.linear1.weight",
+  "model.diffusion_model.single_blocks.36.linear2.bias",
+  "model.diffusion_model.single_blocks.36.linear2.weight",
+  "model.diffusion_model.single_blocks.36.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.36.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.36.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.36.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.37.linear1.bias",
+  "model.diffusion_model.single_blocks.37.linear1.weight",
+  "model.diffusion_model.single_blocks.37.linear2.bias",
+  "model.diffusion_model.single_blocks.37.linear2.weight",
+  "model.diffusion_model.single_blocks.37.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.37.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.37.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.37.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.4.linear1.bias",
+  "model.diffusion_model.single_blocks.4.linear1.weight",
+  "model.diffusion_model.single_blocks.4.linear2.bias",
+  "model.diffusion_model.single_blocks.4.linear2.weight",
+  "model.diffusion_model.single_blocks.4.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.4.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.4.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.4.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.5.linear1.bias",
+  "model.diffusion_model.single_blocks.5.linear1.weight",
+  "model.diffusion_model.single_blocks.5.linear2.bias",
+  "model.diffusion_model.single_blocks.5.linear2.weight",
+  "model.diffusion_model.single_blocks.5.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.5.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.5.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.5.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.6.linear1.bias",
+  "model.diffusion_model.single_blocks.6.linear1.weight",
+  "model.diffusion_model.single_blocks.6.linear2.bias",
+  "model.diffusion_model.single_blocks.6.linear2.weight",
+  "model.diffusion_model.single_blocks.6.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.6.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.6.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.6.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.7.linear1.bias",
+  "model.diffusion_model.single_blocks.7.linear1.weight",
+  "model.diffusion_model.single_blocks.7.linear2.bias",
+  "model.diffusion_model.single_blocks.7.linear2.weight",
+  "model.diffusion_model.single_blocks.7.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.7.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.7.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.7.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.8.linear1.bias",
+  "model.diffusion_model.single_blocks.8.linear1.weight",
+  "model.diffusion_model.single_blocks.8.linear2.bias",
+  "model.diffusion_model.single_blocks.8.linear2.weight",
+  "model.diffusion_model.single_blocks.8.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.8.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.8.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.8.norm.query_norm.scale",
+  "model.diffusion_model.single_blocks.9.linear1.bias",
+  "model.diffusion_model.single_blocks.9.linear1.weight",
+  "model.diffusion_model.single_blocks.9.linear2.bias",
+  "model.diffusion_model.single_blocks.9.linear2.weight",
+  "model.diffusion_model.single_blocks.9.modulation.lin.bias",
+  "model.diffusion_model.single_blocks.9.modulation.lin.weight",
+  "model.diffusion_model.single_blocks.9.norm.key_norm.scale",
+  "model.diffusion_model.single_blocks.9.norm.query_norm.scale",
+  "model.diffusion_model.time_in.in_layer.bias",
+  "model.diffusion_model.time_in.in_layer.weight",
+  "model.diffusion_model.time_in.out_layer.bias",
+  "model.diffusion_model.time_in.out_layer.weight",
+  "model.diffusion_model.txt_in.bias",
+  "model.diffusion_model.txt_in.weight",
+  "model.diffusion_model.vector_in.in_layer.bias",
+  "model.diffusion_model.vector_in.in_layer.weight",
+  "model.diffusion_model.vector_in.out_layer.bias",
+  "model.diffusion_model.vector_in.out_layer.weight"
+]

flux_vae_keys.json

@@ -0,0 +1,490 @@
+[
+  "decoder.conv_in.bias",
+  "decoder.conv_in.weight",
+  "decoder.conv_out.bias",
+  "decoder.conv_out.weight",
+  "decoder.mid.attn_1.k.bias",
+  "decoder.mid.attn_1.k.weight",
+  "decoder.mid.attn_1.norm.bias",
+  "decoder.mid.attn_1.norm.weight",
+  "decoder.mid.attn_1.proj_out.bias",
+  "decoder.mid.attn_1.proj_out.weight",
+  "decoder.mid.attn_1.q.bias",
+  "decoder.mid.attn_1.q.weight",
+  "decoder.mid.attn_1.v.bias",
+  "decoder.mid.attn_1.v.weight",
+  "decoder.mid.block_1.conv1.bias",
+  "decoder.mid.block_1.conv1.weight",
+  "decoder.mid.block_1.conv2.bias",
+  "decoder.mid.block_1.conv2.weight",
+  "decoder.mid.block_1.norm1.bias",
+  "decoder.mid.block_1.norm1.weight",
+  "decoder.mid.block_1.norm2.bias",
+  "decoder.mid.block_1.norm2.weight",
+  "decoder.mid.block_2.conv1.bias",
+  "decoder.mid.block_2.conv1.weight",
+  "decoder.mid.block_2.conv2.bias",
+  "decoder.mid.block_2.conv2.weight",
+  "decoder.mid.block_2.norm1.bias",
+  "decoder.mid.block_2.norm1.weight",
+  "decoder.mid.block_2.norm2.bias",
+  "decoder.mid.block_2.norm2.weight",
+  "decoder.norm_out.bias",
+  "decoder.norm_out.weight",
+  "decoder.up.0.block.0.conv1.bias",
+  "decoder.up.0.block.0.conv1.weight",
+  "decoder.up.0.block.0.conv2.bias",
+  "decoder.up.0.block.0.conv2.weight",
+  "decoder.up.0.block.0.nin_shortcut.bias",
+  "decoder.up.0.block.0.nin_shortcut.weight",
+  "decoder.up.0.block.0.norm1.bias",
+  "decoder.up.0.block.0.norm1.weight",
+  "decoder.up.0.block.0.norm2.bias",
+  "decoder.up.0.block.0.norm2.weight",
+  "decoder.up.0.block.1.conv1.bias",
+  "decoder.up.0.block.1.conv1.weight",
+  "decoder.up.0.block.1.conv2.bias",
+  "decoder.up.0.block.1.conv2.weight",
+  "decoder.up.0.block.1.norm1.bias",
+  "decoder.up.0.block.1.norm1.weight",
+  "decoder.up.0.block.1.norm2.bias",
+  "decoder.up.0.block.1.norm2.weight",
+  "decoder.up.0.block.2.conv1.bias",
+  "decoder.up.0.block.2.conv1.weight",
+  "decoder.up.0.block.2.conv2.bias",
+  "decoder.up.0.block.2.conv2.weight",
+  "decoder.up.0.block.2.norm1.bias",
+  "decoder.up.0.block.2.norm1.weight",
+  "decoder.up.0.block.2.norm2.bias",
+  "decoder.up.0.block.2.norm2.weight",
+  "decoder.up.1.block.0.conv1.bias",
+  "decoder.up.1.block.0.conv1.weight",
+  "decoder.up.1.block.0.conv2.bias",
+  "decoder.up.1.block.0.conv2.weight",
+  "decoder.up.1.block.0.nin_shortcut.bias",
+  "decoder.up.1.block.0.nin_shortcut.weight",
+  "decoder.up.1.block.0.norm1.bias",
+  "decoder.up.1.block.0.norm1.weight",
+  "decoder.up.1.block.0.norm2.bias",
+  "decoder.up.1.block.0.norm2.weight",
+  "decoder.up.1.block.1.conv1.bias",
+  "decoder.up.1.block.1.conv1.weight",
+  "decoder.up.1.block.1.conv2.bias",
+  "decoder.up.1.block.1.conv2.weight",
+  "decoder.up.1.block.1.norm1.bias",
+  "decoder.up.1.block.1.norm1.weight",
+  "decoder.up.1.block.1.norm2.bias",
+  "decoder.up.1.block.1.norm2.weight",
+  "decoder.up.1.block.2.conv1.bias",
+  "decoder.up.1.block.2.conv1.weight",
+  "decoder.up.1.block.2.conv2.bias",
+  "decoder.up.1.block.2.conv2.weight",
+  "decoder.up.1.block.2.norm1.bias",
+  "decoder.up.1.block.2.norm1.weight",
+  "decoder.up.1.block.2.norm2.bias",
+  "decoder.up.1.block.2.norm2.weight",
+  "decoder.up.1.upsample.conv.bias",
+  "decoder.up.1.upsample.conv.weight",
+  "decoder.up.2.block.0.conv1.bias",
+  "decoder.up.2.block.0.conv1.weight",
+  "decoder.up.2.block.0.conv2.bias",
+  "decoder.up.2.block.0.conv2.weight",
+  "decoder.up.2.block.0.norm1.bias",
+  "decoder.up.2.block.0.norm1.weight",
+  "decoder.up.2.block.0.norm2.bias",
+  "decoder.up.2.block.0.norm2.weight",
+  "decoder.up.2.block.1.conv1.bias",
+  "decoder.up.2.block.1.conv1.weight",
+  "decoder.up.2.block.1.conv2.bias",
+  "decoder.up.2.block.1.conv2.weight",
+  "decoder.up.2.block.1.norm1.bias",
+  "decoder.up.2.block.1.norm1.weight",
+  "decoder.up.2.block.1.norm2.bias",
+  "decoder.up.2.block.1.norm2.weight",
+  "decoder.up.2.block.2.conv1.bias",
+  "decoder.up.2.block.2.conv1.weight",
+  "decoder.up.2.block.2.conv2.bias",
+  "decoder.up.2.block.2.conv2.weight",
+  "decoder.up.2.block.2.norm1.bias",
+  "decoder.up.2.block.2.norm1.weight",
+  "decoder.up.2.block.2.norm2.bias",
+  "decoder.up.2.block.2.norm2.weight",
+  "decoder.up.2.upsample.conv.bias",
+  "decoder.up.2.upsample.conv.weight",
+  "decoder.up.3.block.0.conv1.bias",
+  "decoder.up.3.block.0.conv1.weight",
+  "decoder.up.3.block.0.conv2.bias",
+  "decoder.up.3.block.0.conv2.weight",
+  "decoder.up.3.block.0.norm1.bias",
+  "decoder.up.3.block.0.norm1.weight",
+  "decoder.up.3.block.0.norm2.bias",
+  "decoder.up.3.block.0.norm2.weight",
+  "decoder.up.3.block.1.conv1.bias",
+  "decoder.up.3.block.1.conv1.weight",
+  "decoder.up.3.block.1.conv2.bias",
+  "decoder.up.3.block.1.conv2.weight",
+  "decoder.up.3.block.1.norm1.bias",
+  "decoder.up.3.block.1.norm1.weight",
+  "decoder.up.3.block.1.norm2.bias",
+  "decoder.up.3.block.1.norm2.weight",
+  "decoder.up.3.block.2.conv1.bias",
+  "decoder.up.3.block.2.conv1.weight",
+  "decoder.up.3.block.2.conv2.bias",
+  "decoder.up.3.block.2.conv2.weight",
+  "decoder.up.3.block.2.norm1.bias",
+  "decoder.up.3.block.2.norm1.weight",
+  "decoder.up.3.block.2.norm2.bias",
+  "decoder.up.3.block.2.norm2.weight",
+  "decoder.up.3.upsample.conv.bias",
+  "decoder.up.3.upsample.conv.weight",
+  "encoder.conv_in.bias",
+  "encoder.conv_in.weight",
+  "encoder.conv_out.bias",
+  "encoder.conv_out.weight",
+  "encoder.down.0.block.0.conv1.bias",
+  "encoder.down.0.block.0.conv1.weight",
+  "encoder.down.0.block.0.conv2.bias",
+  "encoder.down.0.block.0.conv2.weight",
+  "encoder.down.0.block.0.norm1.bias",
+  "encoder.down.0.block.0.norm1.weight",
+  "encoder.down.0.block.0.norm2.bias",
+  "encoder.down.0.block.0.norm2.weight",
+  "encoder.down.0.block.1.conv1.bias",
+  "encoder.down.0.block.1.conv1.weight",
+  "encoder.down.0.block.1.conv2.bias",
+  "encoder.down.0.block.1.conv2.weight",
+  "encoder.down.0.block.1.norm1.bias",
+  "encoder.down.0.block.1.norm1.weight",
+  "encoder.down.0.block.1.norm2.bias",
+  "encoder.down.0.block.1.norm2.weight",
+  "encoder.down.0.downsample.conv.bias",
+  "encoder.down.0.downsample.conv.weight",
+  "encoder.down.1.block.0.conv1.bias",
+  "encoder.down.1.block.0.conv1.weight",
+  "encoder.down.1.block.0.conv2.bias",
+  "encoder.down.1.block.0.conv2.weight",
+  "encoder.down.1.block.0.nin_shortcut.bias",
+  "encoder.down.1.block.0.nin_shortcut.weight",
+  "encoder.down.1.block.0.norm1.bias",
+  "encoder.down.1.block.0.norm1.weight",
+  "encoder.down.1.block.0.norm2.bias",
+  "encoder.down.1.block.0.norm2.weight",
+  "encoder.down.1.block.1.conv1.bias",
+  "encoder.down.1.block.1.conv1.weight",
+  "encoder.down.1.block.1.conv2.bias",
+  "encoder.down.1.block.1.conv2.weight",
+  "encoder.down.1.block.1.norm1.bias",
+  "encoder.down.1.block.1.norm1.weight",
+  "encoder.down.1.block.1.norm2.bias",
+  "encoder.down.1.block.1.norm2.weight",
+  "encoder.down.1.downsample.conv.bias",
+  "encoder.down.1.downsample.conv.weight",
+  "encoder.down.2.block.0.conv1.bias",
+  "encoder.down.2.block.0.conv1.weight",
+  "encoder.down.2.block.0.conv2.bias",
+  "encoder.down.2.block.0.conv2.weight",
+  "encoder.down.2.block.0.nin_shortcut.bias",
+  "encoder.down.2.block.0.nin_shortcut.weight",
+  "encoder.down.2.block.0.norm1.bias",
+  "encoder.down.2.block.0.norm1.weight",
+  "encoder.down.2.block.0.norm2.bias",
+  "encoder.down.2.block.0.norm2.weight",
+  "encoder.down.2.block.1.conv1.bias",
+  "encoder.down.2.block.1.conv1.weight",
+  "encoder.down.2.block.1.conv2.bias",
+  "encoder.down.2.block.1.conv2.weight",
+  "encoder.down.2.block.1.norm1.bias",
+  "encoder.down.2.block.1.norm1.weight",
+  "encoder.down.2.block.1.norm2.bias",
+  "encoder.down.2.block.1.norm2.weight",
+  "encoder.down.2.downsample.conv.bias",
+  "encoder.down.2.downsample.conv.weight",
+  "encoder.down.3.block.0.conv1.bias",
+  "encoder.down.3.block.0.conv1.weight",
+  "encoder.down.3.block.0.conv2.bias",
+  "encoder.down.3.block.0.conv2.weight",
+  "encoder.down.3.block.0.norm1.bias",
+  "encoder.down.3.block.0.norm1.weight",
+  "encoder.down.3.block.0.norm2.bias",
+  "encoder.down.3.block.0.norm2.weight",
+  "encoder.down.3.block.1.conv1.bias",
+  "encoder.down.3.block.1.conv1.weight",
+  "encoder.down.3.block.1.conv2.bias",
+  "encoder.down.3.block.1.conv2.weight",
+  "encoder.down.3.block.1.norm1.bias",
+  "encoder.down.3.block.1.norm1.weight",
+  "encoder.down.3.block.1.norm2.bias",
+  "encoder.down.3.block.1.norm2.weight",
+  "encoder.mid.attn_1.k.bias",
+  "encoder.mid.attn_1.k.weight",
+  "encoder.mid.attn_1.norm.bias",
+  "encoder.mid.attn_1.norm.weight",
+  "encoder.mid.attn_1.proj_out.bias",
+  "encoder.mid.attn_1.proj_out.weight",
+  "encoder.mid.attn_1.q.bias",
+  "encoder.mid.attn_1.q.weight",
+  "encoder.mid.attn_1.v.bias",
+  "encoder.mid.attn_1.v.weight",
+  "encoder.mid.block_1.conv1.bias",
+  "encoder.mid.block_1.conv1.weight",
+  "encoder.mid.block_1.conv2.bias",
+  "encoder.mid.block_1.conv2.weight",
+  "encoder.mid.block_1.norm1.bias",
+  "encoder.mid.block_1.norm1.weight",
+  "encoder.mid.block_1.norm2.bias",
+  "encoder.mid.block_1.norm2.weight",
+  "encoder.mid.block_2.conv1.bias",
+  "encoder.mid.block_2.conv1.weight",
+  "encoder.mid.block_2.conv2.bias",
+  "encoder.mid.block_2.conv2.weight",
+  "encoder.mid.block_2.norm1.bias",
+  "encoder.mid.block_2.norm1.weight",
+  "encoder.mid.block_2.norm2.bias",
+  "encoder.mid.block_2.norm2.weight",
+  "encoder.norm_out.bias",
+  "encoder.norm_out.weight",
+  "vae.decoder.conv_in.bias",
+  "vae.decoder.conv_in.weight",
+  "vae.decoder.conv_out.bias",
+  "vae.decoder.conv_out.weight",
+  "vae.decoder.mid.attn_1.k.bias",
+  "vae.decoder.mid.attn_1.k.weight",
+  "vae.decoder.mid.attn_1.norm.bias",
+  "vae.decoder.mid.attn_1.norm.weight",
+  "vae.decoder.mid.attn_1.proj_out.bias",
+  "vae.decoder.mid.attn_1.proj_out.weight",
+  "vae.decoder.mid.attn_1.q.bias",
+  "vae.decoder.mid.attn_1.q.weight",
+  "vae.decoder.mid.attn_1.v.bias",
+  "vae.decoder.mid.attn_1.v.weight",
+  "vae.decoder.mid.block_1.conv1.bias",
+  "vae.decoder.mid.block_1.conv1.weight",
+  "vae.decoder.mid.block_1.conv2.bias",
+  "vae.decoder.mid.block_1.conv2.weight",
+  "vae.decoder.mid.block_1.norm1.bias",
+  "vae.decoder.mid.block_1.norm1.weight",
+  "vae.decoder.mid.block_1.norm2.bias",
+  "vae.decoder.mid.block_1.norm2.weight",
+  "vae.decoder.mid.block_2.conv1.bias",
+  "vae.decoder.mid.block_2.conv1.weight",
+  "vae.decoder.mid.block_2.conv2.bias",
+  "vae.decoder.mid.block_2.conv2.weight",
+  "vae.decoder.mid.block_2.norm1.bias",
+  "vae.decoder.mid.block_2.norm1.weight",
+  "vae.decoder.mid.block_2.norm2.bias",
+  "vae.decoder.mid.block_2.norm2.weight",
+  "vae.decoder.norm_out.bias",
+  "vae.decoder.norm_out.weight",
+  "vae.decoder.up.0.block.0.conv1.bias",
+  "vae.decoder.up.0.block.0.conv1.weight",
+  "vae.decoder.up.0.block.0.conv2.bias",
+  "vae.decoder.up.0.block.0.conv2.weight",
+  "vae.decoder.up.0.block.0.nin_shortcut.bias",
+  "vae.decoder.up.0.block.0.nin_shortcut.weight",
+  "vae.decoder.up.0.block.0.norm1.bias",
+  "vae.decoder.up.0.block.0.norm1.weight",
+  "vae.decoder.up.0.block.0.norm2.bias",
+  "vae.decoder.up.0.block.0.norm2.weight",
+  "vae.decoder.up.0.block.1.conv1.bias",
+  "vae.decoder.up.0.block.1.conv1.weight",
+  "vae.decoder.up.0.block.1.conv2.bias",
+  "vae.decoder.up.0.block.1.conv2.weight",
+  "vae.decoder.up.0.block.1.norm1.bias",
+  "vae.decoder.up.0.block.1.norm1.weight",
+  "vae.decoder.up.0.block.1.norm2.bias",
+  "vae.decoder.up.0.block.1.norm2.weight",
+  "vae.decoder.up.0.block.2.conv1.bias",
+  "vae.decoder.up.0.block.2.conv1.weight",
+  "vae.decoder.up.0.block.2.conv2.bias",
+  "vae.decoder.up.0.block.2.conv2.weight",
+  "vae.decoder.up.0.block.2.norm1.bias",
+  "vae.decoder.up.0.block.2.norm1.weight",
+  "vae.decoder.up.0.block.2.norm2.bias",
+  "vae.decoder.up.0.block.2.norm2.weight",
+  "vae.decoder.up.1.block.0.conv1.bias",
+  "vae.decoder.up.1.block.0.conv1.weight",
+  "vae.decoder.up.1.block.0.conv2.bias",
+  "vae.decoder.up.1.block.0.conv2.weight",
+  "vae.decoder.up.1.block.0.nin_shortcut.bias",
+  "vae.decoder.up.1.block.0.nin_shortcut.weight",
+  "vae.decoder.up.1.block.0.norm1.bias",
+  "vae.decoder.up.1.block.0.norm1.weight",
+  "vae.decoder.up.1.block.0.norm2.bias",
+  "vae.decoder.up.1.block.0.norm2.weight",
+  "vae.decoder.up.1.block.1.conv1.bias",
+  "vae.decoder.up.1.block.1.conv1.weight",
+  "vae.decoder.up.1.block.1.conv2.bias",
+  "vae.decoder.up.1.block.1.conv2.weight",
+  "vae.decoder.up.1.block.1.norm1.bias",
+  "vae.decoder.up.1.block.1.norm1.weight",
+  "vae.decoder.up.1.block.1.norm2.bias",
+  "vae.decoder.up.1.block.1.norm2.weight",
+  "vae.decoder.up.1.block.2.conv1.bias",
+  "vae.decoder.up.1.block.2.conv1.weight",
+  "vae.decoder.up.1.block.2.conv2.bias",
+  "vae.decoder.up.1.block.2.conv2.weight",
+  "vae.decoder.up.1.block.2.norm1.bias",
+  "vae.decoder.up.1.block.2.norm1.weight",
+  "vae.decoder.up.1.block.2.norm2.bias",
+  "vae.decoder.up.1.block.2.norm2.weight",
+  "vae.decoder.up.1.upsample.conv.bias",
+  "vae.decoder.up.1.upsample.conv.weight",
+  "vae.decoder.up.2.block.0.conv1.bias",
+  "vae.decoder.up.2.block.0.conv1.weight",
+  "vae.decoder.up.2.block.0.conv2.bias",
+  "vae.decoder.up.2.block.0.conv2.weight",
+  "vae.decoder.up.2.block.0.norm1.bias",
+  "vae.decoder.up.2.block.0.norm1.weight",
+  "vae.decoder.up.2.block.0.norm2.bias",
+  "vae.decoder.up.2.block.0.norm2.weight",
+  "vae.decoder.up.2.block.1.conv1.bias",
+  "vae.decoder.up.2.block.1.conv1.weight",
+  "vae.decoder.up.2.block.1.conv2.bias",
+  "vae.decoder.up.2.block.1.conv2.weight",
+  "vae.decoder.up.2.block.1.norm1.bias",
+  "vae.decoder.up.2.block.1.norm1.weight",
+  "vae.decoder.up.2.block.1.norm2.bias",
+  "vae.decoder.up.2.block.1.norm2.weight",
+  "vae.decoder.up.2.block.2.conv1.bias",
+  "vae.decoder.up.2.block.2.conv1.weight",
+  "vae.decoder.up.2.block.2.conv2.bias",
+  "vae.decoder.up.2.block.2.conv2.weight",
+  "vae.decoder.up.2.block.2.norm1.bias",
+  "vae.decoder.up.2.block.2.norm1.weight",
+  "vae.decoder.up.2.block.2.norm2.bias",
+  "vae.decoder.up.2.block.2.norm2.weight",
+  "vae.decoder.up.2.upsample.conv.bias",
+  "vae.decoder.up.2.upsample.conv.weight",
+  "vae.decoder.up.3.block.0.conv1.bias",
+  "vae.decoder.up.3.block.0.conv1.weight",
+  "vae.decoder.up.3.block.0.conv2.bias",
+  "vae.decoder.up.3.block.0.conv2.weight",
+  "vae.decoder.up.3.block.0.norm1.bias",
+  "vae.decoder.up.3.block.0.norm1.weight",
+  "vae.decoder.up.3.block.0.norm2.bias",
+  "vae.decoder.up.3.block.0.norm2.weight",
+  "vae.decoder.up.3.block.1.conv1.bias",
+  "vae.decoder.up.3.block.1.conv1.weight",
+  "vae.decoder.up.3.block.1.conv2.bias",
+  "vae.decoder.up.3.block.1.conv2.weight",
+  "vae.decoder.up.3.block.1.norm1.bias",
+  "vae.decoder.up.3.block.1.norm1.weight",
+  "vae.decoder.up.3.block.1.norm2.bias",
+  "vae.decoder.up.3.block.1.norm2.weight",
+  "vae.decoder.up.3.block.2.conv1.bias",
+  "vae.decoder.up.3.block.2.conv1.weight",
+  "vae.decoder.up.3.block.2.conv2.bias",
+  "vae.decoder.up.3.block.2.conv2.weight",
+  "vae.decoder.up.3.block.2.norm1.bias",
+  "vae.decoder.up.3.block.2.norm1.weight",
+  "vae.decoder.up.3.block.2.norm2.bias",
+  "vae.decoder.up.3.block.2.norm2.weight",
+  "vae.decoder.up.3.upsample.conv.bias",
+  "vae.decoder.up.3.upsample.conv.weight",
+  "vae.encoder.conv_in.bias",
+  "vae.encoder.conv_in.weight",
+  "vae.encoder.conv_out.bias",
+  "vae.encoder.conv_out.weight",
+  "vae.encoder.down.0.block.0.conv1.bias",
+  "vae.encoder.down.0.block.0.conv1.weight",
+  "vae.encoder.down.0.block.0.conv2.bias",
+  "vae.encoder.down.0.block.0.conv2.weight",
+  "vae.encoder.down.0.block.0.norm1.bias",
+  "vae.encoder.down.0.block.0.norm1.weight",
+  "vae.encoder.down.0.block.0.norm2.bias",
+  "vae.encoder.down.0.block.0.norm2.weight",
+  "vae.encoder.down.0.block.1.conv1.bias",
+  "vae.encoder.down.0.block.1.conv1.weight",
+  "vae.encoder.down.0.block.1.conv2.bias",
+  "vae.encoder.down.0.block.1.conv2.weight",
+  "vae.encoder.down.0.block.1.norm1.bias",
+  "vae.encoder.down.0.block.1.norm1.weight",
+  "vae.encoder.down.0.block.1.norm2.bias",
+  "vae.encoder.down.0.block.1.norm2.weight",
+  "vae.encoder.down.0.downsample.conv.bias",
+  "vae.encoder.down.0.downsample.conv.weight",
+  "vae.encoder.down.1.block.0.conv1.bias",
+  "vae.encoder.down.1.block.0.conv1.weight",
+  "vae.encoder.down.1.block.0.conv2.bias",
+  "vae.encoder.down.1.block.0.conv2.weight",
+  "vae.encoder.down.1.block.0.nin_shortcut.bias",
+  "vae.encoder.down.1.block.0.nin_shortcut.weight",
+  "vae.encoder.down.1.block.0.norm1.bias",
+  "vae.encoder.down.1.block.0.norm1.weight",
+  "vae.encoder.down.1.block.0.norm2.bias",
+  "vae.encoder.down.1.block.0.norm2.weight",
+  "vae.encoder.down.1.block.1.conv1.bias",
+  "vae.encoder.down.1.block.1.conv1.weight",
+  "vae.encoder.down.1.block.1.conv2.bias",
+  "vae.encoder.down.1.block.1.conv2.weight",
+  "vae.encoder.down.1.block.1.norm1.bias",
+  "vae.encoder.down.1.block.1.norm1.weight",
+  "vae.encoder.down.1.block.1.norm2.bias",
+  "vae.encoder.down.1.block.1.norm2.weight",
+  "vae.encoder.down.1.downsample.conv.bias",
+  "vae.encoder.down.1.downsample.conv.weight",
+  "vae.encoder.down.2.block.0.conv1.bias",
+  "vae.encoder.down.2.block.0.conv1.weight",
+  "vae.encoder.down.2.block.0.conv2.bias",
+  "vae.encoder.down.2.block.0.conv2.weight",
+  "vae.encoder.down.2.block.0.nin_shortcut.bias",
+  "vae.encoder.down.2.block.0.nin_shortcut.weight",
+  "vae.encoder.down.2.block.0.norm1.bias",
+  "vae.encoder.down.2.block.0.norm1.weight",
+  "vae.encoder.down.2.block.0.norm2.bias",
+  "vae.encoder.down.2.block.0.norm2.weight",
+  "vae.encoder.down.2.block.1.conv1.bias",
+  "vae.encoder.down.2.block.1.conv1.weight",
+  "vae.encoder.down.2.block.1.conv2.bias",
+  "vae.encoder.down.2.block.1.conv2.weight",
+  "vae.encoder.down.2.block.1.norm1.bias",
+  "vae.encoder.down.2.block.1.norm1.weight",
+  "vae.encoder.down.2.block.1.norm2.bias",
+  "vae.encoder.down.2.block.1.norm2.weight",
+  "vae.encoder.down.2.downsample.conv.bias",
+  "vae.encoder.down.2.downsample.conv.weight",
+  "vae.encoder.down.3.block.0.conv1.bias",
+  "vae.encoder.down.3.block.0.conv1.weight",
+  "vae.encoder.down.3.block.0.conv2.bias",
+  "vae.encoder.down.3.block.0.conv2.weight",
+  "vae.encoder.down.3.block.0.norm1.bias",
+  "vae.encoder.down.3.block.0.norm1.weight",
+  "vae.encoder.down.3.block.0.norm2.bias",
+  "vae.encoder.down.3.block.0.norm2.weight",
+  "vae.encoder.down.3.block.1.conv1.bias",
+  "vae.encoder.down.3.block.1.conv1.weight",
+  "vae.encoder.down.3.block.1.conv2.bias",
+  "vae.encoder.down.3.block.1.conv2.weight",
+  "vae.encoder.down.3.block.1.norm1.bias",
+  "vae.encoder.down.3.block.1.norm1.weight",
+  "vae.encoder.down.3.block.1.norm2.bias",
+  "vae.encoder.down.3.block.1.norm2.weight",
+  "vae.encoder.mid.attn_1.k.bias",
+  "vae.encoder.mid.attn_1.k.weight",
+  "vae.encoder.mid.attn_1.norm.bias",
+  "vae.encoder.mid.attn_1.norm.weight",
+  "vae.encoder.mid.attn_1.proj_out.bias",
+  "vae.encoder.mid.attn_1.proj_out.weight",
+  "vae.encoder.mid.attn_1.q.bias",
+  "vae.encoder.mid.attn_1.q.weight",
+  "vae.encoder.mid.attn_1.v.bias",
+  "vae.encoder.mid.attn_1.v.weight",
+  "vae.encoder.mid.block_1.conv1.bias",
+  "vae.encoder.mid.block_1.conv1.weight",
+  "vae.encoder.mid.block_1.conv2.bias",
+  "vae.encoder.mid.block_1.conv2.weight",
+  "vae.encoder.mid.block_1.norm1.bias",
+  "vae.encoder.mid.block_1.norm1.weight",
+  "vae.encoder.mid.block_1.norm2.bias",
+  "vae.encoder.mid.block_1.norm2.weight",
+  "vae.encoder.mid.block_2.conv1.bias",
+  "vae.encoder.mid.block_2.conv1.weight",
+  "vae.encoder.mid.block_2.conv2.bias",
+  "vae.encoder.mid.block_2.conv2.weight",
+  "vae.encoder.mid.block_2.norm1.bias",
+  "vae.encoder.mid.block_2.norm1.weight",
+  "vae.encoder.mid.block_2.norm2.bias",
+  "vae.encoder.mid.block_2.norm2.weight",
+  "vae.encoder.norm_out.bias",
+  "vae.encoder.norm_out.weight"
+]

fluxunchainedArtfulNSFW_fuT516xfp8E4m3fnV11_fixed.safetensors.new.txt.txt

@@ -0,0 +1,1442 @@
+double_blocks.0.img_attn.norm.key_norm.scale
+double_blocks.0.img_attn.norm.query_norm.scale
+double_blocks.0.img_attn.proj.bias
+double_blocks.0.img_attn.proj.weight
+double_blocks.0.img_attn.qkv.bias
+double_blocks.0.img_attn.qkv.weight
+double_blocks.0.img_mlp.0.bias
+double_blocks.0.img_mlp.0.weight
+double_blocks.0.img_mlp.2.bias
+double_blocks.0.img_mlp.2.weight
+double_blocks.0.img_mod.lin.bias
+double_blocks.0.img_mod.lin.weight
+double_blocks.0.txt_attn.norm.key_norm.scale
+double_blocks.0.txt_attn.norm.query_norm.scale
+double_blocks.0.txt_attn.proj.bias
+double_blocks.0.txt_attn.proj.weight
+double_blocks.0.txt_attn.qkv.bias
+double_blocks.0.txt_attn.qkv.weight
+double_blocks.0.txt_mlp.0.bias
+double_blocks.0.txt_mlp.0.weight
+double_blocks.0.txt_mlp.2.bias
+double_blocks.0.txt_mlp.2.weight
+double_blocks.0.txt_mod.lin.bias
+double_blocks.0.txt_mod.lin.weight
+double_blocks.1.img_attn.norm.key_norm.scale
+double_blocks.1.img_attn.norm.query_norm.scale
+double_blocks.1.img_attn.proj.bias
+double_blocks.1.img_attn.proj.weight
+double_blocks.1.img_attn.qkv.bias
+double_blocks.1.img_attn.qkv.weight
+double_blocks.1.img_mlp.0.bias
+double_blocks.1.img_mlp.0.weight
+double_blocks.1.img_mlp.2.bias
+double_blocks.1.img_mlp.2.weight
+double_blocks.1.img_mod.lin.bias
+double_blocks.1.img_mod.lin.weight
+double_blocks.1.txt_attn.norm.key_norm.scale
+double_blocks.1.txt_attn.norm.query_norm.scale
+double_blocks.1.txt_attn.proj.bias
+double_blocks.1.txt_attn.proj.weight
+double_blocks.1.txt_attn.qkv.bias
+double_blocks.1.txt_attn.qkv.weight
+double_blocks.1.txt_mlp.0.bias
+double_blocks.1.txt_mlp.0.weight
+double_blocks.1.txt_mlp.2.bias
+double_blocks.1.txt_mlp.2.weight
+double_blocks.1.txt_mod.lin.bias
+double_blocks.1.txt_mod.lin.weight
+double_blocks.10.img_attn.norm.key_norm.scale
+double_blocks.10.img_attn.norm.query_norm.scale
+double_blocks.10.img_attn.proj.bias
+double_blocks.10.img_attn.proj.weight
+double_blocks.10.img_attn.qkv.bias
+double_blocks.10.img_attn.qkv.weight
+double_blocks.10.img_mlp.0.bias
+double_blocks.10.img_mlp.0.weight
+double_blocks.10.img_mlp.2.bias
+double_blocks.10.img_mlp.2.weight
+double_blocks.10.img_mod.lin.bias
+double_blocks.10.img_mod.lin.weight
+double_blocks.10.txt_attn.norm.key_norm.scale
+double_blocks.10.txt_attn.norm.query_norm.scale
+double_blocks.10.txt_attn.proj.bias
+double_blocks.10.txt_attn.proj.weight
+double_blocks.10.txt_attn.qkv.bias
+double_blocks.10.txt_attn.qkv.weight
+double_blocks.10.txt_mlp.0.bias
+double_blocks.10.txt_mlp.0.weight
+double_blocks.10.txt_mlp.2.bias
+double_blocks.10.txt_mlp.2.weight
+double_blocks.10.txt_mod.lin.bias
+double_blocks.10.txt_mod.lin.weight
+double_blocks.11.img_attn.norm.key_norm.scale
+double_blocks.11.img_attn.norm.query_norm.scale
+double_blocks.11.img_attn.proj.bias
+double_blocks.11.img_attn.proj.weight
+double_blocks.11.img_attn.qkv.bias
+double_blocks.11.img_attn.qkv.weight
+double_blocks.11.img_mlp.0.bias
+double_blocks.11.img_mlp.0.weight
+double_blocks.11.img_mlp.2.bias
+double_blocks.11.img_mlp.2.weight
+double_blocks.11.img_mod.lin.bias
+double_blocks.11.img_mod.lin.weight
+double_blocks.11.txt_attn.norm.key_norm.scale
+double_blocks.11.txt_attn.norm.query_norm.scale
+double_blocks.11.txt_attn.proj.bias
+double_blocks.11.txt_attn.proj.weight
+double_blocks.11.txt_attn.qkv.bias
+double_blocks.11.txt_attn.qkv.weight
+double_blocks.11.txt_mlp.0.bias
+double_blocks.11.txt_mlp.0.weight
+double_blocks.11.txt_mlp.2.bias
+double_blocks.11.txt_mlp.2.weight
+double_blocks.11.txt_mod.lin.bias
+double_blocks.11.txt_mod.lin.weight
+double_blocks.12.img_attn.norm.key_norm.scale
+double_blocks.12.img_attn.norm.query_norm.scale
+double_blocks.12.img_attn.proj.bias
+double_blocks.12.img_attn.proj.weight
+double_blocks.12.img_attn.qkv.bias
+double_blocks.12.img_attn.qkv.weight
+double_blocks.12.img_mlp.0.bias
+double_blocks.12.img_mlp.0.weight
+double_blocks.12.img_mlp.2.bias
+double_blocks.12.img_mlp.2.weight
+double_blocks.12.img_mod.lin.bias
+double_blocks.12.img_mod.lin.weight
+double_blocks.12.txt_attn.norm.key_norm.scale
+double_blocks.12.txt_attn.norm.query_norm.scale
+double_blocks.12.txt_attn.proj.bias
+double_blocks.12.txt_attn.proj.weight
+double_blocks.12.txt_attn.qkv.bias
+double_blocks.12.txt_attn.qkv.weight
+double_blocks.12.txt_mlp.0.bias
+double_blocks.12.txt_mlp.0.weight
+double_blocks.12.txt_mlp.2.bias
+double_blocks.12.txt_mlp.2.weight
+double_blocks.12.txt_mod.lin.bias
+double_blocks.12.txt_mod.lin.weight
+double_blocks.13.img_attn.norm.key_norm.scale
+double_blocks.13.img_attn.norm.query_norm.scale
+double_blocks.13.img_attn.proj.bias
+double_blocks.13.img_attn.proj.weight
+double_blocks.13.img_attn.qkv.bias
+double_blocks.13.img_attn.qkv.weight
+double_blocks.13.img_mlp.0.bias
+double_blocks.13.img_mlp.0.weight
+double_blocks.13.img_mlp.2.bias
+double_blocks.13.img_mlp.2.weight
+double_blocks.13.img_mod.lin.bias
+double_blocks.13.img_mod.lin.weight
+double_blocks.13.txt_attn.norm.key_norm.scale
+double_blocks.13.txt_attn.norm.query_norm.scale
+double_blocks.13.txt_attn.proj.bias
+double_blocks.13.txt_attn.proj.weight
+double_blocks.13.txt_attn.qkv.bias
+double_blocks.13.txt_attn.qkv.weight
+double_blocks.13.txt_mlp.0.bias
+double_blocks.13.txt_mlp.0.weight
+double_blocks.13.txt_mlp.2.bias
+double_blocks.13.txt_mlp.2.weight
+double_blocks.13.txt_mod.lin.bias
+double_blocks.13.txt_mod.lin.weight
+double_blocks.14.img_attn.norm.key_norm.scale
+double_blocks.14.img_attn.norm.query_norm.scale
+double_blocks.14.img_attn.proj.bias
+double_blocks.14.img_attn.proj.weight
+double_blocks.14.img_attn.qkv.bias
+double_blocks.14.img_attn.qkv.weight
+double_blocks.14.img_mlp.0.bias
+double_blocks.14.img_mlp.0.weight
+double_blocks.14.img_mlp.2.bias
+double_blocks.14.img_mlp.2.weight
+double_blocks.14.img_mod.lin.bias
+double_blocks.14.img_mod.lin.weight
+double_blocks.14.txt_attn.norm.key_norm.scale
+double_blocks.14.txt_attn.norm.query_norm.scale
+double_blocks.14.txt_attn.proj.bias
+double_blocks.14.txt_attn.proj.weight
+double_blocks.14.txt_attn.qkv.bias
+double_blocks.14.txt_attn.qkv.weight
+double_blocks.14.txt_mlp.0.bias
+double_blocks.14.txt_mlp.0.weight
+double_blocks.14.txt_mlp.2.bias
+double_blocks.14.txt_mlp.2.weight
+double_blocks.14.txt_mod.lin.bias
+double_blocks.14.txt_mod.lin.weight
+double_blocks.15.img_attn.norm.key_norm.scale
+double_blocks.15.img_attn.norm.query_norm.scale
+double_blocks.15.img_attn.proj.bias
+double_blocks.15.img_attn.proj.weight
+double_blocks.15.img_attn.qkv.bias
+double_blocks.15.img_attn.qkv.weight
+double_blocks.15.img_mlp.0.bias
+double_blocks.15.img_mlp.0.weight
+double_blocks.15.img_mlp.2.bias
+double_blocks.15.img_mlp.2.weight
+double_blocks.15.img_mod.lin.bias
+double_blocks.15.img_mod.lin.weight
+double_blocks.15.txt_attn.norm.key_norm.scale
+double_blocks.15.txt_attn.norm.query_norm.scale
+double_blocks.15.txt_attn.proj.bias
+double_blocks.15.txt_attn.proj.weight
+double_blocks.15.txt_attn.qkv.bias
+double_blocks.15.txt_attn.qkv.weight
+double_blocks.15.txt_mlp.0.bias
+double_blocks.15.txt_mlp.0.weight
+double_blocks.15.txt_mlp.2.bias
+double_blocks.15.txt_mlp.2.weight
+double_blocks.15.txt_mod.lin.bias
+double_blocks.15.txt_mod.lin.weight
+double_blocks.16.img_attn.norm.key_norm.scale
+double_blocks.16.img_attn.norm.query_norm.scale
+double_blocks.16.img_attn.proj.bias
+double_blocks.16.img_attn.proj.weight
+double_blocks.16.img_attn.qkv.bias
+double_blocks.16.img_attn.qkv.weight
+double_blocks.16.img_mlp.0.bias
+double_blocks.16.img_mlp.0.weight
+double_blocks.16.img_mlp.2.bias
+double_blocks.16.img_mlp.2.weight
+double_blocks.16.img_mod.lin.bias
+double_blocks.16.img_mod.lin.weight
+double_blocks.16.txt_attn.norm.key_norm.scale
+double_blocks.16.txt_attn.norm.query_norm.scale
+double_blocks.16.txt_attn.proj.bias
+double_blocks.16.txt_attn.proj.weight
+double_blocks.16.txt_attn.qkv.bias
+double_blocks.16.txt_attn.qkv.weight
+double_blocks.16.txt_mlp.0.bias
+double_blocks.16.txt_mlp.0.weight
+double_blocks.16.txt_mlp.2.bias
+double_blocks.16.txt_mlp.2.weight
+double_blocks.16.txt_mod.lin.bias
+double_blocks.16.txt_mod.lin.weight
+double_blocks.17.img_attn.norm.key_norm.scale
+double_blocks.17.img_attn.norm.query_norm.scale
+double_blocks.17.img_attn.proj.bias
+double_blocks.17.img_attn.proj.weight
+double_blocks.17.img_attn.qkv.bias
+double_blocks.17.img_attn.qkv.weight
+double_blocks.17.img_mlp.0.bias
+double_blocks.17.img_mlp.0.weight
+double_blocks.17.img_mlp.2.bias
+double_blocks.17.img_mlp.2.weight
+double_blocks.17.img_mod.lin.bias
+double_blocks.17.img_mod.lin.weight
+double_blocks.17.txt_attn.norm.key_norm.scale
+double_blocks.17.txt_attn.norm.query_norm.scale
+double_blocks.17.txt_attn.proj.bias
+double_blocks.17.txt_attn.proj.weight
+double_blocks.17.txt_attn.qkv.bias
+double_blocks.17.txt_attn.qkv.weight
+double_blocks.17.txt_mlp.0.bias
+double_blocks.17.txt_mlp.0.weight
+double_blocks.17.txt_mlp.2.bias
+double_blocks.17.txt_mlp.2.weight
+double_blocks.17.txt_mod.lin.bias
+double_blocks.17.txt_mod.lin.weight
+double_blocks.18.img_attn.norm.key_norm.scale
+double_blocks.18.img_attn.norm.query_norm.scale
+double_blocks.18.img_attn.proj.bias
+double_blocks.18.img_attn.proj.weight
+double_blocks.18.img_attn.qkv.bias
+double_blocks.18.img_attn.qkv.weight
+double_blocks.18.img_mlp.0.bias
+double_blocks.18.img_mlp.0.weight
+double_blocks.18.img_mlp.2.bias
+double_blocks.18.img_mlp.2.weight
+double_blocks.18.img_mod.lin.bias
+double_blocks.18.img_mod.lin.weight
+double_blocks.18.txt_attn.norm.key_norm.scale
+double_blocks.18.txt_attn.norm.query_norm.scale
+double_blocks.18.txt_attn.proj.bias
+double_blocks.18.txt_attn.proj.weight
+double_blocks.18.txt_attn.qkv.bias
+double_blocks.18.txt_attn.qkv.weight
+double_blocks.18.txt_mlp.0.bias
+double_blocks.18.txt_mlp.0.weight
+double_blocks.18.txt_mlp.2.bias
+double_blocks.18.txt_mlp.2.weight
+double_blocks.18.txt_mod.lin.bias
+double_blocks.18.txt_mod.lin.weight
+double_blocks.2.img_attn.norm.key_norm.scale
+double_blocks.2.img_attn.norm.query_norm.scale
+double_blocks.2.img_attn.proj.bias
+double_blocks.2.img_attn.proj.weight
+double_blocks.2.img_attn.qkv.bias
+double_blocks.2.img_attn.qkv.weight
+double_blocks.2.img_mlp.0.bias
+double_blocks.2.img_mlp.0.weight
+double_blocks.2.img_mlp.2.bias
+double_blocks.2.img_mlp.2.weight
+double_blocks.2.img_mod.lin.bias
+double_blocks.2.img_mod.lin.weight
+double_blocks.2.txt_attn.norm.key_norm.scale
+double_blocks.2.txt_attn.norm.query_norm.scale
+double_blocks.2.txt_attn.proj.bias
+double_blocks.2.txt_attn.proj.weight
+double_blocks.2.txt_attn.qkv.bias
+double_blocks.2.txt_attn.qkv.weight
+double_blocks.2.txt_mlp.0.bias
+double_blocks.2.txt_mlp.0.weight
+double_blocks.2.txt_mlp.2.bias
+double_blocks.2.txt_mlp.2.weight
+double_blocks.2.txt_mod.lin.bias
+double_blocks.2.txt_mod.lin.weight
+double_blocks.3.img_attn.norm.key_norm.scale
+double_blocks.3.img_attn.norm.query_norm.scale
+double_blocks.3.img_attn.proj.bias
+double_blocks.3.img_attn.proj.weight
+double_blocks.3.img_attn.qkv.bias
+double_blocks.3.img_attn.qkv.weight
+double_blocks.3.img_mlp.0.bias
+double_blocks.3.img_mlp.0.weight
+double_blocks.3.img_mlp.2.bias
+double_blocks.3.img_mlp.2.weight
+double_blocks.3.img_mod.lin.bias
+double_blocks.3.img_mod.lin.weight
+double_blocks.3.txt_attn.norm.key_norm.scale
+double_blocks.3.txt_attn.norm.query_norm.scale
+double_blocks.3.txt_attn.proj.bias
+double_blocks.3.txt_attn.proj.weight
+double_blocks.3.txt_attn.qkv.bias
+double_blocks.3.txt_attn.qkv.weight
+double_blocks.3.txt_mlp.0.bias
+double_blocks.3.txt_mlp.0.weight
+double_blocks.3.txt_mlp.2.bias
+double_blocks.3.txt_mlp.2.weight
+double_blocks.3.txt_mod.lin.bias
+double_blocks.3.txt_mod.lin.weight
+double_blocks.4.img_attn.norm.key_norm.scale
+double_blocks.4.img_attn.norm.query_norm.scale
+double_blocks.4.img_attn.proj.bias
+double_blocks.4.img_attn.proj.weight
+double_blocks.4.img_attn.qkv.bias
+double_blocks.4.img_attn.qkv.weight
+double_blocks.4.img_mlp.0.bias
+double_blocks.4.img_mlp.0.weight
+double_blocks.4.img_mlp.2.bias
+double_blocks.4.img_mlp.2.weight
+double_blocks.4.img_mod.lin.bias
+double_blocks.4.img_mod.lin.weight
+double_blocks.4.txt_attn.norm.key_norm.scale
+double_blocks.4.txt_attn.norm.query_norm.scale
+double_blocks.4.txt_attn.proj.bias
+double_blocks.4.txt_attn.proj.weight
+double_blocks.4.txt_attn.qkv.bias
+double_blocks.4.txt_attn.qkv.weight
+double_blocks.4.txt_mlp.0.bias
+double_blocks.4.txt_mlp.0.weight
+double_blocks.4.txt_mlp.2.bias
+double_blocks.4.txt_mlp.2.weight
+double_blocks.4.txt_mod.lin.bias
+double_blocks.4.txt_mod.lin.weight
+double_blocks.5.img_attn.norm.key_norm.scale
+double_blocks.5.img_attn.norm.query_norm.scale
+double_blocks.5.img_attn.proj.bias
+double_blocks.5.img_attn.proj.weight
+double_blocks.5.img_attn.qkv.bias
+double_blocks.5.img_attn.qkv.weight
+double_blocks.5.img_mlp.0.bias
+double_blocks.5.img_mlp.0.weight
+double_blocks.5.img_mlp.2.bias
+double_blocks.5.img_mlp.2.weight
+double_blocks.5.img_mod.lin.bias
+double_blocks.5.img_mod.lin.weight
+double_blocks.5.txt_attn.norm.key_norm.scale
+double_blocks.5.txt_attn.norm.query_norm.scale
+double_blocks.5.txt_attn.proj.bias
+double_blocks.5.txt_attn.proj.weight
+double_blocks.5.txt_attn.qkv.bias
+double_blocks.5.txt_attn.qkv.weight
+double_blocks.5.txt_mlp.0.bias
+double_blocks.5.txt_mlp.0.weight
+double_blocks.5.txt_mlp.2.bias
+double_blocks.5.txt_mlp.2.weight
+double_blocks.5.txt_mod.lin.bias
+double_blocks.5.txt_mod.lin.weight
+double_blocks.6.img_attn.norm.key_norm.scale
+double_blocks.6.img_attn.norm.query_norm.scale
+double_blocks.6.img_attn.proj.bias
+double_blocks.6.img_attn.proj.weight
+double_blocks.6.img_attn.qkv.bias
+double_blocks.6.img_attn.qkv.weight
+double_blocks.6.img_mlp.0.bias
+double_blocks.6.img_mlp.0.weight
+double_blocks.6.img_mlp.2.bias
+double_blocks.6.img_mlp.2.weight
+double_blocks.6.img_mod.lin.bias
+double_blocks.6.img_mod.lin.weight
+double_blocks.6.txt_attn.norm.key_norm.scale
+double_blocks.6.txt_attn.norm.query_norm.scale
+double_blocks.6.txt_attn.proj.bias
+double_blocks.6.txt_attn.proj.weight
+double_blocks.6.txt_attn.qkv.bias
+double_blocks.6.txt_attn.qkv.weight
+double_blocks.6.txt_mlp.0.bias
+double_blocks.6.txt_mlp.0.weight
+double_blocks.6.txt_mlp.2.bias
+double_blocks.6.txt_mlp.2.weight
+double_blocks.6.txt_mod.lin.bias
+double_blocks.6.txt_mod.lin.weight
+double_blocks.7.img_attn.norm.key_norm.scale
+double_blocks.7.img_attn.norm.query_norm.scale
+double_blocks.7.img_attn.proj.bias
+double_blocks.7.img_attn.proj.weight
+double_blocks.7.img_attn.qkv.bias
+double_blocks.7.img_attn.qkv.weight
+double_blocks.7.img_mlp.0.bias
+double_blocks.7.img_mlp.0.weight
+double_blocks.7.img_mlp.2.bias
+double_blocks.7.img_mlp.2.weight
+double_blocks.7.img_mod.lin.bias
+double_blocks.7.img_mod.lin.weight
+double_blocks.7.txt_attn.norm.key_norm.scale
+double_blocks.7.txt_attn.norm.query_norm.scale
+double_blocks.7.txt_attn.proj.bias
+double_blocks.7.txt_attn.proj.weight
+double_blocks.7.txt_attn.qkv.bias
+double_blocks.7.txt_attn.qkv.weight
+double_blocks.7.txt_mlp.0.bias
+double_blocks.7.txt_mlp.0.weight
+double_blocks.7.txt_mlp.2.bias
+double_blocks.7.txt_mlp.2.weight
+double_blocks.7.txt_mod.lin.bias
+double_blocks.7.txt_mod.lin.weight
+double_blocks.8.img_attn.norm.key_norm.scale
+double_blocks.8.img_attn.norm.query_norm.scale
+double_blocks.8.img_attn.proj.bias
+double_blocks.8.img_attn.proj.weight
+double_blocks.8.img_attn.qkv.bias
+double_blocks.8.img_attn.qkv.weight
+double_blocks.8.img_mlp.0.bias
+double_blocks.8.img_mlp.0.weight
+double_blocks.8.img_mlp.2.bias
+double_blocks.8.img_mlp.2.weight
+double_blocks.8.img_mod.lin.bias
+double_blocks.8.img_mod.lin.weight
+double_blocks.8.txt_attn.norm.key_norm.scale
+double_blocks.8.txt_attn.norm.query_norm.scale
+double_blocks.8.txt_attn.proj.bias
+double_blocks.8.txt_attn.proj.weight
+double_blocks.8.txt_attn.qkv.bias
+double_blocks.8.txt_attn.qkv.weight
+double_blocks.8.txt_mlp.0.bias
+double_blocks.8.txt_mlp.0.weight
+double_blocks.8.txt_mlp.2.bias
+double_blocks.8.txt_mlp.2.weight
+double_blocks.8.txt_mod.lin.bias
+double_blocks.8.txt_mod.lin.weight
+double_blocks.9.img_attn.norm.key_norm.scale
+double_blocks.9.img_attn.norm.query_norm.scale
+double_blocks.9.img_attn.proj.bias
+double_blocks.9.img_attn.proj.weight
+double_blocks.9.img_attn.qkv.bias
+double_blocks.9.img_attn.qkv.weight
+double_blocks.9.img_mlp.0.bias
+double_blocks.9.img_mlp.0.weight
+double_blocks.9.img_mlp.2.bias
+double_blocks.9.img_mlp.2.weight
+double_blocks.9.img_mod.lin.bias
+double_blocks.9.img_mod.lin.weight
+double_blocks.9.txt_attn.norm.key_norm.scale
+double_blocks.9.txt_attn.norm.query_norm.scale
+double_blocks.9.txt_attn.proj.bias
+double_blocks.9.txt_attn.proj.weight
+double_blocks.9.txt_attn.qkv.bias
+double_blocks.9.txt_attn.qkv.weight
+double_blocks.9.txt_mlp.0.bias
+double_blocks.9.txt_mlp.0.weight
+double_blocks.9.txt_mlp.2.bias
+double_blocks.9.txt_mlp.2.weight
+double_blocks.9.txt_mod.lin.bias
+double_blocks.9.txt_mod.lin.weight
+final_layer.adaLN_modulation.1.bias
+final_layer.adaLN_modulation.1.weight
+final_layer.linear.bias
+final_layer.linear.weight
+guidance_in.in_layer.bias
+guidance_in.in_layer.weight
+guidance_in.out_layer.bias
+guidance_in.out_layer.weight
+img_in.bias
+img_in.weight
+single_blocks.0.linear1.bias
+single_blocks.0.linear1.weight
+single_blocks.0.linear2.bias
+single_blocks.0.linear2.weight
+single_blocks.0.modulation.lin.bias
+single_blocks.0.modulation.lin.weight
+single_blocks.0.norm.key_norm.scale
+single_blocks.0.norm.query_norm.scale
+single_blocks.1.linear1.bias
+single_blocks.1.linear1.weight
+single_blocks.1.linear2.bias
+single_blocks.1.linear2.weight
+single_blocks.1.modulation.lin.bias
+single_blocks.1.modulation.lin.weight
+single_blocks.1.norm.key_norm.scale
+single_blocks.1.norm.query_norm.scale
+single_blocks.10.linear1.bias
+single_blocks.10.linear1.weight
+single_blocks.10.linear2.bias
+single_blocks.10.linear2.weight
+single_blocks.10.modulation.lin.bias
+single_blocks.10.modulation.lin.weight
+single_blocks.10.norm.key_norm.scale
+single_blocks.10.norm.query_norm.scale
+single_blocks.11.linear1.bias
+single_blocks.11.linear1.weight
+single_blocks.11.linear2.bias
+single_blocks.11.linear2.weight
+single_blocks.11.modulation.lin.bias
+single_blocks.11.modulation.lin.weight
+single_blocks.11.norm.key_norm.scale
+single_blocks.11.norm.query_norm.scale
+single_blocks.12.linear1.bias
+single_blocks.12.linear1.weight
+single_blocks.12.linear2.bias
+single_blocks.12.linear2.weight
+single_blocks.12.modulation.lin.bias
+single_blocks.12.modulation.lin.weight
+single_blocks.12.norm.key_norm.scale
+single_blocks.12.norm.query_norm.scale
+single_blocks.13.linear1.bias
+single_blocks.13.linear1.weight
+single_blocks.13.linear2.bias
+single_blocks.13.linear2.weight
+single_blocks.13.modulation.lin.bias
+single_blocks.13.modulation.lin.weight
+single_blocks.13.norm.key_norm.scale
+single_blocks.13.norm.query_norm.scale
+single_blocks.14.linear1.bias
+single_blocks.14.linear1.weight
+single_blocks.14.linear2.bias
+single_blocks.14.linear2.weight
+single_blocks.14.modulation.lin.bias
+single_blocks.14.modulation.lin.weight
+single_blocks.14.norm.key_norm.scale
+single_blocks.14.norm.query_norm.scale
+single_blocks.15.linear1.bias
+single_blocks.15.linear1.weight
+single_blocks.15.linear2.bias
+single_blocks.15.linear2.weight
+single_blocks.15.modulation.lin.bias
+single_blocks.15.modulation.lin.weight
+single_blocks.15.norm.key_norm.scale
+single_blocks.15.norm.query_norm.scale
+single_blocks.16.linear1.bias
+single_blocks.16.linear1.weight
+single_blocks.16.linear2.bias
+single_blocks.16.linear2.weight
+single_blocks.16.modulation.lin.bias
+single_blocks.16.modulation.lin.weight
+single_blocks.16.norm.key_norm.scale
+single_blocks.16.norm.query_norm.scale
+single_blocks.17.linear1.bias
+single_blocks.17.linear1.weight
+single_blocks.17.linear2.bias
+single_blocks.17.linear2.weight
+single_blocks.17.modulation.lin.bias
+single_blocks.17.modulation.lin.weight
+single_blocks.17.norm.key_norm.scale
+single_blocks.17.norm.query_norm.scale
+single_blocks.18.linear1.bias
+single_blocks.18.linear1.weight
+single_blocks.18.linear2.bias
+single_blocks.18.linear2.weight
+single_blocks.18.modulation.lin.bias
+single_blocks.18.modulation.lin.weight
+single_blocks.18.norm.key_norm.scale
+single_blocks.18.norm.query_norm.scale
+single_blocks.19.linear1.bias
+single_blocks.19.linear1.weight
+single_blocks.19.linear2.bias
+single_blocks.19.linear2.weight
+single_blocks.19.modulation.lin.bias
+single_blocks.19.modulation.lin.weight
+single_blocks.19.norm.key_norm.scale
+single_blocks.19.norm.query_norm.scale
+single_blocks.2.linear1.bias
+single_blocks.2.linear1.weight
+single_blocks.2.linear2.bias
+single_blocks.2.linear2.weight
+single_blocks.2.modulation.lin.bias
+single_blocks.2.modulation.lin.weight
+single_blocks.2.norm.key_norm.scale
+single_blocks.2.norm.query_norm.scale
+single_blocks.20.linear1.bias
+single_blocks.20.linear1.weight
+single_blocks.20.linear2.bias
+single_blocks.20.linear2.weight
+single_blocks.20.modulation.lin.bias
+single_blocks.20.modulation.lin.weight
+single_blocks.20.norm.key_norm.scale
+single_blocks.20.norm.query_norm.scale
+single_blocks.21.linear1.bias
+single_blocks.21.linear1.weight
+single_blocks.21.linear2.bias
+single_blocks.21.linear2.weight
+single_blocks.21.modulation.lin.bias
+single_blocks.21.modulation.lin.weight
+single_blocks.21.norm.key_norm.scale
+single_blocks.21.norm.query_norm.scale
+single_blocks.22.linear1.bias
+single_blocks.22.linear1.weight
+single_blocks.22.linear2.bias
+single_blocks.22.linear2.weight
+single_blocks.22.modulation.lin.bias
+single_blocks.22.modulation.lin.weight
+single_blocks.22.norm.key_norm.scale
+single_blocks.22.norm.query_norm.scale
+single_blocks.23.linear1.bias
+single_blocks.23.linear1.weight
+single_blocks.23.linear2.bias
+single_blocks.23.linear2.weight
+single_blocks.23.modulation.lin.bias
+single_blocks.23.modulation.lin.weight
+single_blocks.23.norm.key_norm.scale
+single_blocks.23.norm.query_norm.scale
+single_blocks.24.linear1.bias
+single_blocks.24.linear1.weight
+single_blocks.24.linear2.bias
+single_blocks.24.linear2.weight
+single_blocks.24.modulation.lin.bias
+single_blocks.24.modulation.lin.weight
+single_blocks.24.norm.key_norm.scale
+single_blocks.24.norm.query_norm.scale
+single_blocks.25.linear1.bias
+single_blocks.25.linear1.weight
+single_blocks.25.linear2.bias
+single_blocks.25.linear2.weight
+single_blocks.25.modulation.lin.bias
+single_blocks.25.modulation.lin.weight
+single_blocks.25.norm.key_norm.scale
+single_blocks.25.norm.query_norm.scale
+single_blocks.26.linear1.bias
+single_blocks.26.linear1.weight
+single_blocks.26.linear2.bias
+single_blocks.26.linear2.weight
+single_blocks.26.modulation.lin.bias
+single_blocks.26.modulation.lin.weight
+single_blocks.26.norm.key_norm.scale
+single_blocks.26.norm.query_norm.scale
+single_blocks.27.linear1.bias
+single_blocks.27.linear1.weight
+single_blocks.27.linear2.bias
+single_blocks.27.linear2.weight
+single_blocks.27.modulation.lin.bias
+single_blocks.27.modulation.lin.weight
+single_blocks.27.norm.key_norm.scale
+single_blocks.27.norm.query_norm.scale
+single_blocks.28.linear1.bias
+single_blocks.28.linear1.weight
+single_blocks.28.linear2.bias
+single_blocks.28.linear2.weight
+single_blocks.28.modulation.lin.bias
+single_blocks.28.modulation.lin.weight
+single_blocks.28.norm.key_norm.scale
+single_blocks.28.norm.query_norm.scale
+single_blocks.29.linear1.bias
+single_blocks.29.linear1.weight
+single_blocks.29.linear2.bias
+single_blocks.29.linear2.weight
+single_blocks.29.modulation.lin.bias
+single_blocks.29.modulation.lin.weight
+single_blocks.29.norm.key_norm.scale
+single_blocks.29.norm.query_norm.scale
+single_blocks.3.linear1.bias
+single_blocks.3.linear1.weight
+single_blocks.3.linear2.bias
+single_blocks.3.linear2.weight
+single_blocks.3.modulation.lin.bias
+single_blocks.3.modulation.lin.weight
+single_blocks.3.norm.key_norm.scale
+single_blocks.3.norm.query_norm.scale
+single_blocks.30.linear1.bias
+single_blocks.30.linear1.weight
+single_blocks.30.linear2.bias
+single_blocks.30.linear2.weight
+single_blocks.30.modulation.lin.bias
+single_blocks.30.modulation.lin.weight
+single_blocks.30.norm.key_norm.scale
+single_blocks.30.norm.query_norm.scale
+single_blocks.31.linear1.bias
+single_blocks.31.linear1.weight
+single_blocks.31.linear2.bias
+single_blocks.31.linear2.weight
+single_blocks.31.modulation.lin.bias
+single_blocks.31.modulation.lin.weight
+single_blocks.31.norm.key_norm.scale
+single_blocks.31.norm.query_norm.scale
+single_blocks.32.linear1.bias
+single_blocks.32.linear1.weight
+single_blocks.32.linear2.bias
+single_blocks.32.linear2.weight
+single_blocks.32.modulation.lin.bias
+single_blocks.32.modulation.lin.weight
+single_blocks.32.norm.key_norm.scale
+single_blocks.32.norm.query_norm.scale
+single_blocks.33.linear1.bias
+single_blocks.33.linear1.weight
+single_blocks.33.linear2.bias
+single_blocks.33.linear2.weight
+single_blocks.33.modulation.lin.bias
+single_blocks.33.modulation.lin.weight
+single_blocks.33.norm.key_norm.scale
+single_blocks.33.norm.query_norm.scale
+single_blocks.34.linear1.bias
+single_blocks.34.linear1.weight
+single_blocks.34.linear2.bias
+single_blocks.34.linear2.weight
+single_blocks.34.modulation.lin.bias
+single_blocks.34.modulation.lin.weight
+single_blocks.34.norm.key_norm.scale
+single_blocks.34.norm.query_norm.scale
+single_blocks.35.linear1.bias
+single_blocks.35.linear1.weight
+single_blocks.35.linear2.bias
+single_blocks.35.linear2.weight
+single_blocks.35.modulation.lin.bias
+single_blocks.35.modulation.lin.weight
+single_blocks.35.norm.key_norm.scale
+single_blocks.35.norm.query_norm.scale
+single_blocks.36.linear1.bias
+single_blocks.36.linear1.weight
+single_blocks.36.linear2.bias
+single_blocks.36.linear2.weight
+single_blocks.36.modulation.lin.bias
+single_blocks.36.modulation.lin.weight
+single_blocks.36.norm.key_norm.scale
+single_blocks.36.norm.query_norm.scale
+single_blocks.37.linear1.bias
+single_blocks.37.linear1.weight
+single_blocks.37.linear2.bias
+single_blocks.37.linear2.weight
+single_blocks.37.modulation.lin.bias
+single_blocks.37.modulation.lin.weight
+single_blocks.37.norm.key_norm.scale
+single_blocks.37.norm.query_norm.scale
+single_blocks.4.linear1.bias
+single_blocks.4.linear1.weight
+single_blocks.4.linear2.bias
+single_blocks.4.linear2.weight
+single_blocks.4.modulation.lin.bias
+single_blocks.4.modulation.lin.weight
+single_blocks.4.norm.key_norm.scale
+single_blocks.4.norm.query_norm.scale
+single_blocks.5.linear1.bias
+single_blocks.5.linear1.weight
+single_blocks.5.linear2.bias
+single_blocks.5.linear2.weight
+single_blocks.5.modulation.lin.bias
+single_blocks.5.modulation.lin.weight
+single_blocks.5.norm.key_norm.scale
+single_blocks.5.norm.query_norm.scale
+single_blocks.6.linear1.bias
+single_blocks.6.linear1.weight
+single_blocks.6.linear2.bias
+single_blocks.6.linear2.weight
+single_blocks.6.modulation.lin.bias
+single_blocks.6.modulation.lin.weight
+single_blocks.6.norm.key_norm.scale
+single_blocks.6.norm.query_norm.scale
+single_blocks.7.linear1.bias
+single_blocks.7.linear1.weight
+single_blocks.7.linear2.bias
+single_blocks.7.linear2.weight
+single_blocks.7.modulation.lin.bias
+single_blocks.7.modulation.lin.weight
+single_blocks.7.norm.key_norm.scale
+single_blocks.7.norm.query_norm.scale
+single_blocks.8.linear1.bias
+single_blocks.8.linear1.weight
+single_blocks.8.linear2.bias
+single_blocks.8.linear2.weight
+single_blocks.8.modulation.lin.bias
+single_blocks.8.modulation.lin.weight
+single_blocks.8.norm.key_norm.scale
+single_blocks.8.norm.query_norm.scale
+single_blocks.9.linear1.bias
+single_blocks.9.linear1.weight
+single_blocks.9.linear2.bias
+single_blocks.9.linear2.weight
+single_blocks.9.modulation.lin.bias
+single_blocks.9.modulation.lin.weight
+single_blocks.9.norm.key_norm.scale
+single_blocks.9.norm.query_norm.scale
+time_in.in_layer.bias
+time_in.in_layer.weight
+time_in.out_layer.bias
+time_in.out_layer.weight
+txt_in.bias
+txt_in.weight
+vector_in.in_layer.bias
+vector_in.in_layer.weight
+vector_in.out_layer.bias
+vector_in.out_layer.weight
+text_encoders.clip_l.logit_scale
+embeddings.position_embedding.weight
+embeddings.token_embedding.weight
+encoder.layers.0.layer_norm1.bias
+encoder.layers.0.layer_norm1.weight
+encoder.layers.0.layer_norm2.bias
+encoder.layers.0.layer_norm2.weight
+encoder.layers.0.mlp.fc1.bias
+encoder.layers.0.mlp.fc1.weight
+encoder.layers.0.mlp.fc2.bias
+encoder.layers.0.mlp.fc2.weight
+encoder.layers.0.self_attn.k_proj.bias
+encoder.layers.0.self_attn.k_proj.weight
+encoder.layers.0.self_attn.out_proj.bias
+encoder.layers.0.self_attn.out_proj.weight
+encoder.layers.0.self_attn.q_proj.bias
+encoder.layers.0.self_attn.q_proj.weight
+encoder.layers.0.self_attn.v_proj.bias
+encoder.layers.0.self_attn.v_proj.weight
+encoder.layers.1.layer_norm1.bias
+encoder.layers.1.layer_norm1.weight
+encoder.layers.1.layer_norm2.bias
+encoder.layers.1.layer_norm2.weight
+encoder.layers.1.mlp.fc1.bias
+encoder.layers.1.mlp.fc1.weight
+encoder.layers.1.mlp.fc2.bias
+encoder.layers.1.mlp.fc2.weight
+encoder.layers.1.self_attn.k_proj.bias
+encoder.layers.1.self_attn.k_proj.weight
+encoder.layers.1.self_attn.out_proj.bias
+encoder.layers.1.self_attn.out_proj.weight
+encoder.layers.1.self_attn.q_proj.bias
+encoder.layers.1.self_attn.q_proj.weight
+encoder.layers.1.self_attn.v_proj.bias
+encoder.layers.1.self_attn.v_proj.weight
+encoder.layers.10.layer_norm1.bias
+encoder.layers.10.layer_norm1.weight
+encoder.layers.10.layer_norm2.bias
+encoder.layers.10.layer_norm2.weight
+encoder.layers.10.mlp.fc1.bias
+encoder.layers.10.mlp.fc1.weight
+encoder.layers.10.mlp.fc2.bias
+encoder.layers.10.mlp.fc2.weight
+encoder.layers.10.self_attn.k_proj.bias
+encoder.layers.10.self_attn.k_proj.weight
+encoder.layers.10.self_attn.out_proj.bias
+encoder.layers.10.self_attn.out_proj.weight
+encoder.layers.10.self_attn.q_proj.bias
+encoder.layers.10.self_attn.q_proj.weight
+encoder.layers.10.self_attn.v_proj.bias
+encoder.layers.10.self_attn.v_proj.weight
+encoder.layers.11.layer_norm1.bias
+encoder.layers.11.layer_norm1.weight
+encoder.layers.11.layer_norm2.bias
+encoder.layers.11.layer_norm2.weight
+encoder.layers.11.mlp.fc1.bias
+encoder.layers.11.mlp.fc1.weight
+encoder.layers.11.mlp.fc2.bias
+encoder.layers.11.mlp.fc2.weight
+encoder.layers.11.self_attn.k_proj.bias
+encoder.layers.11.self_attn.k_proj.weight
+encoder.layers.11.self_attn.out_proj.bias
+encoder.layers.11.self_attn.out_proj.weight
+encoder.layers.11.self_attn.q_proj.bias
+encoder.layers.11.self_attn.q_proj.weight
+encoder.layers.11.self_attn.v_proj.bias
+encoder.layers.11.self_attn.v_proj.weight
+encoder.layers.2.layer_norm1.bias
+encoder.layers.2.layer_norm1.weight
+encoder.layers.2.layer_norm2.bias
+encoder.layers.2.layer_norm2.weight
+encoder.layers.2.mlp.fc1.bias
+encoder.layers.2.mlp.fc1.weight
+encoder.layers.2.mlp.fc2.bias
+encoder.layers.2.mlp.fc2.weight
+encoder.layers.2.self_attn.k_proj.bias
+encoder.layers.2.self_attn.k_proj.weight
+encoder.layers.2.self_attn.out_proj.bias
+encoder.layers.2.self_attn.out_proj.weight
+encoder.layers.2.self_attn.q_proj.bias
+encoder.layers.2.self_attn.q_proj.weight
+encoder.layers.2.self_attn.v_proj.bias
+encoder.layers.2.self_attn.v_proj.weight
+encoder.layers.3.layer_norm1.bias
+encoder.layers.3.layer_norm1.weight
+encoder.layers.3.layer_norm2.bias
+encoder.layers.3.layer_norm2.weight
+encoder.layers.3.mlp.fc1.bias
+encoder.layers.3.mlp.fc1.weight
+encoder.layers.3.mlp.fc2.bias
+encoder.layers.3.mlp.fc2.weight
+encoder.layers.3.self_attn.k_proj.bias
+encoder.layers.3.self_attn.k_proj.weight
+encoder.layers.3.self_attn.out_proj.bias
+encoder.layers.3.self_attn.out_proj.weight
+encoder.layers.3.self_attn.q_proj.bias
+encoder.layers.3.self_attn.q_proj.weight
+encoder.layers.3.self_attn.v_proj.bias
+encoder.layers.3.self_attn.v_proj.weight
+encoder.layers.4.layer_norm1.bias
+encoder.layers.4.layer_norm1.weight
+encoder.layers.4.layer_norm2.bias
+encoder.layers.4.layer_norm2.weight
+encoder.layers.4.mlp.fc1.bias
+encoder.layers.4.mlp.fc1.weight
+encoder.layers.4.mlp.fc2.bias
+encoder.layers.4.mlp.fc2.weight
+encoder.layers.4.self_attn.k_proj.bias
+encoder.layers.4.self_attn.k_proj.weight
+encoder.layers.4.self_attn.out_proj.bias
+encoder.layers.4.self_attn.out_proj.weight
+encoder.layers.4.self_attn.q_proj.bias
+encoder.layers.4.self_attn.q_proj.weight
+encoder.layers.4.self_attn.v_proj.bias
+encoder.layers.4.self_attn.v_proj.weight
+encoder.layers.5.layer_norm1.bias
+encoder.layers.5.layer_norm1.weight
+encoder.layers.5.layer_norm2.bias
+encoder.layers.5.layer_norm2.weight
+encoder.layers.5.mlp.fc1.bias
+encoder.layers.5.mlp.fc1.weight
+encoder.layers.5.mlp.fc2.bias
+encoder.layers.5.mlp.fc2.weight
+encoder.layers.5.self_attn.k_proj.bias
+encoder.layers.5.self_attn.k_proj.weight
+encoder.layers.5.self_attn.out_proj.bias
+encoder.layers.5.self_attn.out_proj.weight
+encoder.layers.5.self_attn.q_proj.bias
+encoder.layers.5.self_attn.q_proj.weight
+encoder.layers.5.self_attn.v_proj.bias
+encoder.layers.5.self_attn.v_proj.weight
+encoder.layers.6.layer_norm1.bias
+encoder.layers.6.layer_norm1.weight
+encoder.layers.6.layer_norm2.bias
+encoder.layers.6.layer_norm2.weight
+encoder.layers.6.mlp.fc1.bias
+encoder.layers.6.mlp.fc1.weight
+encoder.layers.6.mlp.fc2.bias
+encoder.layers.6.mlp.fc2.weight
+encoder.layers.6.self_attn.k_proj.bias
+encoder.layers.6.self_attn.k_proj.weight
+encoder.layers.6.self_attn.out_proj.bias
+encoder.layers.6.self_attn.out_proj.weight
+encoder.layers.6.self_attn.q_proj.bias
+encoder.layers.6.self_attn.q_proj.weight
+encoder.layers.6.self_attn.v_proj.bias
+encoder.layers.6.self_attn.v_proj.weight
+encoder.layers.7.layer_norm1.bias
+encoder.layers.7.layer_norm1.weight
+encoder.layers.7.layer_norm2.bias
+encoder.layers.7.layer_norm2.weight
+encoder.layers.7.mlp.fc1.bias
+encoder.layers.7.mlp.fc1.weight
+encoder.layers.7.mlp.fc2.bias
+encoder.layers.7.mlp.fc2.weight
+encoder.layers.7.self_attn.k_proj.bias
+encoder.layers.7.self_attn.k_proj.weight
+encoder.layers.7.self_attn.out_proj.bias
+encoder.layers.7.self_attn.out_proj.weight
+encoder.layers.7.self_attn.q_proj.bias
+encoder.layers.7.self_attn.q_proj.weight
+encoder.layers.7.self_attn.v_proj.bias
+encoder.layers.7.self_attn.v_proj.weight
+encoder.layers.8.layer_norm1.bias
+encoder.layers.8.layer_norm1.weight
+encoder.layers.8.layer_norm2.bias
+encoder.layers.8.layer_norm2.weight
+encoder.layers.8.mlp.fc1.bias
+encoder.layers.8.mlp.fc1.weight
+encoder.layers.8.mlp.fc2.bias
+encoder.layers.8.mlp.fc2.weight
+encoder.layers.8.self_attn.k_proj.bias
+encoder.layers.8.self_attn.k_proj.weight
+encoder.layers.8.self_attn.out_proj.bias
+encoder.layers.8.self_attn.out_proj.weight
+encoder.layers.8.self_attn.q_proj.bias
+encoder.layers.8.self_attn.q_proj.weight
+encoder.layers.8.self_attn.v_proj.bias
+encoder.layers.8.self_attn.v_proj.weight
+encoder.layers.9.layer_norm1.bias
+encoder.layers.9.layer_norm1.weight
+encoder.layers.9.layer_norm2.bias
+encoder.layers.9.layer_norm2.weight
+encoder.layers.9.mlp.fc1.bias
+encoder.layers.9.mlp.fc1.weight
+encoder.layers.9.mlp.fc2.bias
+encoder.layers.9.mlp.fc2.weight
+encoder.layers.9.self_attn.k_proj.bias
+encoder.layers.9.self_attn.k_proj.weight
+encoder.layers.9.self_attn.out_proj.bias
+encoder.layers.9.self_attn.out_proj.weight
+encoder.layers.9.self_attn.q_proj.bias
+encoder.layers.9.self_attn.q_proj.weight
+encoder.layers.9.self_attn.v_proj.bias
+encoder.layers.9.self_attn.v_proj.weight
+final_layer_norm.bias
+final_layer_norm.weight
+text_encoders.clip_l.transformer.text_projection.weight
+text_encoders.t5xxl.logit_scale
+encoder.block.0.layer.0.SelfAttention.k.weight
+encoder.block.0.layer.0.SelfAttention.o.weight
+encoder.block.0.layer.0.SelfAttention.q.weight
+encoder.block.0.layer.0.SelfAttention.relative_attention_bias.weight
+encoder.block.0.layer.0.SelfAttention.v.weight
+encoder.block.0.layer.0.layer_norm.weight
+encoder.block.0.layer.1.DenseReluDense.wi_0.weight
+encoder.block.0.layer.1.DenseReluDense.wi_1.weight
+encoder.block.0.layer.1.DenseReluDense.wo.weight
+encoder.block.0.layer.1.layer_norm.weight
+encoder.block.1.layer.0.SelfAttention.k.weight
+encoder.block.1.layer.0.SelfAttention.o.weight
+encoder.block.1.layer.0.SelfAttention.q.weight
+encoder.block.1.layer.0.SelfAttention.v.weight
+encoder.block.1.layer.0.layer_norm.weight
+encoder.block.1.layer.1.DenseReluDense.wi_0.weight
+encoder.block.1.layer.1.DenseReluDense.wi_1.weight
+encoder.block.1.layer.1.DenseReluDense.wo.weight
+encoder.block.1.layer.1.layer_norm.weight
+encoder.block.10.layer.0.SelfAttention.k.weight
+encoder.block.10.layer.0.SelfAttention.o.weight
+encoder.block.10.layer.0.SelfAttention.q.weight
+encoder.block.10.layer.0.SelfAttention.v.weight
+encoder.block.10.layer.0.layer_norm.weight
+encoder.block.10.layer.1.DenseReluDense.wi_0.weight
+encoder.block.10.layer.1.DenseReluDense.wi_1.weight
+encoder.block.10.layer.1.DenseReluDense.wo.weight
+encoder.block.10.layer.1.layer_norm.weight
+encoder.block.11.layer.0.SelfAttention.k.weight
+encoder.block.11.layer.0.SelfAttention.o.weight
+encoder.block.11.layer.0.SelfAttention.q.weight
+encoder.block.11.layer.0.SelfAttention.v.weight
+encoder.block.11.layer.0.layer_norm.weight
+encoder.block.11.layer.1.DenseReluDense.wi_0.weight
+encoder.block.11.layer.1.DenseReluDense.wi_1.weight
+encoder.block.11.layer.1.DenseReluDense.wo.weight
+encoder.block.11.layer.1.layer_norm.weight
+encoder.block.12.layer.0.SelfAttention.k.weight
+encoder.block.12.layer.0.SelfAttention.o.weight
+encoder.block.12.layer.0.SelfAttention.q.weight
+encoder.block.12.layer.0.SelfAttention.v.weight
+encoder.block.12.layer.0.layer_norm.weight
+encoder.block.12.layer.1.DenseReluDense.wi_0.weight
+encoder.block.12.layer.1.DenseReluDense.wi_1.weight
+encoder.block.12.layer.1.DenseReluDense.wo.weight
+encoder.block.12.layer.1.layer_norm.weight
+encoder.block.13.layer.0.SelfAttention.k.weight
+encoder.block.13.layer.0.SelfAttention.o.weight
+encoder.block.13.layer.0.SelfAttention.q.weight
+encoder.block.13.layer.0.SelfAttention.v.weight
+encoder.block.13.layer.0.layer_norm.weight
+encoder.block.13.layer.1.DenseReluDense.wi_0.weight
+encoder.block.13.layer.1.DenseReluDense.wi_1.weight
+encoder.block.13.layer.1.DenseReluDense.wo.weight
+encoder.block.13.layer.1.layer_norm.weight
+encoder.block.14.layer.0.SelfAttention.k.weight
+encoder.block.14.layer.0.SelfAttention.o.weight
+encoder.block.14.layer.0.SelfAttention.q.weight
+encoder.block.14.layer.0.SelfAttention.v.weight
+encoder.block.14.layer.0.layer_norm.weight
+encoder.block.14.layer.1.DenseReluDense.wi_0.weight
+encoder.block.14.layer.1.DenseReluDense.wi_1.weight
+encoder.block.14.layer.1.DenseReluDense.wo.weight
+encoder.block.14.layer.1.layer_norm.weight
+encoder.block.15.layer.0.SelfAttention.k.weight
+encoder.block.15.layer.0.SelfAttention.o.weight
+encoder.block.15.layer.0.SelfAttention.q.weight
+encoder.block.15.layer.0.SelfAttention.v.weight
+encoder.block.15.layer.0.layer_norm.weight
+encoder.block.15.layer.1.DenseReluDense.wi_0.weight
+encoder.block.15.layer.1.DenseReluDense.wi_1.weight
+encoder.block.15.layer.1.DenseReluDense.wo.weight
+encoder.block.15.layer.1.layer_norm.weight
+encoder.block.16.layer.0.SelfAttention.k.weight
+encoder.block.16.layer.0.SelfAttention.o.weight
+encoder.block.16.layer.0.SelfAttention.q.weight
+encoder.block.16.layer.0.SelfAttention.v.weight
+encoder.block.16.layer.0.layer_norm.weight
+encoder.block.16.layer.1.DenseReluDense.wi_0.weight
+encoder.block.16.layer.1.DenseReluDense.wi_1.weight
+encoder.block.16.layer.1.DenseReluDense.wo.weight
+encoder.block.16.layer.1.layer_norm.weight
+encoder.block.17.layer.0.SelfAttention.k.weight
+encoder.block.17.layer.0.SelfAttention.o.weight
+encoder.block.17.layer.0.SelfAttention.q.weight
+encoder.block.17.layer.0.SelfAttention.v.weight
+encoder.block.17.layer.0.layer_norm.weight
+encoder.block.17.layer.1.DenseReluDense.wi_0.weight
+encoder.block.17.layer.1.DenseReluDense.wi_1.weight
+encoder.block.17.layer.1.DenseReluDense.wo.weight
+encoder.block.17.layer.1.layer_norm.weight
+encoder.block.18.layer.0.SelfAttention.k.weight
+encoder.block.18.layer.0.SelfAttention.o.weight
+encoder.block.18.layer.0.SelfAttention.q.weight
+encoder.block.18.layer.0.SelfAttention.v.weight
+encoder.block.18.layer.0.layer_norm.weight
+encoder.block.18.layer.1.DenseReluDense.wi_0.weight
+encoder.block.18.layer.1.DenseReluDense.wi_1.weight
+encoder.block.18.layer.1.DenseReluDense.wo.weight
+encoder.block.18.layer.1.layer_norm.weight
+encoder.block.19.layer.0.SelfAttention.k.weight
+encoder.block.19.layer.0.SelfAttention.o.weight
+encoder.block.19.layer.0.SelfAttention.q.weight
+encoder.block.19.layer.0.SelfAttention.v.weight
+encoder.block.19.layer.0.layer_norm.weight
+encoder.block.19.layer.1.DenseReluDense.wi_0.weight
+encoder.block.19.layer.1.DenseReluDense.wi_1.weight
+encoder.block.19.layer.1.DenseReluDense.wo.weight
+encoder.block.19.layer.1.layer_norm.weight
+encoder.block.2.layer.0.SelfAttention.k.weight
+encoder.block.2.layer.0.SelfAttention.o.weight
+encoder.block.2.layer.0.SelfAttention.q.weight
+encoder.block.2.layer.0.SelfAttention.v.weight
+encoder.block.2.layer.0.layer_norm.weight
+encoder.block.2.layer.1.DenseReluDense.wi_0.weight
+encoder.block.2.layer.1.DenseReluDense.wi_1.weight
+encoder.block.2.layer.1.DenseReluDense.wo.weight
+encoder.block.2.layer.1.layer_norm.weight
+encoder.block.20.layer.0.SelfAttention.k.weight
+encoder.block.20.layer.0.SelfAttention.o.weight
+encoder.block.20.layer.0.SelfAttention.q.weight
+encoder.block.20.layer.0.SelfAttention.v.weight
+encoder.block.20.layer.0.layer_norm.weight
+encoder.block.20.layer.1.DenseReluDense.wi_0.weight
+encoder.block.20.layer.1.DenseReluDense.wi_1.weight
+encoder.block.20.layer.1.DenseReluDense.wo.weight
+encoder.block.20.layer.1.layer_norm.weight
+encoder.block.21.layer.0.SelfAttention.k.weight
+encoder.block.21.layer.0.SelfAttention.o.weight
+encoder.block.21.layer.0.SelfAttention.q.weight
+encoder.block.21.layer.0.SelfAttention.v.weight
+encoder.block.21.layer.0.layer_norm.weight
+encoder.block.21.layer.1.DenseReluDense.wi_0.weight
+encoder.block.21.layer.1.DenseReluDense.wi_1.weight
+encoder.block.21.layer.1.DenseReluDense.wo.weight
+encoder.block.21.layer.1.layer_norm.weight
+encoder.block.22.layer.0.SelfAttention.k.weight
+encoder.block.22.layer.0.SelfAttention.o.weight
+encoder.block.22.layer.0.SelfAttention.q.weight
+encoder.block.22.layer.0.SelfAttention.v.weight
+encoder.block.22.layer.0.layer_norm.weight
+encoder.block.22.layer.1.DenseReluDense.wi_0.weight
+encoder.block.22.layer.1.DenseReluDense.wi_1.weight
+encoder.block.22.layer.1.DenseReluDense.wo.weight
+encoder.block.22.layer.1.layer_norm.weight
+encoder.block.23.layer.0.SelfAttention.k.weight
+encoder.block.23.layer.0.SelfAttention.o.weight
+encoder.block.23.layer.0.SelfAttention.q.weight
+encoder.block.23.layer.0.SelfAttention.v.weight
+encoder.block.23.layer.0.layer_norm.weight
+encoder.block.23.layer.1.DenseReluDense.wi_0.weight
+encoder.block.23.layer.1.DenseReluDense.wi_1.weight
+encoder.block.23.layer.1.DenseReluDense.wo.weight
+encoder.block.23.layer.1.layer_norm.weight
+encoder.block.3.layer.0.SelfAttention.k.weight
+encoder.block.3.layer.0.SelfAttention.o.weight
+encoder.block.3.layer.0.SelfAttention.q.weight
+encoder.block.3.layer.0.SelfAttention.v.weight
+encoder.block.3.layer.0.layer_norm.weight
+encoder.block.3.layer.1.DenseReluDense.wi_0.weight
+encoder.block.3.layer.1.DenseReluDense.wi_1.weight
+encoder.block.3.layer.1.DenseReluDense.wo.weight
+encoder.block.3.layer.1.layer_norm.weight
+encoder.block.4.layer.0.SelfAttention.k.weight
+encoder.block.4.layer.0.SelfAttention.o.weight
+encoder.block.4.layer.0.SelfAttention.q.weight
+encoder.block.4.layer.0.SelfAttention.v.weight
+encoder.block.4.layer.0.layer_norm.weight
+encoder.block.4.layer.1.DenseReluDense.wi_0.weight
+encoder.block.4.layer.1.DenseReluDense.wi_1.weight
+encoder.block.4.layer.1.DenseReluDense.wo.weight
+encoder.block.4.layer.1.layer_norm.weight
+encoder.block.5.layer.0.SelfAttention.k.weight
+encoder.block.5.layer.0.SelfAttention.o.weight
+encoder.block.5.layer.0.SelfAttention.q.weight
+encoder.block.5.layer.0.SelfAttention.v.weight
+encoder.block.5.layer.0.layer_norm.weight
+encoder.block.5.layer.1.DenseReluDense.wi_0.weight
+encoder.block.5.layer.1.DenseReluDense.wi_1.weight
+encoder.block.5.layer.1.DenseReluDense.wo.weight
+encoder.block.5.layer.1.layer_norm.weight
+encoder.block.6.layer.0.SelfAttention.k.weight
+encoder.block.6.layer.0.SelfAttention.o.weight
+encoder.block.6.layer.0.SelfAttention.q.weight
+encoder.block.6.layer.0.SelfAttention.v.weight
+encoder.block.6.layer.0.layer_norm.weight
+encoder.block.6.layer.1.DenseReluDense.wi_0.weight
+encoder.block.6.layer.1.DenseReluDense.wi_1.weight
+encoder.block.6.layer.1.DenseReluDense.wo.weight
+encoder.block.6.layer.1.layer_norm.weight
+encoder.block.7.layer.0.SelfAttention.k.weight
+encoder.block.7.layer.0.SelfAttention.o.weight
+encoder.block.7.layer.0.SelfAttention.q.weight
+encoder.block.7.layer.0.SelfAttention.v.weight
+encoder.block.7.layer.0.layer_norm.weight
+encoder.block.7.layer.1.DenseReluDense.wi_0.weight
+encoder.block.7.layer.1.DenseReluDense.wi_1.weight
+encoder.block.7.layer.1.DenseReluDense.wo.weight
+encoder.block.7.layer.1.layer_norm.weight
+encoder.block.8.layer.0.SelfAttention.k.weight
+encoder.block.8.layer.0.SelfAttention.o.weight
+encoder.block.8.layer.0.SelfAttention.q.weight
+encoder.block.8.layer.0.SelfAttention.v.weight
+encoder.block.8.layer.0.layer_norm.weight
+encoder.block.8.layer.1.DenseReluDense.wi_0.weight
+encoder.block.8.layer.1.DenseReluDense.wi_1.weight
+encoder.block.8.layer.1.DenseReluDense.wo.weight
+encoder.block.8.layer.1.layer_norm.weight
+encoder.block.9.layer.0.SelfAttention.k.weight
+encoder.block.9.layer.0.SelfAttention.o.weight
+encoder.block.9.layer.0.SelfAttention.q.weight
+encoder.block.9.layer.0.SelfAttention.v.weight
+encoder.block.9.layer.0.layer_norm.weight
+encoder.block.9.layer.1.DenseReluDense.wi_0.weight
+encoder.block.9.layer.1.DenseReluDense.wi_1.weight
+encoder.block.9.layer.1.DenseReluDense.wo.weight
+encoder.block.9.layer.1.layer_norm.weight
+encoder.final_layer_norm.weight
+shared.weight
+decoder.conv_in.bias
+decoder.conv_in.weight
+decoder.conv_out.bias
+decoder.conv_out.weight
+decoder.mid.attn_1.k.bias
+decoder.mid.attn_1.k.weight
+decoder.mid.attn_1.norm.bias
+decoder.mid.attn_1.norm.weight
+decoder.mid.attn_1.proj_out.bias
+decoder.mid.attn_1.proj_out.weight
+decoder.mid.attn_1.q.bias
+decoder.mid.attn_1.q.weight
+decoder.mid.attn_1.v.bias
+decoder.mid.attn_1.v.weight
+decoder.mid.block_1.conv1.bias
+decoder.mid.block_1.conv1.weight
+decoder.mid.block_1.conv2.bias
+decoder.mid.block_1.conv2.weight
+decoder.mid.block_1.norm1.bias
+decoder.mid.block_1.norm1.weight
+decoder.mid.block_1.norm2.bias
+decoder.mid.block_1.norm2.weight
+decoder.mid.block_2.conv1.bias
+decoder.mid.block_2.conv1.weight
+decoder.mid.block_2.conv2.bias
+decoder.mid.block_2.conv2.weight
+decoder.mid.block_2.norm1.bias
+decoder.mid.block_2.norm1.weight
+decoder.mid.block_2.norm2.bias
+decoder.mid.block_2.norm2.weight
+decoder.norm_out.bias
+decoder.norm_out.weight
+decoder.up.0.block.0.conv1.bias
+decoder.up.0.block.0.conv1.weight
+decoder.up.0.block.0.conv2.bias
+decoder.up.0.block.0.conv2.weight
+decoder.up.0.block.0.nin_shortcut.bias
+decoder.up.0.block.0.nin_shortcut.weight
+decoder.up.0.block.0.norm1.bias
+decoder.up.0.block.0.norm1.weight
+decoder.up.0.block.0.norm2.bias
+decoder.up.0.block.0.norm2.weight
+decoder.up.0.block.1.conv1.bias
+decoder.up.0.block.1.conv1.weight
+decoder.up.0.block.1.conv2.bias
+decoder.up.0.block.1.conv2.weight
+decoder.up.0.block.1.norm1.bias
+decoder.up.0.block.1.norm1.weight
+decoder.up.0.block.1.norm2.bias
+decoder.up.0.block.1.norm2.weight
+decoder.up.0.block.2.conv1.bias
+decoder.up.0.block.2.conv1.weight
+decoder.up.0.block.2.conv2.bias
+decoder.up.0.block.2.conv2.weight
+decoder.up.0.block.2.norm1.bias
+decoder.up.0.block.2.norm1.weight
+decoder.up.0.block.2.norm2.bias
+decoder.up.0.block.2.norm2.weight
+decoder.up.1.block.0.conv1.bias
+decoder.up.1.block.0.conv1.weight
+decoder.up.1.block.0.conv2.bias
+decoder.up.1.block.0.conv2.weight
+decoder.up.1.block.0.nin_shortcut.bias
+decoder.up.1.block.0.nin_shortcut.weight
+decoder.up.1.block.0.norm1.bias
+decoder.up.1.block.0.norm1.weight
+decoder.up.1.block.0.norm2.bias
+decoder.up.1.block.0.norm2.weight
+decoder.up.1.block.1.conv1.bias
+decoder.up.1.block.1.conv1.weight
+decoder.up.1.block.1.conv2.bias
+decoder.up.1.block.1.conv2.weight
+decoder.up.1.block.1.norm1.bias
+decoder.up.1.block.1.norm1.weight
+decoder.up.1.block.1.norm2.bias
+decoder.up.1.block.1.norm2.weight
+decoder.up.1.block.2.conv1.bias
+decoder.up.1.block.2.conv1.weight
+decoder.up.1.block.2.conv2.bias
+decoder.up.1.block.2.conv2.weight
+decoder.up.1.block.2.norm1.bias
+decoder.up.1.block.2.norm1.weight
+decoder.up.1.block.2.norm2.bias
+decoder.up.1.block.2.norm2.weight
+decoder.up.1.upsample.conv.bias
+decoder.up.1.upsample.conv.weight
+decoder.up.2.block.0.conv1.bias
+decoder.up.2.block.0.conv1.weight
+decoder.up.2.block.0.conv2.bias
+decoder.up.2.block.0.conv2.weight
+decoder.up.2.block.0.norm1.bias
+decoder.up.2.block.0.norm1.weight
+decoder.up.2.block.0.norm2.bias
+decoder.up.2.block.0.norm2.weight
+decoder.up.2.block.1.conv1.bias
+decoder.up.2.block.1.conv1.weight
+decoder.up.2.block.1.conv2.bias
+decoder.up.2.block.1.conv2.weight
+decoder.up.2.block.1.norm1.bias
+decoder.up.2.block.1.norm1.weight
+decoder.up.2.block.1.norm2.bias
+decoder.up.2.block.1.norm2.weight
+decoder.up.2.block.2.conv1.bias
+decoder.up.2.block.2.conv1.weight
+decoder.up.2.block.2.conv2.bias
+decoder.up.2.block.2.conv2.weight
+decoder.up.2.block.2.norm1.bias
+decoder.up.2.block.2.norm1.weight
+decoder.up.2.block.2.norm2.bias
+decoder.up.2.block.2.norm2.weight
+decoder.up.2.upsample.conv.bias
+decoder.up.2.upsample.conv.weight
+decoder.up.3.block.0.conv1.bias
+decoder.up.3.block.0.conv1.weight
+decoder.up.3.block.0.conv2.bias
+decoder.up.3.block.0.conv2.weight
+decoder.up.3.block.0.norm1.bias
+decoder.up.3.block.0.norm1.weight
+decoder.up.3.block.0.norm2.bias
+decoder.up.3.block.0.norm2.weight
+decoder.up.3.block.1.conv1.bias
+decoder.up.3.block.1.conv1.weight
+decoder.up.3.block.1.conv2.bias
+decoder.up.3.block.1.conv2.weight
+decoder.up.3.block.1.norm1.bias
+decoder.up.3.block.1.norm1.weight
+decoder.up.3.block.1.norm2.bias
+decoder.up.3.block.1.norm2.weight
+decoder.up.3.block.2.conv1.bias
+decoder.up.3.block.2.conv1.weight
+decoder.up.3.block.2.conv2.bias
+decoder.up.3.block.2.conv2.weight
+decoder.up.3.block.2.norm1.bias
+decoder.up.3.block.2.norm1.weight
+decoder.up.3.block.2.norm2.bias
+decoder.up.3.block.2.norm2.weight
+decoder.up.3.upsample.conv.bias
+decoder.up.3.upsample.conv.weight
+encoder.conv_in.bias
+encoder.conv_in.weight
+encoder.conv_out.bias
+encoder.conv_out.weight
+encoder.down.0.block.0.conv1.bias
+encoder.down.0.block.0.conv1.weight
+encoder.down.0.block.0.conv2.bias
+encoder.down.0.block.0.conv2.weight
+encoder.down.0.block.0.norm1.bias
+encoder.down.0.block.0.norm1.weight
+encoder.down.0.block.0.norm2.bias
+encoder.down.0.block.0.norm2.weight
+encoder.down.0.block.1.conv1.bias
+encoder.down.0.block.1.conv1.weight
+encoder.down.0.block.1.conv2.bias
+encoder.down.0.block.1.conv2.weight
+encoder.down.0.block.1.norm1.bias
+encoder.down.0.block.1.norm1.weight
+encoder.down.0.block.1.norm2.bias
+encoder.down.0.block.1.norm2.weight
+encoder.down.0.downsample.conv.bias
+encoder.down.0.downsample.conv.weight
+encoder.down.1.block.0.conv1.bias
+encoder.down.1.block.0.conv1.weight
+encoder.down.1.block.0.conv2.bias
+encoder.down.1.block.0.conv2.weight
+encoder.down.1.block.0.nin_shortcut.bias
+encoder.down.1.block.0.nin_shortcut.weight
+encoder.down.1.block.0.norm1.bias
+encoder.down.1.block.0.norm1.weight
+encoder.down.1.block.0.norm2.bias
+encoder.down.1.block.0.norm2.weight
+encoder.down.1.block.1.conv1.bias
+encoder.down.1.block.1.conv1.weight
+encoder.down.1.block.1.conv2.bias
+encoder.down.1.block.1.conv2.weight
+encoder.down.1.block.1.norm1.bias
+encoder.down.1.block.1.norm1.weight
+encoder.down.1.block.1.norm2.bias
+encoder.down.1.block.1.norm2.weight
+encoder.down.1.downsample.conv.bias
+encoder.down.1.downsample.conv.weight
+encoder.down.2.block.0.conv1.bias
+encoder.down.2.block.0.conv1.weight
+encoder.down.2.block.0.conv2.bias
+encoder.down.2.block.0.conv2.weight
+encoder.down.2.block.0.nin_shortcut.bias
+encoder.down.2.block.0.nin_shortcut.weight
+encoder.down.2.block.0.norm1.bias
+encoder.down.2.block.0.norm1.weight
+encoder.down.2.block.0.norm2.bias
+encoder.down.2.block.0.norm2.weight
+encoder.down.2.block.1.conv1.bias
+encoder.down.2.block.1.conv1.weight
+encoder.down.2.block.1.conv2.bias
+encoder.down.2.block.1.conv2.weight
+encoder.down.2.block.1.norm1.bias
+encoder.down.2.block.1.norm1.weight
+encoder.down.2.block.1.norm2.bias
+encoder.down.2.block.1.norm2.weight
+encoder.down.2.downsample.conv.bias
+encoder.down.2.downsample.conv.weight
+encoder.down.3.block.0.conv1.bias
+encoder.down.3.block.0.conv1.weight
+encoder.down.3.block.0.conv2.bias
+encoder.down.3.block.0.conv2.weight
+encoder.down.3.block.0.norm1.bias
+encoder.down.3.block.0.norm1.weight
+encoder.down.3.block.0.norm2.bias
+encoder.down.3.block.0.norm2.weight
+encoder.down.3.block.1.conv1.bias
+encoder.down.3.block.1.conv1.weight
+encoder.down.3.block.1.conv2.bias
+encoder.down.3.block.1.conv2.weight
+encoder.down.3.block.1.norm1.bias
+encoder.down.3.block.1.norm1.weight
+encoder.down.3.block.1.norm2.bias
+encoder.down.3.block.1.norm2.weight
+encoder.mid.attn_1.k.bias
+encoder.mid.attn_1.k.weight
+encoder.mid.attn_1.norm.bias
+encoder.mid.attn_1.norm.weight
+encoder.mid.attn_1.proj_out.bias
+encoder.mid.attn_1.proj_out.weight
+encoder.mid.attn_1.q.bias
+encoder.mid.attn_1.q.weight
+encoder.mid.attn_1.v.bias
+encoder.mid.attn_1.v.weight
+encoder.mid.block_1.conv1.bias
+encoder.mid.block_1.conv1.weight
+encoder.mid.block_1.conv2.bias
+encoder.mid.block_1.conv2.weight
+encoder.mid.block_1.norm1.bias
+encoder.mid.block_1.norm1.weight
+encoder.mid.block_1.norm2.bias
+encoder.mid.block_1.norm2.weight
+encoder.mid.block_2.conv1.bias
+encoder.mid.block_2.conv1.weight
+encoder.mid.block_2.conv2.bias
+encoder.mid.block_2.conv2.weight
+encoder.mid.block_2.norm1.bias
+encoder.mid.block_2.norm1.weight
+encoder.mid.block_2.norm2.bias
+encoder.mid.block_2.norm2.weight
+encoder.norm_out.bias
+encoder.norm_out.weight

fluxunchainedArtfulNSFW_fuT516xfp8E4m3fnV11_fixed.safetensors.old.txt.txt

@@ -0,0 +1,1442 @@
+model.diffusion_model.double_blocks.0.img_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.0.img_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.0.img_attn.proj.bias
+model.diffusion_model.double_blocks.0.img_attn.proj.weight
+model.diffusion_model.double_blocks.0.img_attn.qkv.bias
+model.diffusion_model.double_blocks.0.img_attn.qkv.weight
+model.diffusion_model.double_blocks.0.img_mlp.0.bias
+model.diffusion_model.double_blocks.0.img_mlp.0.weight
+model.diffusion_model.double_blocks.0.img_mlp.2.bias
+model.diffusion_model.double_blocks.0.img_mlp.2.weight
+model.diffusion_model.double_blocks.0.img_mod.lin.bias
+model.diffusion_model.double_blocks.0.img_mod.lin.weight
+model.diffusion_model.double_blocks.0.txt_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.0.txt_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.0.txt_attn.proj.bias
+model.diffusion_model.double_blocks.0.txt_attn.proj.weight
+model.diffusion_model.double_blocks.0.txt_attn.qkv.bias
+model.diffusion_model.double_blocks.0.txt_attn.qkv.weight
+model.diffusion_model.double_blocks.0.txt_mlp.0.bias
+model.diffusion_model.double_blocks.0.txt_mlp.0.weight
+model.diffusion_model.double_blocks.0.txt_mlp.2.bias
+model.diffusion_model.double_blocks.0.txt_mlp.2.weight
+model.diffusion_model.double_blocks.0.txt_mod.lin.bias
+model.diffusion_model.double_blocks.0.txt_mod.lin.weight
+model.diffusion_model.double_blocks.1.img_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.1.img_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.1.img_attn.proj.bias
+model.diffusion_model.double_blocks.1.img_attn.proj.weight
+model.diffusion_model.double_blocks.1.img_attn.qkv.bias
+model.diffusion_model.double_blocks.1.img_attn.qkv.weight
+model.diffusion_model.double_blocks.1.img_mlp.0.bias
+model.diffusion_model.double_blocks.1.img_mlp.0.weight
+model.diffusion_model.double_blocks.1.img_mlp.2.bias
+model.diffusion_model.double_blocks.1.img_mlp.2.weight
+model.diffusion_model.double_blocks.1.img_mod.lin.bias
+model.diffusion_model.double_blocks.1.img_mod.lin.weight
+model.diffusion_model.double_blocks.1.txt_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.1.txt_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.1.txt_attn.proj.bias
+model.diffusion_model.double_blocks.1.txt_attn.proj.weight
+model.diffusion_model.double_blocks.1.txt_attn.qkv.bias
+model.diffusion_model.double_blocks.1.txt_attn.qkv.weight
+model.diffusion_model.double_blocks.1.txt_mlp.0.bias
+model.diffusion_model.double_blocks.1.txt_mlp.0.weight
+model.diffusion_model.double_blocks.1.txt_mlp.2.bias
+model.diffusion_model.double_blocks.1.txt_mlp.2.weight
+model.diffusion_model.double_blocks.1.txt_mod.lin.bias
+model.diffusion_model.double_blocks.1.txt_mod.lin.weight
+model.diffusion_model.double_blocks.10.img_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.10.img_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.10.img_attn.proj.bias
+model.diffusion_model.double_blocks.10.img_attn.proj.weight
+model.diffusion_model.double_blocks.10.img_attn.qkv.bias
+model.diffusion_model.double_blocks.10.img_attn.qkv.weight
+model.diffusion_model.double_blocks.10.img_mlp.0.bias
+model.diffusion_model.double_blocks.10.img_mlp.0.weight
+model.diffusion_model.double_blocks.10.img_mlp.2.bias
+model.diffusion_model.double_blocks.10.img_mlp.2.weight
+model.diffusion_model.double_blocks.10.img_mod.lin.bias
+model.diffusion_model.double_blocks.10.img_mod.lin.weight
+model.diffusion_model.double_blocks.10.txt_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.10.txt_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.10.txt_attn.proj.bias
+model.diffusion_model.double_blocks.10.txt_attn.proj.weight
+model.diffusion_model.double_blocks.10.txt_attn.qkv.bias
+model.diffusion_model.double_blocks.10.txt_attn.qkv.weight
+model.diffusion_model.double_blocks.10.txt_mlp.0.bias
+model.diffusion_model.double_blocks.10.txt_mlp.0.weight
+model.diffusion_model.double_blocks.10.txt_mlp.2.bias
+model.diffusion_model.double_blocks.10.txt_mlp.2.weight
+model.diffusion_model.double_blocks.10.txt_mod.lin.bias
+model.diffusion_model.double_blocks.10.txt_mod.lin.weight
+model.diffusion_model.double_blocks.11.img_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.11.img_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.11.img_attn.proj.bias
+model.diffusion_model.double_blocks.11.img_attn.proj.weight
+model.diffusion_model.double_blocks.11.img_attn.qkv.bias
+model.diffusion_model.double_blocks.11.img_attn.qkv.weight
+model.diffusion_model.double_blocks.11.img_mlp.0.bias
+model.diffusion_model.double_blocks.11.img_mlp.0.weight
+model.diffusion_model.double_blocks.11.img_mlp.2.bias
+model.diffusion_model.double_blocks.11.img_mlp.2.weight
+model.diffusion_model.double_blocks.11.img_mod.lin.bias
+model.diffusion_model.double_blocks.11.img_mod.lin.weight
+model.diffusion_model.double_blocks.11.txt_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.11.txt_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.11.txt_attn.proj.bias
+model.diffusion_model.double_blocks.11.txt_attn.proj.weight
+model.diffusion_model.double_blocks.11.txt_attn.qkv.bias
+model.diffusion_model.double_blocks.11.txt_attn.qkv.weight
+model.diffusion_model.double_blocks.11.txt_mlp.0.bias
+model.diffusion_model.double_blocks.11.txt_mlp.0.weight
+model.diffusion_model.double_blocks.11.txt_mlp.2.bias
+model.diffusion_model.double_blocks.11.txt_mlp.2.weight
+model.diffusion_model.double_blocks.11.txt_mod.lin.bias
+model.diffusion_model.double_blocks.11.txt_mod.lin.weight
+model.diffusion_model.double_blocks.12.img_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.12.img_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.12.img_attn.proj.bias
+model.diffusion_model.double_blocks.12.img_attn.proj.weight
+model.diffusion_model.double_blocks.12.img_attn.qkv.bias
+model.diffusion_model.double_blocks.12.img_attn.qkv.weight
+model.diffusion_model.double_blocks.12.img_mlp.0.bias
+model.diffusion_model.double_blocks.12.img_mlp.0.weight
+model.diffusion_model.double_blocks.12.img_mlp.2.bias
+model.diffusion_model.double_blocks.12.img_mlp.2.weight
+model.diffusion_model.double_blocks.12.img_mod.lin.bias
+model.diffusion_model.double_blocks.12.img_mod.lin.weight
+model.diffusion_model.double_blocks.12.txt_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.12.txt_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.12.txt_attn.proj.bias
+model.diffusion_model.double_blocks.12.txt_attn.proj.weight
+model.diffusion_model.double_blocks.12.txt_attn.qkv.bias
+model.diffusion_model.double_blocks.12.txt_attn.qkv.weight
+model.diffusion_model.double_blocks.12.txt_mlp.0.bias
+model.diffusion_model.double_blocks.12.txt_mlp.0.weight
+model.diffusion_model.double_blocks.12.txt_mlp.2.bias
+model.diffusion_model.double_blocks.12.txt_mlp.2.weight
+model.diffusion_model.double_blocks.12.txt_mod.lin.bias
+model.diffusion_model.double_blocks.12.txt_mod.lin.weight
+model.diffusion_model.double_blocks.13.img_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.13.img_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.13.img_attn.proj.bias
+model.diffusion_model.double_blocks.13.img_attn.proj.weight
+model.diffusion_model.double_blocks.13.img_attn.qkv.bias
+model.diffusion_model.double_blocks.13.img_attn.qkv.weight
+model.diffusion_model.double_blocks.13.img_mlp.0.bias
+model.diffusion_model.double_blocks.13.img_mlp.0.weight
+model.diffusion_model.double_blocks.13.img_mlp.2.bias
+model.diffusion_model.double_blocks.13.img_mlp.2.weight
+model.diffusion_model.double_blocks.13.img_mod.lin.bias
+model.diffusion_model.double_blocks.13.img_mod.lin.weight
+model.diffusion_model.double_blocks.13.txt_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.13.txt_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.13.txt_attn.proj.bias
+model.diffusion_model.double_blocks.13.txt_attn.proj.weight
+model.diffusion_model.double_blocks.13.txt_attn.qkv.bias
+model.diffusion_model.double_blocks.13.txt_attn.qkv.weight
+model.diffusion_model.double_blocks.13.txt_mlp.0.bias
+model.diffusion_model.double_blocks.13.txt_mlp.0.weight
+model.diffusion_model.double_blocks.13.txt_mlp.2.bias
+model.diffusion_model.double_blocks.13.txt_mlp.2.weight
+model.diffusion_model.double_blocks.13.txt_mod.lin.bias
+model.diffusion_model.double_blocks.13.txt_mod.lin.weight
+model.diffusion_model.double_blocks.14.img_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.14.img_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.14.img_attn.proj.bias
+model.diffusion_model.double_blocks.14.img_attn.proj.weight
+model.diffusion_model.double_blocks.14.img_attn.qkv.bias
+model.diffusion_model.double_blocks.14.img_attn.qkv.weight
+model.diffusion_model.double_blocks.14.img_mlp.0.bias
+model.diffusion_model.double_blocks.14.img_mlp.0.weight
+model.diffusion_model.double_blocks.14.img_mlp.2.bias
+model.diffusion_model.double_blocks.14.img_mlp.2.weight
+model.diffusion_model.double_blocks.14.img_mod.lin.bias
+model.diffusion_model.double_blocks.14.img_mod.lin.weight
+model.diffusion_model.double_blocks.14.txt_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.14.txt_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.14.txt_attn.proj.bias
+model.diffusion_model.double_blocks.14.txt_attn.proj.weight
+model.diffusion_model.double_blocks.14.txt_attn.qkv.bias
+model.diffusion_model.double_blocks.14.txt_attn.qkv.weight
+model.diffusion_model.double_blocks.14.txt_mlp.0.bias
+model.diffusion_model.double_blocks.14.txt_mlp.0.weight
+model.diffusion_model.double_blocks.14.txt_mlp.2.bias
+model.diffusion_model.double_blocks.14.txt_mlp.2.weight
+model.diffusion_model.double_blocks.14.txt_mod.lin.bias
+model.diffusion_model.double_blocks.14.txt_mod.lin.weight
+model.diffusion_model.double_blocks.15.img_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.15.img_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.15.img_attn.proj.bias
+model.diffusion_model.double_blocks.15.img_attn.proj.weight
+model.diffusion_model.double_blocks.15.img_attn.qkv.bias
+model.diffusion_model.double_blocks.15.img_attn.qkv.weight
+model.diffusion_model.double_blocks.15.img_mlp.0.bias
+model.diffusion_model.double_blocks.15.img_mlp.0.weight
+model.diffusion_model.double_blocks.15.img_mlp.2.bias
+model.diffusion_model.double_blocks.15.img_mlp.2.weight
+model.diffusion_model.double_blocks.15.img_mod.lin.bias
+model.diffusion_model.double_blocks.15.img_mod.lin.weight
+model.diffusion_model.double_blocks.15.txt_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.15.txt_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.15.txt_attn.proj.bias
+model.diffusion_model.double_blocks.15.txt_attn.proj.weight
+model.diffusion_model.double_blocks.15.txt_attn.qkv.bias
+model.diffusion_model.double_blocks.15.txt_attn.qkv.weight
+model.diffusion_model.double_blocks.15.txt_mlp.0.bias
+model.diffusion_model.double_blocks.15.txt_mlp.0.weight
+model.diffusion_model.double_blocks.15.txt_mlp.2.bias
+model.diffusion_model.double_blocks.15.txt_mlp.2.weight
+model.diffusion_model.double_blocks.15.txt_mod.lin.bias
+model.diffusion_model.double_blocks.15.txt_mod.lin.weight
+model.diffusion_model.double_blocks.16.img_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.16.img_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.16.img_attn.proj.bias
+model.diffusion_model.double_blocks.16.img_attn.proj.weight
+model.diffusion_model.double_blocks.16.img_attn.qkv.bias
+model.diffusion_model.double_blocks.16.img_attn.qkv.weight
+model.diffusion_model.double_blocks.16.img_mlp.0.bias
+model.diffusion_model.double_blocks.16.img_mlp.0.weight
+model.diffusion_model.double_blocks.16.img_mlp.2.bias
+model.diffusion_model.double_blocks.16.img_mlp.2.weight
+model.diffusion_model.double_blocks.16.img_mod.lin.bias
+model.diffusion_model.double_blocks.16.img_mod.lin.weight
+model.diffusion_model.double_blocks.16.txt_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.16.txt_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.16.txt_attn.proj.bias
+model.diffusion_model.double_blocks.16.txt_attn.proj.weight
+model.diffusion_model.double_blocks.16.txt_attn.qkv.bias
+model.diffusion_model.double_blocks.16.txt_attn.qkv.weight
+model.diffusion_model.double_blocks.16.txt_mlp.0.bias
+model.diffusion_model.double_blocks.16.txt_mlp.0.weight
+model.diffusion_model.double_blocks.16.txt_mlp.2.bias
+model.diffusion_model.double_blocks.16.txt_mlp.2.weight
+model.diffusion_model.double_blocks.16.txt_mod.lin.bias
+model.diffusion_model.double_blocks.16.txt_mod.lin.weight
+model.diffusion_model.double_blocks.17.img_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.17.img_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.17.img_attn.proj.bias
+model.diffusion_model.double_blocks.17.img_attn.proj.weight
+model.diffusion_model.double_blocks.17.img_attn.qkv.bias
+model.diffusion_model.double_blocks.17.img_attn.qkv.weight
+model.diffusion_model.double_blocks.17.img_mlp.0.bias
+model.diffusion_model.double_blocks.17.img_mlp.0.weight
+model.diffusion_model.double_blocks.17.img_mlp.2.bias
+model.diffusion_model.double_blocks.17.img_mlp.2.weight
+model.diffusion_model.double_blocks.17.img_mod.lin.bias
+model.diffusion_model.double_blocks.17.img_mod.lin.weight
+model.diffusion_model.double_blocks.17.txt_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.17.txt_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.17.txt_attn.proj.bias
+model.diffusion_model.double_blocks.17.txt_attn.proj.weight
+model.diffusion_model.double_blocks.17.txt_attn.qkv.bias
+model.diffusion_model.double_blocks.17.txt_attn.qkv.weight
+model.diffusion_model.double_blocks.17.txt_mlp.0.bias
+model.diffusion_model.double_blocks.17.txt_mlp.0.weight
+model.diffusion_model.double_blocks.17.txt_mlp.2.bias
+model.diffusion_model.double_blocks.17.txt_mlp.2.weight
+model.diffusion_model.double_blocks.17.txt_mod.lin.bias
+model.diffusion_model.double_blocks.17.txt_mod.lin.weight
+model.diffusion_model.double_blocks.18.img_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.18.img_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.18.img_attn.proj.bias
+model.diffusion_model.double_blocks.18.img_attn.proj.weight
+model.diffusion_model.double_blocks.18.img_attn.qkv.bias
+model.diffusion_model.double_blocks.18.img_attn.qkv.weight
+model.diffusion_model.double_blocks.18.img_mlp.0.bias
+model.diffusion_model.double_blocks.18.img_mlp.0.weight
+model.diffusion_model.double_blocks.18.img_mlp.2.bias
+model.diffusion_model.double_blocks.18.img_mlp.2.weight
+model.diffusion_model.double_blocks.18.img_mod.lin.bias
+model.diffusion_model.double_blocks.18.img_mod.lin.weight
+model.diffusion_model.double_blocks.18.txt_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.18.txt_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.18.txt_attn.proj.bias
+model.diffusion_model.double_blocks.18.txt_attn.proj.weight
+model.diffusion_model.double_blocks.18.txt_attn.qkv.bias
+model.diffusion_model.double_blocks.18.txt_attn.qkv.weight
+model.diffusion_model.double_blocks.18.txt_mlp.0.bias
+model.diffusion_model.double_blocks.18.txt_mlp.0.weight
+model.diffusion_model.double_blocks.18.txt_mlp.2.bias
+model.diffusion_model.double_blocks.18.txt_mlp.2.weight
+model.diffusion_model.double_blocks.18.txt_mod.lin.bias
+model.diffusion_model.double_blocks.18.txt_mod.lin.weight
+model.diffusion_model.double_blocks.2.img_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.2.img_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.2.img_attn.proj.bias
+model.diffusion_model.double_blocks.2.img_attn.proj.weight
+model.diffusion_model.double_blocks.2.img_attn.qkv.bias
+model.diffusion_model.double_blocks.2.img_attn.qkv.weight
+model.diffusion_model.double_blocks.2.img_mlp.0.bias
+model.diffusion_model.double_blocks.2.img_mlp.0.weight
+model.diffusion_model.double_blocks.2.img_mlp.2.bias
+model.diffusion_model.double_blocks.2.img_mlp.2.weight
+model.diffusion_model.double_blocks.2.img_mod.lin.bias
+model.diffusion_model.double_blocks.2.img_mod.lin.weight
+model.diffusion_model.double_blocks.2.txt_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.2.txt_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.2.txt_attn.proj.bias
+model.diffusion_model.double_blocks.2.txt_attn.proj.weight
+model.diffusion_model.double_blocks.2.txt_attn.qkv.bias
+model.diffusion_model.double_blocks.2.txt_attn.qkv.weight
+model.diffusion_model.double_blocks.2.txt_mlp.0.bias
+model.diffusion_model.double_blocks.2.txt_mlp.0.weight
+model.diffusion_model.double_blocks.2.txt_mlp.2.bias
+model.diffusion_model.double_blocks.2.txt_mlp.2.weight
+model.diffusion_model.double_blocks.2.txt_mod.lin.bias
+model.diffusion_model.double_blocks.2.txt_mod.lin.weight
+model.diffusion_model.double_blocks.3.img_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.3.img_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.3.img_attn.proj.bias
+model.diffusion_model.double_blocks.3.img_attn.proj.weight
+model.diffusion_model.double_blocks.3.img_attn.qkv.bias
+model.diffusion_model.double_blocks.3.img_attn.qkv.weight
+model.diffusion_model.double_blocks.3.img_mlp.0.bias
+model.diffusion_model.double_blocks.3.img_mlp.0.weight
+model.diffusion_model.double_blocks.3.img_mlp.2.bias
+model.diffusion_model.double_blocks.3.img_mlp.2.weight
+model.diffusion_model.double_blocks.3.img_mod.lin.bias
+model.diffusion_model.double_blocks.3.img_mod.lin.weight
+model.diffusion_model.double_blocks.3.txt_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.3.txt_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.3.txt_attn.proj.bias
+model.diffusion_model.double_blocks.3.txt_attn.proj.weight
+model.diffusion_model.double_blocks.3.txt_attn.qkv.bias
+model.diffusion_model.double_blocks.3.txt_attn.qkv.weight
+model.diffusion_model.double_blocks.3.txt_mlp.0.bias
+model.diffusion_model.double_blocks.3.txt_mlp.0.weight
+model.diffusion_model.double_blocks.3.txt_mlp.2.bias
+model.diffusion_model.double_blocks.3.txt_mlp.2.weight
+model.diffusion_model.double_blocks.3.txt_mod.lin.bias
+model.diffusion_model.double_blocks.3.txt_mod.lin.weight
+model.diffusion_model.double_blocks.4.img_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.4.img_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.4.img_attn.proj.bias
+model.diffusion_model.double_blocks.4.img_attn.proj.weight
+model.diffusion_model.double_blocks.4.img_attn.qkv.bias
+model.diffusion_model.double_blocks.4.img_attn.qkv.weight
+model.diffusion_model.double_blocks.4.img_mlp.0.bias
+model.diffusion_model.double_blocks.4.img_mlp.0.weight
+model.diffusion_model.double_blocks.4.img_mlp.2.bias
+model.diffusion_model.double_blocks.4.img_mlp.2.weight
+model.diffusion_model.double_blocks.4.img_mod.lin.bias
+model.diffusion_model.double_blocks.4.img_mod.lin.weight
+model.diffusion_model.double_blocks.4.txt_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.4.txt_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.4.txt_attn.proj.bias
+model.diffusion_model.double_blocks.4.txt_attn.proj.weight
+model.diffusion_model.double_blocks.4.txt_attn.qkv.bias
+model.diffusion_model.double_blocks.4.txt_attn.qkv.weight
+model.diffusion_model.double_blocks.4.txt_mlp.0.bias
+model.diffusion_model.double_blocks.4.txt_mlp.0.weight
+model.diffusion_model.double_blocks.4.txt_mlp.2.bias
+model.diffusion_model.double_blocks.4.txt_mlp.2.weight
+model.diffusion_model.double_blocks.4.txt_mod.lin.bias
+model.diffusion_model.double_blocks.4.txt_mod.lin.weight
+model.diffusion_model.double_blocks.5.img_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.5.img_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.5.img_attn.proj.bias
+model.diffusion_model.double_blocks.5.img_attn.proj.weight
+model.diffusion_model.double_blocks.5.img_attn.qkv.bias
+model.diffusion_model.double_blocks.5.img_attn.qkv.weight
+model.diffusion_model.double_blocks.5.img_mlp.0.bias
+model.diffusion_model.double_blocks.5.img_mlp.0.weight
+model.diffusion_model.double_blocks.5.img_mlp.2.bias
+model.diffusion_model.double_blocks.5.img_mlp.2.weight
+model.diffusion_model.double_blocks.5.img_mod.lin.bias
+model.diffusion_model.double_blocks.5.img_mod.lin.weight
+model.diffusion_model.double_blocks.5.txt_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.5.txt_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.5.txt_attn.proj.bias
+model.diffusion_model.double_blocks.5.txt_attn.proj.weight
+model.diffusion_model.double_blocks.5.txt_attn.qkv.bias
+model.diffusion_model.double_blocks.5.txt_attn.qkv.weight
+model.diffusion_model.double_blocks.5.txt_mlp.0.bias
+model.diffusion_model.double_blocks.5.txt_mlp.0.weight
+model.diffusion_model.double_blocks.5.txt_mlp.2.bias
+model.diffusion_model.double_blocks.5.txt_mlp.2.weight
+model.diffusion_model.double_blocks.5.txt_mod.lin.bias
+model.diffusion_model.double_blocks.5.txt_mod.lin.weight
+model.diffusion_model.double_blocks.6.img_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.6.img_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.6.img_attn.proj.bias
+model.diffusion_model.double_blocks.6.img_attn.proj.weight
+model.diffusion_model.double_blocks.6.img_attn.qkv.bias
+model.diffusion_model.double_blocks.6.img_attn.qkv.weight
+model.diffusion_model.double_blocks.6.img_mlp.0.bias
+model.diffusion_model.double_blocks.6.img_mlp.0.weight
+model.diffusion_model.double_blocks.6.img_mlp.2.bias
+model.diffusion_model.double_blocks.6.img_mlp.2.weight
+model.diffusion_model.double_blocks.6.img_mod.lin.bias
+model.diffusion_model.double_blocks.6.img_mod.lin.weight
+model.diffusion_model.double_blocks.6.txt_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.6.txt_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.6.txt_attn.proj.bias
+model.diffusion_model.double_blocks.6.txt_attn.proj.weight
+model.diffusion_model.double_blocks.6.txt_attn.qkv.bias
+model.diffusion_model.double_blocks.6.txt_attn.qkv.weight
+model.diffusion_model.double_blocks.6.txt_mlp.0.bias
+model.diffusion_model.double_blocks.6.txt_mlp.0.weight
+model.diffusion_model.double_blocks.6.txt_mlp.2.bias
+model.diffusion_model.double_blocks.6.txt_mlp.2.weight
+model.diffusion_model.double_blocks.6.txt_mod.lin.bias
+model.diffusion_model.double_blocks.6.txt_mod.lin.weight
+model.diffusion_model.double_blocks.7.img_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.7.img_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.7.img_attn.proj.bias
+model.diffusion_model.double_blocks.7.img_attn.proj.weight
+model.diffusion_model.double_blocks.7.img_attn.qkv.bias
+model.diffusion_model.double_blocks.7.img_attn.qkv.weight
+model.diffusion_model.double_blocks.7.img_mlp.0.bias
+model.diffusion_model.double_blocks.7.img_mlp.0.weight
+model.diffusion_model.double_blocks.7.img_mlp.2.bias
+model.diffusion_model.double_blocks.7.img_mlp.2.weight
+model.diffusion_model.double_blocks.7.img_mod.lin.bias
+model.diffusion_model.double_blocks.7.img_mod.lin.weight
+model.diffusion_model.double_blocks.7.txt_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.7.txt_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.7.txt_attn.proj.bias
+model.diffusion_model.double_blocks.7.txt_attn.proj.weight
+model.diffusion_model.double_blocks.7.txt_attn.qkv.bias
+model.diffusion_model.double_blocks.7.txt_attn.qkv.weight
+model.diffusion_model.double_blocks.7.txt_mlp.0.bias
+model.diffusion_model.double_blocks.7.txt_mlp.0.weight
+model.diffusion_model.double_blocks.7.txt_mlp.2.bias
+model.diffusion_model.double_blocks.7.txt_mlp.2.weight
+model.diffusion_model.double_blocks.7.txt_mod.lin.bias
+model.diffusion_model.double_blocks.7.txt_mod.lin.weight
+model.diffusion_model.double_blocks.8.img_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.8.img_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.8.img_attn.proj.bias
+model.diffusion_model.double_blocks.8.img_attn.proj.weight
+model.diffusion_model.double_blocks.8.img_attn.qkv.bias
+model.diffusion_model.double_blocks.8.img_attn.qkv.weight
+model.diffusion_model.double_blocks.8.img_mlp.0.bias
+model.diffusion_model.double_blocks.8.img_mlp.0.weight
+model.diffusion_model.double_blocks.8.img_mlp.2.bias
+model.diffusion_model.double_blocks.8.img_mlp.2.weight
+model.diffusion_model.double_blocks.8.img_mod.lin.bias
+model.diffusion_model.double_blocks.8.img_mod.lin.weight
+model.diffusion_model.double_blocks.8.txt_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.8.txt_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.8.txt_attn.proj.bias
+model.diffusion_model.double_blocks.8.txt_attn.proj.weight
+model.diffusion_model.double_blocks.8.txt_attn.qkv.bias
+model.diffusion_model.double_blocks.8.txt_attn.qkv.weight
+model.diffusion_model.double_blocks.8.txt_mlp.0.bias
+model.diffusion_model.double_blocks.8.txt_mlp.0.weight
+model.diffusion_model.double_blocks.8.txt_mlp.2.bias
+model.diffusion_model.double_blocks.8.txt_mlp.2.weight
+model.diffusion_model.double_blocks.8.txt_mod.lin.bias
+model.diffusion_model.double_blocks.8.txt_mod.lin.weight
+model.diffusion_model.double_blocks.9.img_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.9.img_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.9.img_attn.proj.bias
+model.diffusion_model.double_blocks.9.img_attn.proj.weight
+model.diffusion_model.double_blocks.9.img_attn.qkv.bias
+model.diffusion_model.double_blocks.9.img_attn.qkv.weight
+model.diffusion_model.double_blocks.9.img_mlp.0.bias
+model.diffusion_model.double_blocks.9.img_mlp.0.weight
+model.diffusion_model.double_blocks.9.img_mlp.2.bias
+model.diffusion_model.double_blocks.9.img_mlp.2.weight
+model.diffusion_model.double_blocks.9.img_mod.lin.bias
+model.diffusion_model.double_blocks.9.img_mod.lin.weight
+model.diffusion_model.double_blocks.9.txt_attn.norm.key_norm.scale
+model.diffusion_model.double_blocks.9.txt_attn.norm.query_norm.scale
+model.diffusion_model.double_blocks.9.txt_attn.proj.bias
+model.diffusion_model.double_blocks.9.txt_attn.proj.weight
+model.diffusion_model.double_blocks.9.txt_attn.qkv.bias
+model.diffusion_model.double_blocks.9.txt_attn.qkv.weight
+model.diffusion_model.double_blocks.9.txt_mlp.0.bias
+model.diffusion_model.double_blocks.9.txt_mlp.0.weight
+model.diffusion_model.double_blocks.9.txt_mlp.2.bias
+model.diffusion_model.double_blocks.9.txt_mlp.2.weight
+model.diffusion_model.double_blocks.9.txt_mod.lin.bias
+model.diffusion_model.double_blocks.9.txt_mod.lin.weight
+model.diffusion_model.final_layer.adaLN_modulation.1.bias
+model.diffusion_model.final_layer.adaLN_modulation.1.weight
+model.diffusion_model.final_layer.linear.bias
+model.diffusion_model.final_layer.linear.weight
+model.diffusion_model.guidance_in.in_layer.bias
+model.diffusion_model.guidance_in.in_layer.weight
+model.diffusion_model.guidance_in.out_layer.bias
+model.diffusion_model.guidance_in.out_layer.weight
+model.diffusion_model.img_in.bias
+model.diffusion_model.img_in.weight
+model.diffusion_model.single_blocks.0.linear1.bias
+model.diffusion_model.single_blocks.0.linear1.weight
+model.diffusion_model.single_blocks.0.linear2.bias
+model.diffusion_model.single_blocks.0.linear2.weight
+model.diffusion_model.single_blocks.0.modulation.lin.bias
+model.diffusion_model.single_blocks.0.modulation.lin.weight
+model.diffusion_model.single_blocks.0.norm.key_norm.scale
+model.diffusion_model.single_blocks.0.norm.query_norm.scale
+model.diffusion_model.single_blocks.1.linear1.bias
+model.diffusion_model.single_blocks.1.linear1.weight
+model.diffusion_model.single_blocks.1.linear2.bias
+model.diffusion_model.single_blocks.1.linear2.weight
+model.diffusion_model.single_blocks.1.modulation.lin.bias
+model.diffusion_model.single_blocks.1.modulation.lin.weight
+model.diffusion_model.single_blocks.1.norm.key_norm.scale
+model.diffusion_model.single_blocks.1.norm.query_norm.scale
+model.diffusion_model.single_blocks.10.linear1.bias
+model.diffusion_model.single_blocks.10.linear1.weight
+model.diffusion_model.single_blocks.10.linear2.bias
+model.diffusion_model.single_blocks.10.linear2.weight
+model.diffusion_model.single_blocks.10.modulation.lin.bias
+model.diffusion_model.single_blocks.10.modulation.lin.weight
+model.diffusion_model.single_blocks.10.norm.key_norm.scale
+model.diffusion_model.single_blocks.10.norm.query_norm.scale
+model.diffusion_model.single_blocks.11.linear1.bias
+model.diffusion_model.single_blocks.11.linear1.weight
+model.diffusion_model.single_blocks.11.linear2.bias
+model.diffusion_model.single_blocks.11.linear2.weight
+model.diffusion_model.single_blocks.11.modulation.lin.bias
+model.diffusion_model.single_blocks.11.modulation.lin.weight
+model.diffusion_model.single_blocks.11.norm.key_norm.scale
+model.diffusion_model.single_blocks.11.norm.query_norm.scale
+model.diffusion_model.single_blocks.12.linear1.bias
+model.diffusion_model.single_blocks.12.linear1.weight
+model.diffusion_model.single_blocks.12.linear2.bias
+model.diffusion_model.single_blocks.12.linear2.weight
+model.diffusion_model.single_blocks.12.modulation.lin.bias
+model.diffusion_model.single_blocks.12.modulation.lin.weight
+model.diffusion_model.single_blocks.12.norm.key_norm.scale
+model.diffusion_model.single_blocks.12.norm.query_norm.scale
+model.diffusion_model.single_blocks.13.linear1.bias
+model.diffusion_model.single_blocks.13.linear1.weight
+model.diffusion_model.single_blocks.13.linear2.bias
+model.diffusion_model.single_blocks.13.linear2.weight
+model.diffusion_model.single_blocks.13.modulation.lin.bias
+model.diffusion_model.single_blocks.13.modulation.lin.weight
+model.diffusion_model.single_blocks.13.norm.key_norm.scale
+model.diffusion_model.single_blocks.13.norm.query_norm.scale
+model.diffusion_model.single_blocks.14.linear1.bias
+model.diffusion_model.single_blocks.14.linear1.weight
+model.diffusion_model.single_blocks.14.linear2.bias
+model.diffusion_model.single_blocks.14.linear2.weight
+model.diffusion_model.single_blocks.14.modulation.lin.bias
+model.diffusion_model.single_blocks.14.modulation.lin.weight
+model.diffusion_model.single_blocks.14.norm.key_norm.scale
+model.diffusion_model.single_blocks.14.norm.query_norm.scale
+model.diffusion_model.single_blocks.15.linear1.bias
+model.diffusion_model.single_blocks.15.linear1.weight
+model.diffusion_model.single_blocks.15.linear2.bias
+model.diffusion_model.single_blocks.15.linear2.weight
+model.diffusion_model.single_blocks.15.modulation.lin.bias
+model.diffusion_model.single_blocks.15.modulation.lin.weight
+model.diffusion_model.single_blocks.15.norm.key_norm.scale
+model.diffusion_model.single_blocks.15.norm.query_norm.scale
+model.diffusion_model.single_blocks.16.linear1.bias
+model.diffusion_model.single_blocks.16.linear1.weight
+model.diffusion_model.single_blocks.16.linear2.bias
+model.diffusion_model.single_blocks.16.linear2.weight
+model.diffusion_model.single_blocks.16.modulation.lin.bias
+model.diffusion_model.single_blocks.16.modulation.lin.weight
+model.diffusion_model.single_blocks.16.norm.key_norm.scale
+model.diffusion_model.single_blocks.16.norm.query_norm.scale
+model.diffusion_model.single_blocks.17.linear1.bias
+model.diffusion_model.single_blocks.17.linear1.weight
+model.diffusion_model.single_blocks.17.linear2.bias
+model.diffusion_model.single_blocks.17.linear2.weight
+model.diffusion_model.single_blocks.17.modulation.lin.bias
+model.diffusion_model.single_blocks.17.modulation.lin.weight
+model.diffusion_model.single_blocks.17.norm.key_norm.scale
+model.diffusion_model.single_blocks.17.norm.query_norm.scale
+model.diffusion_model.single_blocks.18.linear1.bias
+model.diffusion_model.single_blocks.18.linear1.weight
+model.diffusion_model.single_blocks.18.linear2.bias
+model.diffusion_model.single_blocks.18.linear2.weight
+model.diffusion_model.single_blocks.18.modulation.lin.bias
+model.diffusion_model.single_blocks.18.modulation.lin.weight
+model.diffusion_model.single_blocks.18.norm.key_norm.scale
+model.diffusion_model.single_blocks.18.norm.query_norm.scale
+model.diffusion_model.single_blocks.19.linear1.bias
+model.diffusion_model.single_blocks.19.linear1.weight
+model.diffusion_model.single_blocks.19.linear2.bias
+model.diffusion_model.single_blocks.19.linear2.weight
+model.diffusion_model.single_blocks.19.modulation.lin.bias
+model.diffusion_model.single_blocks.19.modulation.lin.weight
+model.diffusion_model.single_blocks.19.norm.key_norm.scale
+model.diffusion_model.single_blocks.19.norm.query_norm.scale
+model.diffusion_model.single_blocks.2.linear1.bias
+model.diffusion_model.single_blocks.2.linear1.weight
+model.diffusion_model.single_blocks.2.linear2.bias
+model.diffusion_model.single_blocks.2.linear2.weight
+model.diffusion_model.single_blocks.2.modulation.lin.bias
+model.diffusion_model.single_blocks.2.modulation.lin.weight
+model.diffusion_model.single_blocks.2.norm.key_norm.scale
+model.diffusion_model.single_blocks.2.norm.query_norm.scale
+model.diffusion_model.single_blocks.20.linear1.bias
+model.diffusion_model.single_blocks.20.linear1.weight
+model.diffusion_model.single_blocks.20.linear2.bias
+model.diffusion_model.single_blocks.20.linear2.weight
+model.diffusion_model.single_blocks.20.modulation.lin.bias
+model.diffusion_model.single_blocks.20.modulation.lin.weight
+model.diffusion_model.single_blocks.20.norm.key_norm.scale
+model.diffusion_model.single_blocks.20.norm.query_norm.scale
+model.diffusion_model.single_blocks.21.linear1.bias
+model.diffusion_model.single_blocks.21.linear1.weight
+model.diffusion_model.single_blocks.21.linear2.bias
+model.diffusion_model.single_blocks.21.linear2.weight
+model.diffusion_model.single_blocks.21.modulation.lin.bias
+model.diffusion_model.single_blocks.21.modulation.lin.weight
+model.diffusion_model.single_blocks.21.norm.key_norm.scale
+model.diffusion_model.single_blocks.21.norm.query_norm.scale
+model.diffusion_model.single_blocks.22.linear1.bias
+model.diffusion_model.single_blocks.22.linear1.weight
+model.diffusion_model.single_blocks.22.linear2.bias
+model.diffusion_model.single_blocks.22.linear2.weight
+model.diffusion_model.single_blocks.22.modulation.lin.bias
+model.diffusion_model.single_blocks.22.modulation.lin.weight
+model.diffusion_model.single_blocks.22.norm.key_norm.scale
+model.diffusion_model.single_blocks.22.norm.query_norm.scale
+model.diffusion_model.single_blocks.23.linear1.bias
+model.diffusion_model.single_blocks.23.linear1.weight
+model.diffusion_model.single_blocks.23.linear2.bias
+model.diffusion_model.single_blocks.23.linear2.weight
+model.diffusion_model.single_blocks.23.modulation.lin.bias
+model.diffusion_model.single_blocks.23.modulation.lin.weight
+model.diffusion_model.single_blocks.23.norm.key_norm.scale
+model.diffusion_model.single_blocks.23.norm.query_norm.scale
+model.diffusion_model.single_blocks.24.linear1.bias
+model.diffusion_model.single_blocks.24.linear1.weight
+model.diffusion_model.single_blocks.24.linear2.bias
+model.diffusion_model.single_blocks.24.linear2.weight
+model.diffusion_model.single_blocks.24.modulation.lin.bias
+model.diffusion_model.single_blocks.24.modulation.lin.weight
+model.diffusion_model.single_blocks.24.norm.key_norm.scale
+model.diffusion_model.single_blocks.24.norm.query_norm.scale
+model.diffusion_model.single_blocks.25.linear1.bias
+model.diffusion_model.single_blocks.25.linear1.weight
+model.diffusion_model.single_blocks.25.linear2.bias
+model.diffusion_model.single_blocks.25.linear2.weight
+model.diffusion_model.single_blocks.25.modulation.lin.bias
+model.diffusion_model.single_blocks.25.modulation.lin.weight
+model.diffusion_model.single_blocks.25.norm.key_norm.scale
+model.diffusion_model.single_blocks.25.norm.query_norm.scale
+model.diffusion_model.single_blocks.26.linear1.bias
+model.diffusion_model.single_blocks.26.linear1.weight
+model.diffusion_model.single_blocks.26.linear2.bias
+model.diffusion_model.single_blocks.26.linear2.weight
+model.diffusion_model.single_blocks.26.modulation.lin.bias
+model.diffusion_model.single_blocks.26.modulation.lin.weight
+model.diffusion_model.single_blocks.26.norm.key_norm.scale
+model.diffusion_model.single_blocks.26.norm.query_norm.scale
+model.diffusion_model.single_blocks.27.linear1.bias
+model.diffusion_model.single_blocks.27.linear1.weight
+model.diffusion_model.single_blocks.27.linear2.bias
+model.diffusion_model.single_blocks.27.linear2.weight
+model.diffusion_model.single_blocks.27.modulation.lin.bias
+model.diffusion_model.single_blocks.27.modulation.lin.weight
+model.diffusion_model.single_blocks.27.norm.key_norm.scale
+model.diffusion_model.single_blocks.27.norm.query_norm.scale
+model.diffusion_model.single_blocks.28.linear1.bias
+model.diffusion_model.single_blocks.28.linear1.weight
+model.diffusion_model.single_blocks.28.linear2.bias
+model.diffusion_model.single_blocks.28.linear2.weight
+model.diffusion_model.single_blocks.28.modulation.lin.bias
+model.diffusion_model.single_blocks.28.modulation.lin.weight
+model.diffusion_model.single_blocks.28.norm.key_norm.scale
+model.diffusion_model.single_blocks.28.norm.query_norm.scale
+model.diffusion_model.single_blocks.29.linear1.bias
+model.diffusion_model.single_blocks.29.linear1.weight
+model.diffusion_model.single_blocks.29.linear2.bias
+model.diffusion_model.single_blocks.29.linear2.weight
+model.diffusion_model.single_blocks.29.modulation.lin.bias
+model.diffusion_model.single_blocks.29.modulation.lin.weight
+model.diffusion_model.single_blocks.29.norm.key_norm.scale
+model.diffusion_model.single_blocks.29.norm.query_norm.scale
+model.diffusion_model.single_blocks.3.linear1.bias
+model.diffusion_model.single_blocks.3.linear1.weight
+model.diffusion_model.single_blocks.3.linear2.bias
+model.diffusion_model.single_blocks.3.linear2.weight
+model.diffusion_model.single_blocks.3.modulation.lin.bias
+model.diffusion_model.single_blocks.3.modulation.lin.weight
+model.diffusion_model.single_blocks.3.norm.key_norm.scale
+model.diffusion_model.single_blocks.3.norm.query_norm.scale
+model.diffusion_model.single_blocks.30.linear1.bias
+model.diffusion_model.single_blocks.30.linear1.weight
+model.diffusion_model.single_blocks.30.linear2.bias
+model.diffusion_model.single_blocks.30.linear2.weight
+model.diffusion_model.single_blocks.30.modulation.lin.bias
+model.diffusion_model.single_blocks.30.modulation.lin.weight
+model.diffusion_model.single_blocks.30.norm.key_norm.scale
+model.diffusion_model.single_blocks.30.norm.query_norm.scale
+model.diffusion_model.single_blocks.31.linear1.bias
+model.diffusion_model.single_blocks.31.linear1.weight
+model.diffusion_model.single_blocks.31.linear2.bias
+model.diffusion_model.single_blocks.31.linear2.weight
+model.diffusion_model.single_blocks.31.modulation.lin.bias
+model.diffusion_model.single_blocks.31.modulation.lin.weight
+model.diffusion_model.single_blocks.31.norm.key_norm.scale
+model.diffusion_model.single_blocks.31.norm.query_norm.scale
+model.diffusion_model.single_blocks.32.linear1.bias
+model.diffusion_model.single_blocks.32.linear1.weight
+model.diffusion_model.single_blocks.32.linear2.bias
+model.diffusion_model.single_blocks.32.linear2.weight
+model.diffusion_model.single_blocks.32.modulation.lin.bias
+model.diffusion_model.single_blocks.32.modulation.lin.weight
+model.diffusion_model.single_blocks.32.norm.key_norm.scale
+model.diffusion_model.single_blocks.32.norm.query_norm.scale
+model.diffusion_model.single_blocks.33.linear1.bias
+model.diffusion_model.single_blocks.33.linear1.weight
+model.diffusion_model.single_blocks.33.linear2.bias
+model.diffusion_model.single_blocks.33.linear2.weight
+model.diffusion_model.single_blocks.33.modulation.lin.bias
+model.diffusion_model.single_blocks.33.modulation.lin.weight
+model.diffusion_model.single_blocks.33.norm.key_norm.scale
+model.diffusion_model.single_blocks.33.norm.query_norm.scale
+model.diffusion_model.single_blocks.34.linear1.bias
+model.diffusion_model.single_blocks.34.linear1.weight
+model.diffusion_model.single_blocks.34.linear2.bias
+model.diffusion_model.single_blocks.34.linear2.weight
+model.diffusion_model.single_blocks.34.modulation.lin.bias
+model.diffusion_model.single_blocks.34.modulation.lin.weight
+model.diffusion_model.single_blocks.34.norm.key_norm.scale
+model.diffusion_model.single_blocks.34.norm.query_norm.scale
+model.diffusion_model.single_blocks.35.linear1.bias
+model.diffusion_model.single_blocks.35.linear1.weight
+model.diffusion_model.single_blocks.35.linear2.bias
+model.diffusion_model.single_blocks.35.linear2.weight
+model.diffusion_model.single_blocks.35.modulation.lin.bias
+model.diffusion_model.single_blocks.35.modulation.lin.weight
+model.diffusion_model.single_blocks.35.norm.key_norm.scale
+model.diffusion_model.single_blocks.35.norm.query_norm.scale
+model.diffusion_model.single_blocks.36.linear1.bias
+model.diffusion_model.single_blocks.36.linear1.weight
+model.diffusion_model.single_blocks.36.linear2.bias
+model.diffusion_model.single_blocks.36.linear2.weight
+model.diffusion_model.single_blocks.36.modulation.lin.bias
+model.diffusion_model.single_blocks.36.modulation.lin.weight
+model.diffusion_model.single_blocks.36.norm.key_norm.scale
+model.diffusion_model.single_blocks.36.norm.query_norm.scale
+model.diffusion_model.single_blocks.37.linear1.bias
+model.diffusion_model.single_blocks.37.linear1.weight
+model.diffusion_model.single_blocks.37.linear2.bias
+model.diffusion_model.single_blocks.37.linear2.weight
+model.diffusion_model.single_blocks.37.modulation.lin.bias
+model.diffusion_model.single_blocks.37.modulation.lin.weight
+model.diffusion_model.single_blocks.37.norm.key_norm.scale
+model.diffusion_model.single_blocks.37.norm.query_norm.scale
+model.diffusion_model.single_blocks.4.linear1.bias
+model.diffusion_model.single_blocks.4.linear1.weight
+model.diffusion_model.single_blocks.4.linear2.bias
+model.diffusion_model.single_blocks.4.linear2.weight
+model.diffusion_model.single_blocks.4.modulation.lin.bias
+model.diffusion_model.single_blocks.4.modulation.lin.weight
+model.diffusion_model.single_blocks.4.norm.key_norm.scale
+model.diffusion_model.single_blocks.4.norm.query_norm.scale
+model.diffusion_model.single_blocks.5.linear1.bias
+model.diffusion_model.single_blocks.5.linear1.weight
+model.diffusion_model.single_blocks.5.linear2.bias
+model.diffusion_model.single_blocks.5.linear2.weight
+model.diffusion_model.single_blocks.5.modulation.lin.bias
+model.diffusion_model.single_blocks.5.modulation.lin.weight
+model.diffusion_model.single_blocks.5.norm.key_norm.scale
+model.diffusion_model.single_blocks.5.norm.query_norm.scale
+model.diffusion_model.single_blocks.6.linear1.bias
+model.diffusion_model.single_blocks.6.linear1.weight
+model.diffusion_model.single_blocks.6.linear2.bias
+model.diffusion_model.single_blocks.6.linear2.weight
+model.diffusion_model.single_blocks.6.modulation.lin.bias
+model.diffusion_model.single_blocks.6.modulation.lin.weight
+model.diffusion_model.single_blocks.6.norm.key_norm.scale
+model.diffusion_model.single_blocks.6.norm.query_norm.scale
+model.diffusion_model.single_blocks.7.linear1.bias
+model.diffusion_model.single_blocks.7.linear1.weight
+model.diffusion_model.single_blocks.7.linear2.bias
+model.diffusion_model.single_blocks.7.linear2.weight
+model.diffusion_model.single_blocks.7.modulation.lin.bias
+model.diffusion_model.single_blocks.7.modulation.lin.weight
+model.diffusion_model.single_blocks.7.norm.key_norm.scale
+model.diffusion_model.single_blocks.7.norm.query_norm.scale
+model.diffusion_model.single_blocks.8.linear1.bias
+model.diffusion_model.single_blocks.8.linear1.weight
+model.diffusion_model.single_blocks.8.linear2.bias
+model.diffusion_model.single_blocks.8.linear2.weight
+model.diffusion_model.single_blocks.8.modulation.lin.bias
+model.diffusion_model.single_blocks.8.modulation.lin.weight
+model.diffusion_model.single_blocks.8.norm.key_norm.scale
+model.diffusion_model.single_blocks.8.norm.query_norm.scale
+model.diffusion_model.single_blocks.9.linear1.bias
+model.diffusion_model.single_blocks.9.linear1.weight
+model.diffusion_model.single_blocks.9.linear2.bias
+model.diffusion_model.single_blocks.9.linear2.weight
+model.diffusion_model.single_blocks.9.modulation.lin.bias
+model.diffusion_model.single_blocks.9.modulation.lin.weight
+model.diffusion_model.single_blocks.9.norm.key_norm.scale
+model.diffusion_model.single_blocks.9.norm.query_norm.scale
+model.diffusion_model.time_in.in_layer.bias
+model.diffusion_model.time_in.in_layer.weight
+model.diffusion_model.time_in.out_layer.bias
+model.diffusion_model.time_in.out_layer.weight
+model.diffusion_model.txt_in.bias
+model.diffusion_model.txt_in.weight
+model.diffusion_model.vector_in.in_layer.bias
+model.diffusion_model.vector_in.in_layer.weight
+model.diffusion_model.vector_in.out_layer.bias
+model.diffusion_model.vector_in.out_layer.weight
+text_encoders.clip_l.logit_scale
+text_encoders.clip_l.transformer.text_model.embeddings.position_embedding.weight
+text_encoders.clip_l.transformer.text_model.embeddings.token_embedding.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.0.layer_norm1.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.0.layer_norm1.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.0.layer_norm2.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.0.layer_norm2.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.0.mlp.fc1.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.0.mlp.fc1.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.0.mlp.fc2.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.0.mlp.fc2.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.0.self_attn.k_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.0.self_attn.k_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.0.self_attn.out_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.0.self_attn.out_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.0.self_attn.q_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.0.self_attn.q_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.0.self_attn.v_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.0.self_attn.v_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.1.layer_norm1.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.1.layer_norm1.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.1.layer_norm2.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.1.layer_norm2.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.1.mlp.fc1.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.1.mlp.fc1.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.1.mlp.fc2.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.1.mlp.fc2.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.1.self_attn.k_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.1.self_attn.k_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.1.self_attn.out_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.1.self_attn.out_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.1.self_attn.q_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.1.self_attn.q_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.1.self_attn.v_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.1.self_attn.v_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.10.layer_norm1.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.10.layer_norm1.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.10.layer_norm2.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.10.layer_norm2.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.10.mlp.fc1.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.10.mlp.fc1.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.10.mlp.fc2.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.10.mlp.fc2.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.10.self_attn.k_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.10.self_attn.k_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.10.self_attn.out_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.10.self_attn.out_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.10.self_attn.q_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.10.self_attn.q_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.10.self_attn.v_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.10.self_attn.v_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.11.layer_norm1.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.11.layer_norm1.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.11.layer_norm2.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.11.layer_norm2.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.11.mlp.fc1.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.11.mlp.fc1.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.11.mlp.fc2.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.11.mlp.fc2.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.11.self_attn.k_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.11.self_attn.k_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.11.self_attn.out_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.11.self_attn.out_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.11.self_attn.q_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.11.self_attn.q_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.11.self_attn.v_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.11.self_attn.v_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.2.layer_norm1.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.2.layer_norm1.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.2.layer_norm2.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.2.layer_norm2.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.2.mlp.fc1.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.2.mlp.fc1.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.2.mlp.fc2.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.2.mlp.fc2.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.2.self_attn.k_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.2.self_attn.k_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.2.self_attn.out_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.2.self_attn.out_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.2.self_attn.q_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.2.self_attn.q_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.2.self_attn.v_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.2.self_attn.v_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.3.layer_norm1.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.3.layer_norm1.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.3.layer_norm2.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.3.layer_norm2.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.3.mlp.fc1.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.3.mlp.fc1.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.3.mlp.fc2.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.3.mlp.fc2.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.3.self_attn.k_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.3.self_attn.k_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.3.self_attn.out_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.3.self_attn.out_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.3.self_attn.q_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.3.self_attn.q_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.3.self_attn.v_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.3.self_attn.v_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.4.layer_norm1.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.4.layer_norm1.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.4.layer_norm2.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.4.layer_norm2.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.4.mlp.fc1.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.4.mlp.fc1.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.4.mlp.fc2.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.4.mlp.fc2.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.4.self_attn.k_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.4.self_attn.k_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.4.self_attn.out_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.4.self_attn.out_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.4.self_attn.q_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.4.self_attn.q_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.4.self_attn.v_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.4.self_attn.v_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.5.layer_norm1.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.5.layer_norm1.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.5.layer_norm2.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.5.layer_norm2.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.5.mlp.fc1.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.5.mlp.fc1.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.5.mlp.fc2.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.5.mlp.fc2.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.5.self_attn.k_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.5.self_attn.k_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.5.self_attn.out_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.5.self_attn.out_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.5.self_attn.q_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.5.self_attn.q_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.5.self_attn.v_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.5.self_attn.v_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.6.layer_norm1.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.6.layer_norm1.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.6.layer_norm2.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.6.layer_norm2.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.6.mlp.fc1.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.6.mlp.fc1.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.6.mlp.fc2.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.6.mlp.fc2.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.6.self_attn.k_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.6.self_attn.k_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.6.self_attn.out_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.6.self_attn.out_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.6.self_attn.q_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.6.self_attn.q_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.6.self_attn.v_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.6.self_attn.v_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.7.layer_norm1.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.7.layer_norm1.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.7.layer_norm2.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.7.layer_norm2.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.7.mlp.fc1.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.7.mlp.fc1.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.7.mlp.fc2.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.7.mlp.fc2.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.7.self_attn.k_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.7.self_attn.k_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.7.self_attn.out_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.7.self_attn.out_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.7.self_attn.q_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.7.self_attn.q_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.7.self_attn.v_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.7.self_attn.v_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.8.layer_norm1.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.8.layer_norm1.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.8.layer_norm2.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.8.layer_norm2.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.8.mlp.fc1.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.8.mlp.fc1.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.8.mlp.fc2.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.8.mlp.fc2.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.8.self_attn.k_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.8.self_attn.k_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.8.self_attn.out_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.8.self_attn.out_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.8.self_attn.q_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.8.self_attn.q_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.8.self_attn.v_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.8.self_attn.v_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.9.layer_norm1.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.9.layer_norm1.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.9.layer_norm2.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.9.layer_norm2.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.9.mlp.fc1.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.9.mlp.fc1.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.9.mlp.fc2.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.9.mlp.fc2.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.9.self_attn.k_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.9.self_attn.k_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.9.self_attn.out_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.9.self_attn.out_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.9.self_attn.q_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.9.self_attn.q_proj.weight
+text_encoders.clip_l.transformer.text_model.encoder.layers.9.self_attn.v_proj.bias
+text_encoders.clip_l.transformer.text_model.encoder.layers.9.self_attn.v_proj.weight
+text_encoders.clip_l.transformer.text_model.final_layer_norm.bias
+text_encoders.clip_l.transformer.text_model.final_layer_norm.weight
+text_encoders.clip_l.transformer.text_projection.weight
+text_encoders.t5xxl.logit_scale
+text_encoders.t5xxl.transformer.encoder.block.0.layer.0.SelfAttention.k.weight
+text_encoders.t5xxl.transformer.encoder.block.0.layer.0.SelfAttention.o.weight
+text_encoders.t5xxl.transformer.encoder.block.0.layer.0.SelfAttention.q.weight
+text_encoders.t5xxl.transformer.encoder.block.0.layer.0.SelfAttention.relative_attention_bias.weight
+text_encoders.t5xxl.transformer.encoder.block.0.layer.0.SelfAttention.v.weight
+text_encoders.t5xxl.transformer.encoder.block.0.layer.0.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.0.layer.1.DenseReluDense.wi_0.weight
+text_encoders.t5xxl.transformer.encoder.block.0.layer.1.DenseReluDense.wi_1.weight
+text_encoders.t5xxl.transformer.encoder.block.0.layer.1.DenseReluDense.wo.weight
+text_encoders.t5xxl.transformer.encoder.block.0.layer.1.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.1.layer.0.SelfAttention.k.weight
+text_encoders.t5xxl.transformer.encoder.block.1.layer.0.SelfAttention.o.weight
+text_encoders.t5xxl.transformer.encoder.block.1.layer.0.SelfAttention.q.weight
+text_encoders.t5xxl.transformer.encoder.block.1.layer.0.SelfAttention.v.weight
+text_encoders.t5xxl.transformer.encoder.block.1.layer.0.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.1.layer.1.DenseReluDense.wi_0.weight
+text_encoders.t5xxl.transformer.encoder.block.1.layer.1.DenseReluDense.wi_1.weight
+text_encoders.t5xxl.transformer.encoder.block.1.layer.1.DenseReluDense.wo.weight
+text_encoders.t5xxl.transformer.encoder.block.1.layer.1.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.10.layer.0.SelfAttention.k.weight
+text_encoders.t5xxl.transformer.encoder.block.10.layer.0.SelfAttention.o.weight
+text_encoders.t5xxl.transformer.encoder.block.10.layer.0.SelfAttention.q.weight
+text_encoders.t5xxl.transformer.encoder.block.10.layer.0.SelfAttention.v.weight
+text_encoders.t5xxl.transformer.encoder.block.10.layer.0.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.10.layer.1.DenseReluDense.wi_0.weight
+text_encoders.t5xxl.transformer.encoder.block.10.layer.1.DenseReluDense.wi_1.weight
+text_encoders.t5xxl.transformer.encoder.block.10.layer.1.DenseReluDense.wo.weight
+text_encoders.t5xxl.transformer.encoder.block.10.layer.1.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.11.layer.0.SelfAttention.k.weight
+text_encoders.t5xxl.transformer.encoder.block.11.layer.0.SelfAttention.o.weight
+text_encoders.t5xxl.transformer.encoder.block.11.layer.0.SelfAttention.q.weight
+text_encoders.t5xxl.transformer.encoder.block.11.layer.0.SelfAttention.v.weight
+text_encoders.t5xxl.transformer.encoder.block.11.layer.0.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.11.layer.1.DenseReluDense.wi_0.weight
+text_encoders.t5xxl.transformer.encoder.block.11.layer.1.DenseReluDense.wi_1.weight
+text_encoders.t5xxl.transformer.encoder.block.11.layer.1.DenseReluDense.wo.weight
+text_encoders.t5xxl.transformer.encoder.block.11.layer.1.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.12.layer.0.SelfAttention.k.weight
+text_encoders.t5xxl.transformer.encoder.block.12.layer.0.SelfAttention.o.weight
+text_encoders.t5xxl.transformer.encoder.block.12.layer.0.SelfAttention.q.weight
+text_encoders.t5xxl.transformer.encoder.block.12.layer.0.SelfAttention.v.weight
+text_encoders.t5xxl.transformer.encoder.block.12.layer.0.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.12.layer.1.DenseReluDense.wi_0.weight
+text_encoders.t5xxl.transformer.encoder.block.12.layer.1.DenseReluDense.wi_1.weight
+text_encoders.t5xxl.transformer.encoder.block.12.layer.1.DenseReluDense.wo.weight
+text_encoders.t5xxl.transformer.encoder.block.12.layer.1.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.13.layer.0.SelfAttention.k.weight
+text_encoders.t5xxl.transformer.encoder.block.13.layer.0.SelfAttention.o.weight
+text_encoders.t5xxl.transformer.encoder.block.13.layer.0.SelfAttention.q.weight
+text_encoders.t5xxl.transformer.encoder.block.13.layer.0.SelfAttention.v.weight
+text_encoders.t5xxl.transformer.encoder.block.13.layer.0.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.13.layer.1.DenseReluDense.wi_0.weight
+text_encoders.t5xxl.transformer.encoder.block.13.layer.1.DenseReluDense.wi_1.weight
+text_encoders.t5xxl.transformer.encoder.block.13.layer.1.DenseReluDense.wo.weight
+text_encoders.t5xxl.transformer.encoder.block.13.layer.1.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.14.layer.0.SelfAttention.k.weight
+text_encoders.t5xxl.transformer.encoder.block.14.layer.0.SelfAttention.o.weight
+text_encoders.t5xxl.transformer.encoder.block.14.layer.0.SelfAttention.q.weight
+text_encoders.t5xxl.transformer.encoder.block.14.layer.0.SelfAttention.v.weight
+text_encoders.t5xxl.transformer.encoder.block.14.layer.0.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.14.layer.1.DenseReluDense.wi_0.weight
+text_encoders.t5xxl.transformer.encoder.block.14.layer.1.DenseReluDense.wi_1.weight
+text_encoders.t5xxl.transformer.encoder.block.14.layer.1.DenseReluDense.wo.weight
+text_encoders.t5xxl.transformer.encoder.block.14.layer.1.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.15.layer.0.SelfAttention.k.weight
+text_encoders.t5xxl.transformer.encoder.block.15.layer.0.SelfAttention.o.weight
+text_encoders.t5xxl.transformer.encoder.block.15.layer.0.SelfAttention.q.weight
+text_encoders.t5xxl.transformer.encoder.block.15.layer.0.SelfAttention.v.weight
+text_encoders.t5xxl.transformer.encoder.block.15.layer.0.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.15.layer.1.DenseReluDense.wi_0.weight
+text_encoders.t5xxl.transformer.encoder.block.15.layer.1.DenseReluDense.wi_1.weight
+text_encoders.t5xxl.transformer.encoder.block.15.layer.1.DenseReluDense.wo.weight
+text_encoders.t5xxl.transformer.encoder.block.15.layer.1.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.16.layer.0.SelfAttention.k.weight
+text_encoders.t5xxl.transformer.encoder.block.16.layer.0.SelfAttention.o.weight
+text_encoders.t5xxl.transformer.encoder.block.16.layer.0.SelfAttention.q.weight
+text_encoders.t5xxl.transformer.encoder.block.16.layer.0.SelfAttention.v.weight
+text_encoders.t5xxl.transformer.encoder.block.16.layer.0.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.16.layer.1.DenseReluDense.wi_0.weight
+text_encoders.t5xxl.transformer.encoder.block.16.layer.1.DenseReluDense.wi_1.weight
+text_encoders.t5xxl.transformer.encoder.block.16.layer.1.DenseReluDense.wo.weight
+text_encoders.t5xxl.transformer.encoder.block.16.layer.1.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.17.layer.0.SelfAttention.k.weight
+text_encoders.t5xxl.transformer.encoder.block.17.layer.0.SelfAttention.o.weight
+text_encoders.t5xxl.transformer.encoder.block.17.layer.0.SelfAttention.q.weight
+text_encoders.t5xxl.transformer.encoder.block.17.layer.0.SelfAttention.v.weight
+text_encoders.t5xxl.transformer.encoder.block.17.layer.0.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.17.layer.1.DenseReluDense.wi_0.weight
+text_encoders.t5xxl.transformer.encoder.block.17.layer.1.DenseReluDense.wi_1.weight
+text_encoders.t5xxl.transformer.encoder.block.17.layer.1.DenseReluDense.wo.weight
+text_encoders.t5xxl.transformer.encoder.block.17.layer.1.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.18.layer.0.SelfAttention.k.weight
+text_encoders.t5xxl.transformer.encoder.block.18.layer.0.SelfAttention.o.weight
+text_encoders.t5xxl.transformer.encoder.block.18.layer.0.SelfAttention.q.weight
+text_encoders.t5xxl.transformer.encoder.block.18.layer.0.SelfAttention.v.weight
+text_encoders.t5xxl.transformer.encoder.block.18.layer.0.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.18.layer.1.DenseReluDense.wi_0.weight
+text_encoders.t5xxl.transformer.encoder.block.18.layer.1.DenseReluDense.wi_1.weight
+text_encoders.t5xxl.transformer.encoder.block.18.layer.1.DenseReluDense.wo.weight
+text_encoders.t5xxl.transformer.encoder.block.18.layer.1.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.19.layer.0.SelfAttention.k.weight
+text_encoders.t5xxl.transformer.encoder.block.19.layer.0.SelfAttention.o.weight
+text_encoders.t5xxl.transformer.encoder.block.19.layer.0.SelfAttention.q.weight
+text_encoders.t5xxl.transformer.encoder.block.19.layer.0.SelfAttention.v.weight
+text_encoders.t5xxl.transformer.encoder.block.19.layer.0.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.19.layer.1.DenseReluDense.wi_0.weight
+text_encoders.t5xxl.transformer.encoder.block.19.layer.1.DenseReluDense.wi_1.weight
+text_encoders.t5xxl.transformer.encoder.block.19.layer.1.DenseReluDense.wo.weight
+text_encoders.t5xxl.transformer.encoder.block.19.layer.1.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.2.layer.0.SelfAttention.k.weight
+text_encoders.t5xxl.transformer.encoder.block.2.layer.0.SelfAttention.o.weight
+text_encoders.t5xxl.transformer.encoder.block.2.layer.0.SelfAttention.q.weight
+text_encoders.t5xxl.transformer.encoder.block.2.layer.0.SelfAttention.v.weight
+text_encoders.t5xxl.transformer.encoder.block.2.layer.0.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.2.layer.1.DenseReluDense.wi_0.weight
+text_encoders.t5xxl.transformer.encoder.block.2.layer.1.DenseReluDense.wi_1.weight
+text_encoders.t5xxl.transformer.encoder.block.2.layer.1.DenseReluDense.wo.weight
+text_encoders.t5xxl.transformer.encoder.block.2.layer.1.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.20.layer.0.SelfAttention.k.weight
+text_encoders.t5xxl.transformer.encoder.block.20.layer.0.SelfAttention.o.weight
+text_encoders.t5xxl.transformer.encoder.block.20.layer.0.SelfAttention.q.weight
+text_encoders.t5xxl.transformer.encoder.block.20.layer.0.SelfAttention.v.weight
+text_encoders.t5xxl.transformer.encoder.block.20.layer.0.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.20.layer.1.DenseReluDense.wi_0.weight
+text_encoders.t5xxl.transformer.encoder.block.20.layer.1.DenseReluDense.wi_1.weight
+text_encoders.t5xxl.transformer.encoder.block.20.layer.1.DenseReluDense.wo.weight
+text_encoders.t5xxl.transformer.encoder.block.20.layer.1.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.21.layer.0.SelfAttention.k.weight
+text_encoders.t5xxl.transformer.encoder.block.21.layer.0.SelfAttention.o.weight
+text_encoders.t5xxl.transformer.encoder.block.21.layer.0.SelfAttention.q.weight
+text_encoders.t5xxl.transformer.encoder.block.21.layer.0.SelfAttention.v.weight
+text_encoders.t5xxl.transformer.encoder.block.21.layer.0.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.21.layer.1.DenseReluDense.wi_0.weight
+text_encoders.t5xxl.transformer.encoder.block.21.layer.1.DenseReluDense.wi_1.weight
+text_encoders.t5xxl.transformer.encoder.block.21.layer.1.DenseReluDense.wo.weight
+text_encoders.t5xxl.transformer.encoder.block.21.layer.1.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.22.layer.0.SelfAttention.k.weight
+text_encoders.t5xxl.transformer.encoder.block.22.layer.0.SelfAttention.o.weight
+text_encoders.t5xxl.transformer.encoder.block.22.layer.0.SelfAttention.q.weight
+text_encoders.t5xxl.transformer.encoder.block.22.layer.0.SelfAttention.v.weight
+text_encoders.t5xxl.transformer.encoder.block.22.layer.0.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.22.layer.1.DenseReluDense.wi_0.weight
+text_encoders.t5xxl.transformer.encoder.block.22.layer.1.DenseReluDense.wi_1.weight
+text_encoders.t5xxl.transformer.encoder.block.22.layer.1.DenseReluDense.wo.weight
+text_encoders.t5xxl.transformer.encoder.block.22.layer.1.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.23.layer.0.SelfAttention.k.weight
+text_encoders.t5xxl.transformer.encoder.block.23.layer.0.SelfAttention.o.weight
+text_encoders.t5xxl.transformer.encoder.block.23.layer.0.SelfAttention.q.weight
+text_encoders.t5xxl.transformer.encoder.block.23.layer.0.SelfAttention.v.weight
+text_encoders.t5xxl.transformer.encoder.block.23.layer.0.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.23.layer.1.DenseReluDense.wi_0.weight
+text_encoders.t5xxl.transformer.encoder.block.23.layer.1.DenseReluDense.wi_1.weight
+text_encoders.t5xxl.transformer.encoder.block.23.layer.1.DenseReluDense.wo.weight
+text_encoders.t5xxl.transformer.encoder.block.23.layer.1.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.3.layer.0.SelfAttention.k.weight
+text_encoders.t5xxl.transformer.encoder.block.3.layer.0.SelfAttention.o.weight
+text_encoders.t5xxl.transformer.encoder.block.3.layer.0.SelfAttention.q.weight
+text_encoders.t5xxl.transformer.encoder.block.3.layer.0.SelfAttention.v.weight
+text_encoders.t5xxl.transformer.encoder.block.3.layer.0.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.3.layer.1.DenseReluDense.wi_0.weight
+text_encoders.t5xxl.transformer.encoder.block.3.layer.1.DenseReluDense.wi_1.weight
+text_encoders.t5xxl.transformer.encoder.block.3.layer.1.DenseReluDense.wo.weight
+text_encoders.t5xxl.transformer.encoder.block.3.layer.1.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.4.layer.0.SelfAttention.k.weight
+text_encoders.t5xxl.transformer.encoder.block.4.layer.0.SelfAttention.o.weight
+text_encoders.t5xxl.transformer.encoder.block.4.layer.0.SelfAttention.q.weight
+text_encoders.t5xxl.transformer.encoder.block.4.layer.0.SelfAttention.v.weight
+text_encoders.t5xxl.transformer.encoder.block.4.layer.0.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.4.layer.1.DenseReluDense.wi_0.weight
+text_encoders.t5xxl.transformer.encoder.block.4.layer.1.DenseReluDense.wi_1.weight
+text_encoders.t5xxl.transformer.encoder.block.4.layer.1.DenseReluDense.wo.weight
+text_encoders.t5xxl.transformer.encoder.block.4.layer.1.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.5.layer.0.SelfAttention.k.weight
+text_encoders.t5xxl.transformer.encoder.block.5.layer.0.SelfAttention.o.weight
+text_encoders.t5xxl.transformer.encoder.block.5.layer.0.SelfAttention.q.weight
+text_encoders.t5xxl.transformer.encoder.block.5.layer.0.SelfAttention.v.weight
+text_encoders.t5xxl.transformer.encoder.block.5.layer.0.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.5.layer.1.DenseReluDense.wi_0.weight
+text_encoders.t5xxl.transformer.encoder.block.5.layer.1.DenseReluDense.wi_1.weight
+text_encoders.t5xxl.transformer.encoder.block.5.layer.1.DenseReluDense.wo.weight
+text_encoders.t5xxl.transformer.encoder.block.5.layer.1.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.6.layer.0.SelfAttention.k.weight
+text_encoders.t5xxl.transformer.encoder.block.6.layer.0.SelfAttention.o.weight
+text_encoders.t5xxl.transformer.encoder.block.6.layer.0.SelfAttention.q.weight
+text_encoders.t5xxl.transformer.encoder.block.6.layer.0.SelfAttention.v.weight
+text_encoders.t5xxl.transformer.encoder.block.6.layer.0.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.6.layer.1.DenseReluDense.wi_0.weight
+text_encoders.t5xxl.transformer.encoder.block.6.layer.1.DenseReluDense.wi_1.weight
+text_encoders.t5xxl.transformer.encoder.block.6.layer.1.DenseReluDense.wo.weight
+text_encoders.t5xxl.transformer.encoder.block.6.layer.1.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.7.layer.0.SelfAttention.k.weight
+text_encoders.t5xxl.transformer.encoder.block.7.layer.0.SelfAttention.o.weight
+text_encoders.t5xxl.transformer.encoder.block.7.layer.0.SelfAttention.q.weight
+text_encoders.t5xxl.transformer.encoder.block.7.layer.0.SelfAttention.v.weight
+text_encoders.t5xxl.transformer.encoder.block.7.layer.0.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.7.layer.1.DenseReluDense.wi_0.weight
+text_encoders.t5xxl.transformer.encoder.block.7.layer.1.DenseReluDense.wi_1.weight
+text_encoders.t5xxl.transformer.encoder.block.7.layer.1.DenseReluDense.wo.weight
+text_encoders.t5xxl.transformer.encoder.block.7.layer.1.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.8.layer.0.SelfAttention.k.weight
+text_encoders.t5xxl.transformer.encoder.block.8.layer.0.SelfAttention.o.weight
+text_encoders.t5xxl.transformer.encoder.block.8.layer.0.SelfAttention.q.weight
+text_encoders.t5xxl.transformer.encoder.block.8.layer.0.SelfAttention.v.weight
+text_encoders.t5xxl.transformer.encoder.block.8.layer.0.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.8.layer.1.DenseReluDense.wi_0.weight
+text_encoders.t5xxl.transformer.encoder.block.8.layer.1.DenseReluDense.wi_1.weight
+text_encoders.t5xxl.transformer.encoder.block.8.layer.1.DenseReluDense.wo.weight
+text_encoders.t5xxl.transformer.encoder.block.8.layer.1.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.9.layer.0.SelfAttention.k.weight
+text_encoders.t5xxl.transformer.encoder.block.9.layer.0.SelfAttention.o.weight
+text_encoders.t5xxl.transformer.encoder.block.9.layer.0.SelfAttention.q.weight
+text_encoders.t5xxl.transformer.encoder.block.9.layer.0.SelfAttention.v.weight
+text_encoders.t5xxl.transformer.encoder.block.9.layer.0.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.block.9.layer.1.DenseReluDense.wi_0.weight
+text_encoders.t5xxl.transformer.encoder.block.9.layer.1.DenseReluDense.wi_1.weight
+text_encoders.t5xxl.transformer.encoder.block.9.layer.1.DenseReluDense.wo.weight
+text_encoders.t5xxl.transformer.encoder.block.9.layer.1.layer_norm.weight
+text_encoders.t5xxl.transformer.encoder.final_layer_norm.weight
+text_encoders.t5xxl.transformer.shared.weight
+vae.decoder.conv_in.bias
+vae.decoder.conv_in.weight
+vae.decoder.conv_out.bias
+vae.decoder.conv_out.weight
+vae.decoder.mid.attn_1.k.bias
+vae.decoder.mid.attn_1.k.weight
+vae.decoder.mid.attn_1.norm.bias
+vae.decoder.mid.attn_1.norm.weight
+vae.decoder.mid.attn_1.proj_out.bias
+vae.decoder.mid.attn_1.proj_out.weight
+vae.decoder.mid.attn_1.q.bias
+vae.decoder.mid.attn_1.q.weight
+vae.decoder.mid.attn_1.v.bias
+vae.decoder.mid.attn_1.v.weight
+vae.decoder.mid.block_1.conv1.bias
+vae.decoder.mid.block_1.conv1.weight
+vae.decoder.mid.block_1.conv2.bias
+vae.decoder.mid.block_1.conv2.weight
+vae.decoder.mid.block_1.norm1.bias
+vae.decoder.mid.block_1.norm1.weight
+vae.decoder.mid.block_1.norm2.bias
+vae.decoder.mid.block_1.norm2.weight
+vae.decoder.mid.block_2.conv1.bias
+vae.decoder.mid.block_2.conv1.weight
+vae.decoder.mid.block_2.conv2.bias
+vae.decoder.mid.block_2.conv2.weight
+vae.decoder.mid.block_2.norm1.bias
+vae.decoder.mid.block_2.norm1.weight
+vae.decoder.mid.block_2.norm2.bias
+vae.decoder.mid.block_2.norm2.weight
+vae.decoder.norm_out.bias
+vae.decoder.norm_out.weight
+vae.decoder.up.0.block.0.conv1.bias
+vae.decoder.up.0.block.0.conv1.weight
+vae.decoder.up.0.block.0.conv2.bias
+vae.decoder.up.0.block.0.conv2.weight
+vae.decoder.up.0.block.0.nin_shortcut.bias
+vae.decoder.up.0.block.0.nin_shortcut.weight
+vae.decoder.up.0.block.0.norm1.bias
+vae.decoder.up.0.block.0.norm1.weight
+vae.decoder.up.0.block.0.norm2.bias
+vae.decoder.up.0.block.0.norm2.weight
+vae.decoder.up.0.block.1.conv1.bias
+vae.decoder.up.0.block.1.conv1.weight
+vae.decoder.up.0.block.1.conv2.bias
+vae.decoder.up.0.block.1.conv2.weight
+vae.decoder.up.0.block.1.norm1.bias
+vae.decoder.up.0.block.1.norm1.weight
+vae.decoder.up.0.block.1.norm2.bias
+vae.decoder.up.0.block.1.norm2.weight
+vae.decoder.up.0.block.2.conv1.bias
+vae.decoder.up.0.block.2.conv1.weight
+vae.decoder.up.0.block.2.conv2.bias
+vae.decoder.up.0.block.2.conv2.weight
+vae.decoder.up.0.block.2.norm1.bias
+vae.decoder.up.0.block.2.norm1.weight
+vae.decoder.up.0.block.2.norm2.bias
+vae.decoder.up.0.block.2.norm2.weight
+vae.decoder.up.1.block.0.conv1.bias
+vae.decoder.up.1.block.0.conv1.weight
+vae.decoder.up.1.block.0.conv2.bias
+vae.decoder.up.1.block.0.conv2.weight
+vae.decoder.up.1.block.0.nin_shortcut.bias
+vae.decoder.up.1.block.0.nin_shortcut.weight
+vae.decoder.up.1.block.0.norm1.bias
+vae.decoder.up.1.block.0.norm1.weight
+vae.decoder.up.1.block.0.norm2.bias
+vae.decoder.up.1.block.0.norm2.weight
+vae.decoder.up.1.block.1.conv1.bias
+vae.decoder.up.1.block.1.conv1.weight
+vae.decoder.up.1.block.1.conv2.bias
+vae.decoder.up.1.block.1.conv2.weight
+vae.decoder.up.1.block.1.norm1.bias
+vae.decoder.up.1.block.1.norm1.weight
+vae.decoder.up.1.block.1.norm2.bias
+vae.decoder.up.1.block.1.norm2.weight
+vae.decoder.up.1.block.2.conv1.bias
+vae.decoder.up.1.block.2.conv1.weight
+vae.decoder.up.1.block.2.conv2.bias
+vae.decoder.up.1.block.2.conv2.weight
+vae.decoder.up.1.block.2.norm1.bias
+vae.decoder.up.1.block.2.norm1.weight
+vae.decoder.up.1.block.2.norm2.bias
+vae.decoder.up.1.block.2.norm2.weight
+vae.decoder.up.1.upsample.conv.bias
+vae.decoder.up.1.upsample.conv.weight
+vae.decoder.up.2.block.0.conv1.bias
+vae.decoder.up.2.block.0.conv1.weight
+vae.decoder.up.2.block.0.conv2.bias
+vae.decoder.up.2.block.0.conv2.weight
+vae.decoder.up.2.block.0.norm1.bias
+vae.decoder.up.2.block.0.norm1.weight
+vae.decoder.up.2.block.0.norm2.bias
+vae.decoder.up.2.block.0.norm2.weight
+vae.decoder.up.2.block.1.conv1.bias
+vae.decoder.up.2.block.1.conv1.weight
+vae.decoder.up.2.block.1.conv2.bias
+vae.decoder.up.2.block.1.conv2.weight
+vae.decoder.up.2.block.1.norm1.bias
+vae.decoder.up.2.block.1.norm1.weight
+vae.decoder.up.2.block.1.norm2.bias
+vae.decoder.up.2.block.1.norm2.weight
+vae.decoder.up.2.block.2.conv1.bias
+vae.decoder.up.2.block.2.conv1.weight
+vae.decoder.up.2.block.2.conv2.bias
+vae.decoder.up.2.block.2.conv2.weight
+vae.decoder.up.2.block.2.norm1.bias
+vae.decoder.up.2.block.2.norm1.weight
+vae.decoder.up.2.block.2.norm2.bias
+vae.decoder.up.2.block.2.norm2.weight
+vae.decoder.up.2.upsample.conv.bias
+vae.decoder.up.2.upsample.conv.weight
+vae.decoder.up.3.block.0.conv1.bias
+vae.decoder.up.3.block.0.conv1.weight
+vae.decoder.up.3.block.0.conv2.bias
+vae.decoder.up.3.block.0.conv2.weight
+vae.decoder.up.3.block.0.norm1.bias
+vae.decoder.up.3.block.0.norm1.weight
+vae.decoder.up.3.block.0.norm2.bias
+vae.decoder.up.3.block.0.norm2.weight
+vae.decoder.up.3.block.1.conv1.bias
+vae.decoder.up.3.block.1.conv1.weight
+vae.decoder.up.3.block.1.conv2.bias
+vae.decoder.up.3.block.1.conv2.weight
+vae.decoder.up.3.block.1.norm1.bias
+vae.decoder.up.3.block.1.norm1.weight
+vae.decoder.up.3.block.1.norm2.bias
+vae.decoder.up.3.block.1.norm2.weight
+vae.decoder.up.3.block.2.conv1.bias
+vae.decoder.up.3.block.2.conv1.weight
+vae.decoder.up.3.block.2.conv2.bias
+vae.decoder.up.3.block.2.conv2.weight
+vae.decoder.up.3.block.2.norm1.bias
+vae.decoder.up.3.block.2.norm1.weight
+vae.decoder.up.3.block.2.norm2.bias
+vae.decoder.up.3.block.2.norm2.weight
+vae.decoder.up.3.upsample.conv.bias
+vae.decoder.up.3.upsample.conv.weight
+vae.encoder.conv_in.bias
+vae.encoder.conv_in.weight
+vae.encoder.conv_out.bias
+vae.encoder.conv_out.weight
+vae.encoder.down.0.block.0.conv1.bias
+vae.encoder.down.0.block.0.conv1.weight
+vae.encoder.down.0.block.0.conv2.bias
+vae.encoder.down.0.block.0.conv2.weight
+vae.encoder.down.0.block.0.norm1.bias
+vae.encoder.down.0.block.0.norm1.weight
+vae.encoder.down.0.block.0.norm2.bias
+vae.encoder.down.0.block.0.norm2.weight
+vae.encoder.down.0.block.1.conv1.bias
+vae.encoder.down.0.block.1.conv1.weight
+vae.encoder.down.0.block.1.conv2.bias
+vae.encoder.down.0.block.1.conv2.weight
+vae.encoder.down.0.block.1.norm1.bias
+vae.encoder.down.0.block.1.norm1.weight
+vae.encoder.down.0.block.1.norm2.bias
+vae.encoder.down.0.block.1.norm2.weight
+vae.encoder.down.0.downsample.conv.bias
+vae.encoder.down.0.downsample.conv.weight
+vae.encoder.down.1.block.0.conv1.bias
+vae.encoder.down.1.block.0.conv1.weight
+vae.encoder.down.1.block.0.conv2.bias
+vae.encoder.down.1.block.0.conv2.weight
+vae.encoder.down.1.block.0.nin_shortcut.bias
+vae.encoder.down.1.block.0.nin_shortcut.weight
+vae.encoder.down.1.block.0.norm1.bias
+vae.encoder.down.1.block.0.norm1.weight
+vae.encoder.down.1.block.0.norm2.bias
+vae.encoder.down.1.block.0.norm2.weight
+vae.encoder.down.1.block.1.conv1.bias
+vae.encoder.down.1.block.1.conv1.weight
+vae.encoder.down.1.block.1.conv2.bias
+vae.encoder.down.1.block.1.conv2.weight
+vae.encoder.down.1.block.1.norm1.bias
+vae.encoder.down.1.block.1.norm1.weight
+vae.encoder.down.1.block.1.norm2.bias
+vae.encoder.down.1.block.1.norm2.weight
+vae.encoder.down.1.downsample.conv.bias
+vae.encoder.down.1.downsample.conv.weight
+vae.encoder.down.2.block.0.conv1.bias
+vae.encoder.down.2.block.0.conv1.weight
+vae.encoder.down.2.block.0.conv2.bias
+vae.encoder.down.2.block.0.conv2.weight
+vae.encoder.down.2.block.0.nin_shortcut.bias
+vae.encoder.down.2.block.0.nin_shortcut.weight
+vae.encoder.down.2.block.0.norm1.bias
+vae.encoder.down.2.block.0.norm1.weight
+vae.encoder.down.2.block.0.norm2.bias
+vae.encoder.down.2.block.0.norm2.weight
+vae.encoder.down.2.block.1.conv1.bias
+vae.encoder.down.2.block.1.conv1.weight
+vae.encoder.down.2.block.1.conv2.bias
+vae.encoder.down.2.block.1.conv2.weight
+vae.encoder.down.2.block.1.norm1.bias
+vae.encoder.down.2.block.1.norm1.weight
+vae.encoder.down.2.block.1.norm2.bias
+vae.encoder.down.2.block.1.norm2.weight
+vae.encoder.down.2.downsample.conv.bias
+vae.encoder.down.2.downsample.conv.weight
+vae.encoder.down.3.block.0.conv1.bias
+vae.encoder.down.3.block.0.conv1.weight
+vae.encoder.down.3.block.0.conv2.bias
+vae.encoder.down.3.block.0.conv2.weight
+vae.encoder.down.3.block.0.norm1.bias
+vae.encoder.down.3.block.0.norm1.weight
+vae.encoder.down.3.block.0.norm2.bias
+vae.encoder.down.3.block.0.norm2.weight
+vae.encoder.down.3.block.1.conv1.bias
+vae.encoder.down.3.block.1.conv1.weight
+vae.encoder.down.3.block.1.conv2.bias
+vae.encoder.down.3.block.1.conv2.weight
+vae.encoder.down.3.block.1.norm1.bias
+vae.encoder.down.3.block.1.norm1.weight
+vae.encoder.down.3.block.1.norm2.bias
+vae.encoder.down.3.block.1.norm2.weight
+vae.encoder.mid.attn_1.k.bias
+vae.encoder.mid.attn_1.k.weight
+vae.encoder.mid.attn_1.norm.bias
+vae.encoder.mid.attn_1.norm.weight
+vae.encoder.mid.attn_1.proj_out.bias
+vae.encoder.mid.attn_1.proj_out.weight
+vae.encoder.mid.attn_1.q.bias
+vae.encoder.mid.attn_1.q.weight
+vae.encoder.mid.attn_1.v.bias
+vae.encoder.mid.attn_1.v.weight
+vae.encoder.mid.block_1.conv1.bias
+vae.encoder.mid.block_1.conv1.weight
+vae.encoder.mid.block_1.conv2.bias
+vae.encoder.mid.block_1.conv2.weight
+vae.encoder.mid.block_1.norm1.bias
+vae.encoder.mid.block_1.norm1.weight
+vae.encoder.mid.block_1.norm2.bias
+vae.encoder.mid.block_1.norm2.weight
+vae.encoder.mid.block_2.conv1.bias
+vae.encoder.mid.block_2.conv1.weight
+vae.encoder.mid.block_2.conv2.bias
+vae.encoder.mid.block_2.conv2.weight
+vae.encoder.mid.block_2.norm1.bias
+vae.encoder.mid.block_2.norm1.weight
+vae.encoder.mid.block_2.norm2.bias
+vae.encoder.mid.block_2.norm2.weight
+vae.encoder.norm_out.bias
+vae.encoder.norm_out.weight

pre-requirements.txt

@@ -0,0 +1 @@
+pip>=23.0.0

requirements.txt

@@ -0,0 +1,17 @@
+huggingface_hub
+safetensors
+git+https://github.com/huggingface/transformers
+git+https://github.com/huggingface/accelerate
+git+https://github.com/huggingface/diffusers
+git+https://github.com/huggingface/peft
+optimum-quanto
+sentencepiece
+torch
+torchaudio
+torchvision
+pytorch_lightning
+aria2
+gdown
+gguf>=0.9.1
+numpy
+psutil