Upload 9 files

README.md

@@ -1,12 +1,13 @@
----
-title: Test57
-emoji: 📚
-colorFrom: purple
-colorTo: blue
-sdk: gradio
-sdk_version: 4.41.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: test
+emoji: 🧨
+colorFrom: yellow
+colorTo: red
+sdk: gradio
+sdk_version: 4.38.1
+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,69 @@
+import gradio as gr
+from merge_gr import gen_repo_list, upload_repo_list, clear_repo_list, process_repos_gr
+
+css = """"""
+
+with gr.Blocks(theme="NoCrypt/miku@>=1.2.2", css=css) as demo:
+    gr.Markdown("# SDXL/SD1.5 DARE Merger (experiment)")
+    gr.Markdown(
+        f"""
+This Space is a mod version of [martyn](https://huggingface.co/martyn)'s [safetensors-merge-supermario](https://github.com/martyn/safetensors-merge-supermario) forced to be compatible with Diffusers.
+Since the space is completely experimental and unfinished,
+I recommend using [ComfyUI-DareMerge](https://github.com/54rt1n/ComfyUI-DareMerge)
+ or [WebUI SuperMerger](https://github.com/hako-mikan/sd-webui-supermerger) for actual merging.
+ Also, I think most safetensors models with the same structure can be merged even if they are not SD models, but I haven't tried.<br>
+**⚠️IMPORTANT NOTICE⚠️**<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 running.
+Keys and tokens could be set to SECRET (HF_TOKEN) 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.
+- Input your HF user ID. e.g. 'yourid'.
+- Input your new merged repo name.
+- Input information for merging models.
+- Set the parameters. If not sure, just use the defaults.
+- Click "Submit".
+- Patiently wait until the output changes. It takes approximately 5~6 minutes (downloading from HF).
+            """
+    )
+    with gr.Column():
+        with gr.Group():
+            hf_token = gr.Textbox(label="Your HF write token", placeholder="hf_...", value="", max_lines=1)
+            with gr.Row():
+                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", value="", max_lines=1)
+        with gr.Group():
+            with gr.Accordion("YAML", open=True):
+                merge_yaml_input = gr.Textbox(label="List of Repos or URLs to merge", placeholder="author/repo\nauthor/repo\n...", value="", lines=4)
+                merge_yaml_md = gr.Markdown()
+                merge_yaml_upload = gr.UploadButton(label="Upload YAML file", file_types=["text"])
+                merge_yaml_clear = gr.Button("Clear YAML files")
+            with gr.Row():
+                merge_p = gr.Number(label="Default dropout probability", value=0.5, minimum=0, maximum=1.0, step=0.01)
+                merge_lambda = gr.Number(label="Default scaling factor for the weight delta", value=1.0, minimum=0, maximum=2.0, step=0.01)
+            merge_mode = gr.Radio(label="Mode", choices=["SDXL", "SD1.5", "Single files"], value="SDXL")
+            merge_is_upload_sf = gr.Checkbox(label="Convert Diffusers files to single safetensors file", value=False)
+            merge_skip = gr.CheckboxGroup(label="Skip Diffusers folders", choices=["vae", "text_encoder", "text_encoder_2", "text_encoder_3"], value=["vae", "text_encoder"])
+            merge_is_upload = gr.Checkbox(label="Upload files into new Repo", value=True)
+            merge_repo_exists_ok = gr.Checkbox(label="Overwrite exsisting Repo", value=False)
+        run_button = gr.Button(value="Submit")
+        repo_urls = gr.CheckboxGroup(visible=False, choices=[], value=None)
+        output_md = gr.Markdown(label="Output")
+        merge_files = gr.Files(label="Download", interactive=False, value=[])
+
+    merge_yaml_input.change(gen_repo_list, [merge_yaml_input, merge_p, merge_lambda], [merge_yaml_md], queue=False)
+    merge_yaml_upload.upload(upload_repo_list, [merge_yaml_upload, merge_p, merge_lambda], [merge_yaml_md], queue=False)
+    merge_yaml_clear.click(clear_repo_list, None, [merge_yaml_input, merge_yaml_md], queue=False)
+    gr.on(
+        triggers=[run_button.click],
+        fn=process_repos_gr,
+        inputs=[merge_mode, merge_p, merge_lambda, merge_skip, hf_user, hf_repo, hf_token,
+                 merge_is_upload, merge_is_upload_sf, merge_repo_exists_ok, merge_files, repo_urls],
+        outputs=[merge_files, repo_urls, output_md],
+    )
+
+demo.queue()
+demo.launch()

convert_repo_to_safetensors_gr.py

@@ -0,0 +1,399 @@
+# Script for converting a HF Diffusers saved pipeline to a Stable Diffusion checkpoint.
+# *Only* converts the UNet, VAE, and Text Encoder.
+# Does not convert optimizer state or any other thing.
+
+import argparse
+import os.path as osp
+import re
+
+import torch
+from safetensors.torch import load_file, save_file
+import gradio as gr
+
+# =================#
+# UNet Conversion #
+# =================#
+
+unet_conversion_map = [
+    # (stable-diffusion, HF Diffusers)
+    ("time_embed.0.weight", "time_embedding.linear_1.weight"),
+    ("time_embed.0.bias", "time_embedding.linear_1.bias"),
+    ("time_embed.2.weight", "time_embedding.linear_2.weight"),
+    ("time_embed.2.bias", "time_embedding.linear_2.bias"),
+    ("input_blocks.0.0.weight", "conv_in.weight"),
+    ("input_blocks.0.0.bias", "conv_in.bias"),
+    ("out.0.weight", "conv_norm_out.weight"),
+    ("out.0.bias", "conv_norm_out.bias"),
+    ("out.2.weight", "conv_out.weight"),
+    ("out.2.bias", "conv_out.bias"),
+    # the following are for sdxl
+    ("label_emb.0.0.weight", "add_embedding.linear_1.weight"),
+    ("label_emb.0.0.bias", "add_embedding.linear_1.bias"),
+    ("label_emb.0.2.weight", "add_embedding.linear_2.weight"),
+    ("label_emb.0.2.bias", "add_embedding.linear_2.bias"),
+]
+
+unet_conversion_map_resnet = [
+    # (stable-diffusion, HF Diffusers)
+    ("in_layers.0", "norm1"),
+    ("in_layers.2", "conv1"),
+    ("out_layers.0", "norm2"),
+    ("out_layers.3", "conv2"),
+    ("emb_layers.1", "time_emb_proj"),
+    ("skip_connection", "conv_shortcut"),
+]
+
+unet_conversion_map_layer = []
+# hardcoded number of downblocks and resnets/attentions...
+# would need smarter logic for other networks.
+for i in range(3):
+    # loop over downblocks/upblocks
+
+    for j in range(2):
+        # loop over resnets/attentions for downblocks
+        hf_down_res_prefix = f"down_blocks.{i}.resnets.{j}."
+        sd_down_res_prefix = f"input_blocks.{3*i + j + 1}.0."
+        unet_conversion_map_layer.append((sd_down_res_prefix, hf_down_res_prefix))
+
+        if i > 0:
+            hf_down_atn_prefix = f"down_blocks.{i}.attentions.{j}."
+            sd_down_atn_prefix = f"input_blocks.{3*i + j + 1}.1."
+            unet_conversion_map_layer.append((sd_down_atn_prefix, hf_down_atn_prefix))
+
+    for j in range(4):
+        # loop over resnets/attentions for upblocks
+        hf_up_res_prefix = f"up_blocks.{i}.resnets.{j}."
+        sd_up_res_prefix = f"output_blocks.{3*i + j}.0."
+        unet_conversion_map_layer.append((sd_up_res_prefix, hf_up_res_prefix))
+
+        if i < 2:
+            # no attention layers in up_blocks.0
+            hf_up_atn_prefix = f"up_blocks.{i}.attentions.{j}."
+            sd_up_atn_prefix = f"output_blocks.{3 * i + j}.1."
+            unet_conversion_map_layer.append((sd_up_atn_prefix, hf_up_atn_prefix))
+
+    if i < 3:
+        # no downsample in down_blocks.3
+        hf_downsample_prefix = f"down_blocks.{i}.downsamplers.0.conv."
+        sd_downsample_prefix = f"input_blocks.{3*(i+1)}.0.op."
+        unet_conversion_map_layer.append((sd_downsample_prefix, hf_downsample_prefix))
+
+        # no upsample in up_blocks.3
+        hf_upsample_prefix = f"up_blocks.{i}.upsamplers.0."
+        sd_upsample_prefix = f"output_blocks.{3*i + 2}.{1 if i == 0 else 2}."
+        unet_conversion_map_layer.append((sd_upsample_prefix, hf_upsample_prefix))
+unet_conversion_map_layer.append(("output_blocks.2.2.conv.", "output_blocks.2.1.conv."))
+
+hf_mid_atn_prefix = "mid_block.attentions.0."
+sd_mid_atn_prefix = "middle_block.1."
+unet_conversion_map_layer.append((sd_mid_atn_prefix, hf_mid_atn_prefix))
+for j in range(2):
+    hf_mid_res_prefix = f"mid_block.resnets.{j}."
+    sd_mid_res_prefix = f"middle_block.{2*j}."
+    unet_conversion_map_layer.append((sd_mid_res_prefix, hf_mid_res_prefix))
+
+
+def convert_unet_state_dict(unet_state_dict):
+    # buyer beware: this is a *brittle* function,
+    # and correct output requires that all of these pieces interact in
+    # the exact order in which I have arranged them.
+    mapping = {k: k for k in unet_state_dict.keys()}
+    for sd_name, hf_name in unet_conversion_map:
+        mapping[hf_name] = sd_name
+    for k, v in mapping.items():
+        if "resnets" in k:
+            for sd_part, hf_part in unet_conversion_map_resnet:
+                v = v.replace(hf_part, sd_part)
+            mapping[k] = v
+    for k, v in mapping.items():
+        for sd_part, hf_part in unet_conversion_map_layer:
+            v = v.replace(hf_part, sd_part)
+        mapping[k] = v
+    new_state_dict = {sd_name: unet_state_dict[hf_name] for hf_name, sd_name in mapping.items()}
+    return new_state_dict
+
+
+# ================#
+# VAE Conversion #
+# ================#
+
+vae_conversion_map = [
+    # (stable-diffusion, HF Diffusers)
+    ("nin_shortcut", "conv_shortcut"),
+    ("norm_out", "conv_norm_out"),
+    ("mid.attn_1.", "mid_block.attentions.0."),
+]
+
+for i in range(4):
+    # down_blocks have two resnets
+    for j in range(2):
+        hf_down_prefix = f"encoder.down_blocks.{i}.resnets.{j}."
+        sd_down_prefix = f"encoder.down.{i}.block.{j}."
+        vae_conversion_map.append((sd_down_prefix, hf_down_prefix))
+
+    if i < 3:
+        hf_downsample_prefix = f"down_blocks.{i}.downsamplers.0."
+        sd_downsample_prefix = f"down.{i}.downsample."
+        vae_conversion_map.append((sd_downsample_prefix, hf_downsample_prefix))
+
+        hf_upsample_prefix = f"up_blocks.{i}.upsamplers.0."
+        sd_upsample_prefix = f"up.{3-i}.upsample."
+        vae_conversion_map.append((sd_upsample_prefix, hf_upsample_prefix))
+
+    # up_blocks have three resnets
+    # also, up blocks in hf are numbered in reverse from sd
+    for j in range(3):
+        hf_up_prefix = f"decoder.up_blocks.{i}.resnets.{j}."
+        sd_up_prefix = f"decoder.up.{3-i}.block.{j}."
+        vae_conversion_map.append((sd_up_prefix, hf_up_prefix))
+
+# this part accounts for mid blocks in both the encoder and the decoder
+for i in range(2):
+    hf_mid_res_prefix = f"mid_block.resnets.{i}."
+    sd_mid_res_prefix = f"mid.block_{i+1}."
+    vae_conversion_map.append((sd_mid_res_prefix, hf_mid_res_prefix))
+
+
+vae_conversion_map_attn = [
+    # (stable-diffusion, HF Diffusers)
+    ("norm.", "group_norm."),
+    # the following are for SDXL
+    ("q.", "to_q."),
+    ("k.", "to_k."),
+    ("v.", "to_v."),
+    ("proj_out.", "to_out.0."),
+]
+
+
+def reshape_weight_for_sd(w):
+    # convert HF linear weights to SD conv2d weights
+    if not w.ndim == 1:
+        return w.reshape(*w.shape, 1, 1)
+    else:
+        return w
+
+
+def convert_vae_state_dict(vae_state_dict):
+    mapping = {k: k for k in vae_state_dict.keys()}
+    for k, v in mapping.items():
+        for sd_part, hf_part in vae_conversion_map:
+            v = v.replace(hf_part, sd_part)
+        mapping[k] = v
+    for k, v in mapping.items():
+        if "attentions" in k:
+            for sd_part, hf_part in vae_conversion_map_attn:
+                v = v.replace(hf_part, sd_part)
+            mapping[k] = v
+    new_state_dict = {v: vae_state_dict[k] for k, v in mapping.items()}
+    weights_to_convert = ["q", "k", "v", "proj_out"]
+    for k, v in new_state_dict.items():
+        for weight_name in weights_to_convert:
+            if f"mid.attn_1.{weight_name}.weight" in k:
+                print(f"Reshaping {k} for SD format")
+                new_state_dict[k] = reshape_weight_for_sd(v)
+    return new_state_dict
+
+
+# =========================#
+# Text Encoder Conversion #
+# =========================#
+
+
+textenc_conversion_lst = [
+    # (stable-diffusion, HF Diffusers)
+    ("transformer.resblocks.", "text_model.encoder.layers."),
+    ("ln_1", "layer_norm1"),
+    ("ln_2", "layer_norm2"),
+    (".c_fc.", ".fc1."),
+    (".c_proj.", ".fc2."),
+    (".attn", ".self_attn"),
+    ("ln_final.", "text_model.final_layer_norm."),
+    ("token_embedding.weight", "text_model.embeddings.token_embedding.weight"),
+    ("positional_embedding", "text_model.embeddings.position_embedding.weight"),
+]
+protected = {re.escape(x[1]): x[0] for x in textenc_conversion_lst}
+textenc_pattern = re.compile("|".join(protected.keys()))
+
+# Ordering is from https://github.com/pytorch/pytorch/blob/master/test/cpp/api/modules.cpp
+code2idx = {"q": 0, "k": 1, "v": 2}
+
+
+def convert_openclip_text_enc_state_dict(text_enc_dict):
+    new_state_dict = {}
+    capture_qkv_weight = {}
+    capture_qkv_bias = {}
+    for k, v in text_enc_dict.items():
+        if (
+            k.endswith(".self_attn.q_proj.weight")
+            or k.endswith(".self_attn.k_proj.weight")
+            or k.endswith(".self_attn.v_proj.weight")
+        ):
+            k_pre = k[: -len(".q_proj.weight")]
+            k_code = k[-len("q_proj.weight")]
+            if k_pre not in capture_qkv_weight:
+                capture_qkv_weight[k_pre] = [None, None, None]
+            capture_qkv_weight[k_pre][code2idx[k_code]] = v
+            continue
+
+        if (
+            k.endswith(".self_attn.q_proj.bias")
+            or k.endswith(".self_attn.k_proj.bias")
+            or k.endswith(".self_attn.v_proj.bias")
+        ):
+            k_pre = k[: -len(".q_proj.bias")]
+            k_code = k[-len("q_proj.bias")]
+            if k_pre not in capture_qkv_bias:
+                capture_qkv_bias[k_pre] = [None, None, None]
+            capture_qkv_bias[k_pre][code2idx[k_code]] = v
+            continue
+
+        relabelled_key = textenc_pattern.sub(lambda m: protected[re.escape(m.group(0))], k)
+        new_state_dict[relabelled_key] = v
+
+    for k_pre, tensors in capture_qkv_weight.items():
+        if None in tensors:
+            raise Exception("CORRUPTED MODEL: one of the q-k-v values for the text encoder was missing")
+        relabelled_key = textenc_pattern.sub(lambda m: protected[re.escape(m.group(0))], k_pre)
+        new_state_dict[relabelled_key + ".in_proj_weight"] = torch.cat(tensors)
+
+    for k_pre, tensors in capture_qkv_bias.items():
+        if None in tensors:
+            raise Exception("CORRUPTED MODEL: one of the q-k-v values for the text encoder was missing")
+        relabelled_key = textenc_pattern.sub(lambda m: protected[re.escape(m.group(0))], k_pre)
+        new_state_dict[relabelled_key + ".in_proj_bias"] = torch.cat(tensors)
+
+    return new_state_dict
+
+
+def convert_openai_text_enc_state_dict(text_enc_dict):
+    return text_enc_dict
+
+
+def convert_diffusers_to_safetensors(model_path, checkpoint_path, half = True, progress=gr.Progress(track_tqdm=True)):
+    progress(0, desc="Start converting...")
+    # Path for safetensors
+    unet_path = osp.join(model_path, "unet", "diffusion_pytorch_model.safetensors")
+    vae_path = osp.join(model_path, "vae", "diffusion_pytorch_model.safetensors")
+    text_enc_path = osp.join(model_path, "text_encoder", "model.safetensors")
+    text_enc_2_path = osp.join(model_path, "text_encoder_2", "model.safetensors")
+
+    # Load models from safetensors if it exists, if it doesn't pytorch
+    if osp.exists(unet_path):
+        unet_state_dict = load_file(unet_path, device="cpu")
+    else:
+        unet_path = osp.join(model_path, "unet", "diffusion_pytorch_model.bin")
+        unet_state_dict = torch.load(unet_path, map_location="cpu")
+
+    if osp.exists(vae_path):
+        vae_state_dict = load_file(vae_path, device="cpu")
+    else:
+        vae_path = osp.join(model_path, "vae", "diffusion_pytorch_model.bin")
+        vae_state_dict = torch.load(vae_path, map_location="cpu")
+
+    if osp.exists(text_enc_path):
+        text_enc_dict = load_file(text_enc_path, device="cpu")
+    else:
+        text_enc_path = osp.join(model_path, "text_encoder", "pytorch_model.bin")
+        text_enc_dict = torch.load(text_enc_path, map_location="cpu")
+
+    if osp.exists(text_enc_2_path):
+        text_enc_2_dict = load_file(text_enc_2_path, device="cpu")
+    else:
+        text_enc_2_path = osp.join(model_path, "text_encoder_2", "pytorch_model.bin")
+        text_enc_2_dict = torch.load(text_enc_2_path, map_location="cpu")
+
+    # Convert the UNet model
+    unet_state_dict = convert_unet_state_dict(unet_state_dict)
+    unet_state_dict = {"model.diffusion_model." + k: v for k, v in unet_state_dict.items()}
+
+    # Convert the VAE model
+    vae_state_dict = convert_vae_state_dict(vae_state_dict)
+    vae_state_dict = {"first_stage_model." + k: v for k, v in vae_state_dict.items()}
+
+    # Convert text encoder 1
+    text_enc_dict = convert_openai_text_enc_state_dict(text_enc_dict)
+    text_enc_dict = {"conditioner.embedders.0.transformer." + k: v for k, v in text_enc_dict.items()}
+
+    # Convert text encoder 2
+    text_enc_2_dict = convert_openclip_text_enc_state_dict(text_enc_2_dict)
+    text_enc_2_dict = {"conditioner.embedders.1.model." + k: v for k, v in text_enc_2_dict.items()}
+    # We call the `.T.contiguous()` to match what's done in
+    # https://github.com/huggingface/diffusers/blob/84905ca7287876b925b6bf8e9bb92fec21c78764/src/diffusers/loaders/single_file_utils.py#L1085
+    text_enc_2_dict["conditioner.embedders.1.model.text_projection"] = text_enc_2_dict.pop(
+        "conditioner.embedders.1.model.text_projection.weight"
+    ).T.contiguous()
+
+    # Put together new checkpoint
+    state_dict = {**unet_state_dict, **vae_state_dict, **text_enc_dict, **text_enc_2_dict}
+
+    if half:
+        state_dict = {k: v.half() for k, v in state_dict.items()}
+
+    save_file(state_dict, checkpoint_path)
+    progress(1, desc="Converted.")
+
+
+def download_repo(repo_id, dir_path, progress=gr.Progress(track_tqdm=True)):
+    from huggingface_hub import snapshot_download
+    try:
+        snapshot_download(repo_id=repo_id, local_dir=dir_path)
+    except Exception as e:
+        print(f"Error: Failed to download {repo_id}. ")
+        return
+
+
+def upload_safetensors_to_repo(filename, progress=gr.Progress(track_tqdm=True)):
+    from huggingface_hub import HfApi, hf_hub_url
+    import os
+    from pathlib import Path
+    output_filename = Path(filename).name
+    hf_token = os.environ.get("HF_TOKEN")
+    repo_id = os.environ.get("HF_OUTPUT_REPO")
+    api = HfApi()
+    try:
+        progress(0, desc="Start uploading...")
+        api.upload_file(path_or_fileobj=filename, path_in_repo=output_filename, repo_id=repo_id, token=hf_token)
+        progress(1, desc="Uploaded.")
+        url  = hf_hub_url(repo_id=repo_id, filename=output_filename)
+    except Exception as e:
+        print(f"Error: Failed to upload to {repo_id}. ")
+        return None
+    return url
+
+
+def convert_repo_to_safetensors(repo_id, half=True, progress=gr.Progress(track_tqdm=True)):
+    download_dir = f"{repo_id.split('/')[0]}_{repo_id.split('/')[-1]}"
+    output_filename = f"{repo_id.split('/')[0]}_{repo_id.split('/')[-1]}.safetensors"
+    download_repo(repo_id, download_dir)
+    convert_diffusers_to_safetensors(download_dir, output_filename)
+    return output_filename
+
+
+def convert_repo_to_safetensors_multi(repo_id, files, is_upload, urls, half=True, progress=gr.Progress(track_tqdm=True)):
+    file = convert_repo_to_safetensors(repo_id)
+    if not urls: urls = []
+    url = ""
+    if is_upload:
+        url = upload_safetensors_to_repo(file)
+        if url: urls.append(url)
+    md = ""
+    for u in urls:
+        md += f"[Download {str(u).split('/')[-1]}]({str(u)})<br>"
+    if not files: files = []
+    files.append(file)
+    return gr.update(value=files), gr.update(value=urls, choices=urls), gr.update(value=md)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument("--repo_id", default=None, type=str, required=True, help="HF Repo ID of the model to convert.")
+    parser.add_argument("--half", default=True, help="Save weights in half precision.")
+
+    args = parser.parse_args()
+    assert args.repo_id is not None, "Must provide a Repo ID!"
+
+    convert_repo_to_safetensors(args.repo_id, args.half)
+
+
+# Usage: python convert_repo_to_safetensors.py --repo_id GraydientPlatformAPI/goodfit-pony41-xl

convert_repo_to_safetensors_sd_gr.py

@@ -0,0 +1,401 @@
+# Script for converting a HF Diffusers saved pipeline to a Stable Diffusion checkpoint.
+# *Only* converts the UNet, VAE, and Text Encoder.
+# Does not convert optimizer state or any other thing.
+
+import argparse
+import os.path as osp
+import re
+
+import torch
+from safetensors.torch import load_file, save_file
+import gradio as gr
+
+
+# =================#
+# UNet Conversion #
+# =================#
+
+unet_conversion_map = [
+    # (stable-diffusion, HF Diffusers)
+    ("time_embed.0.weight", "time_embedding.linear_1.weight"),
+    ("time_embed.0.bias", "time_embedding.linear_1.bias"),
+    ("time_embed.2.weight", "time_embedding.linear_2.weight"),
+    ("time_embed.2.bias", "time_embedding.linear_2.bias"),
+    ("input_blocks.0.0.weight", "conv_in.weight"),
+    ("input_blocks.0.0.bias", "conv_in.bias"),
+    ("out.0.weight", "conv_norm_out.weight"),
+    ("out.0.bias", "conv_norm_out.bias"),
+    ("out.2.weight", "conv_out.weight"),
+    ("out.2.bias", "conv_out.bias"),
+]
+
+unet_conversion_map_resnet = [
+    # (stable-diffusion, HF Diffusers)
+    ("in_layers.0", "norm1"),
+    ("in_layers.2", "conv1"),
+    ("out_layers.0", "norm2"),
+    ("out_layers.3", "conv2"),
+    ("emb_layers.1", "time_emb_proj"),
+    ("skip_connection", "conv_shortcut"),
+]
+
+unet_conversion_map_layer = []
+# hardcoded number of downblocks and resnets/attentions...
+# would need smarter logic for other networks.
+for i in range(4):
+    # loop over downblocks/upblocks
+
+    for j in range(2):
+        # loop over resnets/attentions for downblocks
+        hf_down_res_prefix = f"down_blocks.{i}.resnets.{j}."
+        sd_down_res_prefix = f"input_blocks.{3*i + j + 1}.0."
+        unet_conversion_map_layer.append((sd_down_res_prefix, hf_down_res_prefix))
+
+        if i < 3:
+            # no attention layers in down_blocks.3
+            hf_down_atn_prefix = f"down_blocks.{i}.attentions.{j}."
+            sd_down_atn_prefix = f"input_blocks.{3*i + j + 1}.1."
+            unet_conversion_map_layer.append((sd_down_atn_prefix, hf_down_atn_prefix))
+
+    for j in range(3):
+        # loop over resnets/attentions for upblocks
+        hf_up_res_prefix = f"up_blocks.{i}.resnets.{j}."
+        sd_up_res_prefix = f"output_blocks.{3*i + j}.0."
+        unet_conversion_map_layer.append((sd_up_res_prefix, hf_up_res_prefix))
+
+        if i > 0:
+            # no attention layers in up_blocks.0
+            hf_up_atn_prefix = f"up_blocks.{i}.attentions.{j}."
+            sd_up_atn_prefix = f"output_blocks.{3*i + j}.1."
+            unet_conversion_map_layer.append((sd_up_atn_prefix, hf_up_atn_prefix))
+
+    if i < 3:
+        # no downsample in down_blocks.3
+        hf_downsample_prefix = f"down_blocks.{i}.downsamplers.0.conv."
+        sd_downsample_prefix = f"input_blocks.{3*(i+1)}.0.op."
+        unet_conversion_map_layer.append((sd_downsample_prefix, hf_downsample_prefix))
+
+        # no upsample in up_blocks.3
+        hf_upsample_prefix = f"up_blocks.{i}.upsamplers.0."
+        sd_upsample_prefix = f"output_blocks.{3*i + 2}.{1 if i == 0 else 2}."
+        unet_conversion_map_layer.append((sd_upsample_prefix, hf_upsample_prefix))
+
+hf_mid_atn_prefix = "mid_block.attentions.0."
+sd_mid_atn_prefix = "middle_block.1."
+unet_conversion_map_layer.append((sd_mid_atn_prefix, hf_mid_atn_prefix))
+
+for j in range(2):
+    hf_mid_res_prefix = f"mid_block.resnets.{j}."
+    sd_mid_res_prefix = f"middle_block.{2*j}."
+    unet_conversion_map_layer.append((sd_mid_res_prefix, hf_mid_res_prefix))
+
+
+def convert_unet_state_dict(unet_state_dict):
+    # buyer beware: this is a *brittle* function,
+    # and correct output requires that all of these pieces interact in
+    # the exact order in which I have arranged them.
+    mapping = {k: k for k in unet_state_dict.keys()}
+    for sd_name, hf_name in unet_conversion_map:
+        mapping[hf_name] = sd_name
+    for k, v in mapping.items():
+        if "resnets" in k:
+            for sd_part, hf_part in unet_conversion_map_resnet:
+                v = v.replace(hf_part, sd_part)
+            mapping[k] = v
+    for k, v in mapping.items():
+        for sd_part, hf_part in unet_conversion_map_layer:
+            v = v.replace(hf_part, sd_part)
+        mapping[k] = v
+    new_state_dict = {v: unet_state_dict[k] for k, v in mapping.items()}
+    return new_state_dict
+
+
+# ================#
+# VAE Conversion #
+# ================#
+
+vae_conversion_map = [
+    # (stable-diffusion, HF Diffusers)
+    ("nin_shortcut", "conv_shortcut"),
+    ("norm_out", "conv_norm_out"),
+    ("mid.attn_1.", "mid_block.attentions.0."),
+]
+
+for i in range(4):
+    # down_blocks have two resnets
+    for j in range(2):
+        hf_down_prefix = f"encoder.down_blocks.{i}.resnets.{j}."
+        sd_down_prefix = f"encoder.down.{i}.block.{j}."
+        vae_conversion_map.append((sd_down_prefix, hf_down_prefix))
+
+    if i < 3:
+        hf_downsample_prefix = f"down_blocks.{i}.downsamplers.0."
+        sd_downsample_prefix = f"down.{i}.downsample."
+        vae_conversion_map.append((sd_downsample_prefix, hf_downsample_prefix))
+
+        hf_upsample_prefix = f"up_blocks.{i}.upsamplers.0."
+        sd_upsample_prefix = f"up.{3-i}.upsample."
+        vae_conversion_map.append((sd_upsample_prefix, hf_upsample_prefix))
+
+    # up_blocks have three resnets
+    # also, up blocks in hf are numbered in reverse from sd
+    for j in range(3):
+        hf_up_prefix = f"decoder.up_blocks.{i}.resnets.{j}."
+        sd_up_prefix = f"decoder.up.{3-i}.block.{j}."
+        vae_conversion_map.append((sd_up_prefix, hf_up_prefix))
+
+# this part accounts for mid blocks in both the encoder and the decoder
+for i in range(2):
+    hf_mid_res_prefix = f"mid_block.resnets.{i}."
+    sd_mid_res_prefix = f"mid.block_{i+1}."
+    vae_conversion_map.append((sd_mid_res_prefix, hf_mid_res_prefix))
+
+
+vae_conversion_map_attn = [
+    # (stable-diffusion, HF Diffusers)
+    ("norm.", "group_norm."),
+    ("q.", "query."),
+    ("k.", "key."),
+    ("v.", "value."),
+    ("proj_out.", "proj_attn."),
+]
+
+# This is probably not the most ideal solution, but it does work.
+vae_extra_conversion_map = [
+    ("to_q", "q"),
+    ("to_k", "k"),
+    ("to_v", "v"),
+    ("to_out.0", "proj_out"),
+]
+
+
+def reshape_weight_for_sd(w):
+    # convert HF linear weights to SD conv2d weights
+    if not w.ndim == 1:
+        return w.reshape(*w.shape, 1, 1)
+    else:
+        return w
+
+
+def convert_vae_state_dict(vae_state_dict):
+    mapping = {k: k for k in vae_state_dict.keys()}
+    for k, v in mapping.items():
+        for sd_part, hf_part in vae_conversion_map:
+            v = v.replace(hf_part, sd_part)
+        mapping[k] = v
+    for k, v in mapping.items():
+        if "attentions" in k:
+            for sd_part, hf_part in vae_conversion_map_attn:
+                v = v.replace(hf_part, sd_part)
+            mapping[k] = v
+    new_state_dict = {v: vae_state_dict[k] for k, v in mapping.items()}
+    weights_to_convert = ["q", "k", "v", "proj_out"]
+    keys_to_rename = {}
+    for k, v in new_state_dict.items():
+        for weight_name in weights_to_convert:
+            if f"mid.attn_1.{weight_name}.weight" in k:
+                print(f"Reshaping {k} for SD format")
+                new_state_dict[k] = reshape_weight_for_sd(v)
+        for weight_name, real_weight_name in vae_extra_conversion_map:
+            if f"mid.attn_1.{weight_name}.weight" in k or f"mid.attn_1.{weight_name}.bias" in k:
+                keys_to_rename[k] = k.replace(weight_name, real_weight_name)
+    for k, v in keys_to_rename.items():
+        if k in new_state_dict:
+            print(f"Renaming {k} to {v}")
+            new_state_dict[v] = reshape_weight_for_sd(new_state_dict[k])
+            del new_state_dict[k]
+    return new_state_dict
+
+
+# =========================#
+# Text Encoder Conversion #
+# =========================#
+
+
+textenc_conversion_lst = [
+    # (stable-diffusion, HF Diffusers)
+    ("resblocks.", "text_model.encoder.layers."),
+    ("ln_1", "layer_norm1"),
+    ("ln_2", "layer_norm2"),
+    (".c_fc.", ".fc1."),
+    (".c_proj.", ".fc2."),
+    (".attn", ".self_attn"),
+    ("ln_final.", "transformer.text_model.final_layer_norm."),
+    ("token_embedding.weight", "transformer.text_model.embeddings.token_embedding.weight"),
+    ("positional_embedding", "transformer.text_model.embeddings.position_embedding.weight"),
+]
+protected = {re.escape(x[1]): x[0] for x in textenc_conversion_lst}
+textenc_pattern = re.compile("|".join(protected.keys()))
+
+# Ordering is from https://github.com/pytorch/pytorch/blob/master/test/cpp/api/modules.cpp
+code2idx = {"q": 0, "k": 1, "v": 2}
+
+
+def convert_text_enc_state_dict_v20(text_enc_dict):
+    new_state_dict = {}
+    capture_qkv_weight = {}
+    capture_qkv_bias = {}
+    for k, v in text_enc_dict.items():
+        if (
+            k.endswith(".self_attn.q_proj.weight")
+            or k.endswith(".self_attn.k_proj.weight")
+            or k.endswith(".self_attn.v_proj.weight")
+        ):
+            k_pre = k[: -len(".q_proj.weight")]
+            k_code = k[-len("q_proj.weight")]
+            if k_pre not in capture_qkv_weight:
+                capture_qkv_weight[k_pre] = [None, None, None]
+            capture_qkv_weight[k_pre][code2idx[k_code]] = v
+            continue
+
+        if (
+            k.endswith(".self_attn.q_proj.bias")
+            or k.endswith(".self_attn.k_proj.bias")
+            or k.endswith(".self_attn.v_proj.bias")
+        ):
+            k_pre = k[: -len(".q_proj.bias")]
+            k_code = k[-len("q_proj.bias")]
+            if k_pre not in capture_qkv_bias:
+                capture_qkv_bias[k_pre] = [None, None, None]
+            capture_qkv_bias[k_pre][code2idx[k_code]] = v
+            continue
+
+        relabelled_key = textenc_pattern.sub(lambda m: protected[re.escape(m.group(0))], k)
+        new_state_dict[relabelled_key] = v
+
+    for k_pre, tensors in capture_qkv_weight.items():
+        if None in tensors:
+            raise Exception("CORRUPTED MODEL: one of the q-k-v values for the text encoder was missing")
+        relabelled_key = textenc_pattern.sub(lambda m: protected[re.escape(m.group(0))], k_pre)
+        new_state_dict[relabelled_key + ".in_proj_weight"] = torch.cat(tensors)
+
+    for k_pre, tensors in capture_qkv_bias.items():
+        if None in tensors:
+            raise Exception("CORRUPTED MODEL: one of the q-k-v values for the text encoder was missing")
+        relabelled_key = textenc_pattern.sub(lambda m: protected[re.escape(m.group(0))], k_pre)
+        new_state_dict[relabelled_key + ".in_proj_bias"] = torch.cat(tensors)
+
+    return new_state_dict
+
+
+def convert_text_enc_state_dict(text_enc_dict):
+    return text_enc_dict
+
+
+def convert_diffusers_to_safetensors(model_path, checkpoint_path, half = True, progress=gr.Progress(track_tqdm=True)):
+    progress(0, desc="Start converting...")
+    # Path for safetensors
+    unet_path = osp.join(model_path, "unet", "diffusion_pytorch_model.safetensors")
+    vae_path = osp.join(model_path, "vae", "diffusion_pytorch_model.safetensors")
+    text_enc_path = osp.join(model_path, "text_encoder", "model.safetensors")
+
+    # Load models from safetensors if it exists, if it doesn't pytorch
+    if osp.exists(unet_path):
+        unet_state_dict = load_file(unet_path, device="cpu")
+    else:
+        unet_path = osp.join(model_path, "unet", "diffusion_pytorch_model.bin")
+        unet_state_dict = torch.load(unet_path, map_location="cpu")
+
+    if osp.exists(vae_path):
+        vae_state_dict = load_file(vae_path, device="cpu")
+    else:
+        vae_path = osp.join(model_path, "vae", "diffusion_pytorch_model.bin")
+        vae_state_dict = torch.load(vae_path, map_location="cpu")
+
+    if osp.exists(text_enc_path):
+        text_enc_dict = load_file(text_enc_path, device="cpu")
+    else:
+        text_enc_path = osp.join(model_path, "text_encoder", "pytorch_model.bin")
+        text_enc_dict = torch.load(text_enc_path, map_location="cpu")
+
+    # Convert the UNet model
+    unet_state_dict = convert_unet_state_dict(unet_state_dict)
+    unet_state_dict = {"model.diffusion_model." + k: v for k, v in unet_state_dict.items()}
+
+    # Convert the VAE model
+    vae_state_dict = convert_vae_state_dict(vae_state_dict)
+    vae_state_dict = {"first_stage_model." + k: v for k, v in vae_state_dict.items()}
+
+    # Easiest way to identify v2.0 model seems to be that the text encoder (OpenCLIP) is deeper
+    is_v20_model = "text_model.encoder.layers.22.layer_norm2.bias" in text_enc_dict
+
+    if is_v20_model:
+        # Need to add the tag 'transformer' in advance so we can knock it out from the final layer-norm
+        text_enc_dict = {"transformer." + k: v for k, v in text_enc_dict.items()}
+        text_enc_dict = convert_text_enc_state_dict_v20(text_enc_dict)
+        text_enc_dict = {"cond_stage_model.model." + k: v for k, v in text_enc_dict.items()}
+    else:
+        text_enc_dict = convert_text_enc_state_dict(text_enc_dict)
+        text_enc_dict = {"cond_stage_model.transformer." + k: v for k, v in text_enc_dict.items()}
+
+    # Put together new checkpoint
+    state_dict = {**unet_state_dict, **vae_state_dict, **text_enc_dict}
+    if half:
+        state_dict = {k: v.half() for k, v in state_dict.items()}
+
+    save_file(state_dict, checkpoint_path)
+
+    progress(1, desc="Converted.")
+
+
+def download_repo(repo_id, dir_path, progress=gr.Progress(track_tqdm=True)):
+    from huggingface_hub import snapshot_download
+    try:
+        snapshot_download(repo_id=repo_id, local_dir=dir_path)
+    except Exception as e:
+        print(f"Error: Failed to download {repo_id}. ")
+        return
+
+
+def upload_safetensors_to_repo(filename, progress=gr.Progress(track_tqdm=True)):
+    from huggingface_hub import HfApi, hf_hub_url
+    import os
+    from pathlib import Path
+    output_filename = Path(filename).name
+    hf_token = os.environ.get("HF_TOKEN")
+    repo_id = os.environ.get("HF_OUTPUT_REPO")
+    api = HfApi()
+    try:
+        progress(0, desc="Start uploading...")
+        api.upload_file(path_or_fileobj=filename, path_in_repo=output_filename, repo_id=repo_id, token=hf_token)
+        progress(1, desc="Uploaded.")
+        url  = hf_hub_url(repo_id=repo_id, filename=output_filename)
+    except Exception as e:
+        print(f"Error: Failed to upload to {repo_id}. ")
+        return None
+    return url
+
+
+def convert_repo_to_safetensors(repo_id, half = True, progress=gr.Progress(track_tqdm=True)):
+    download_dir = f"{repo_id.split('/')[0]}_{repo_id.split('/')[-1]}"
+    output_filename = f"{repo_id.split('/')[0]}_{repo_id.split('/')[-1]}.safetensors"
+    download_repo(repo_id, download_dir)
+    convert_diffusers_to_safetensors(download_dir, output_filename, half)
+    return output_filename
+
+
+def convert_repo_to_safetensors_multi_sd(repo_id, files, is_upload, urls, half=True, progress=gr.Progress(track_tqdm=True)):
+    file = convert_repo_to_safetensors(repo_id, half)
+    if not urls: urls = []
+    url = ""
+    if is_upload:
+        url = upload_safetensors_to_repo(file)
+        if url: urls.append(url)
+    md = ""
+    for u in urls:
+        md += f"[Download {str(u).split('/')[-1]}]({str(u)})<br>"
+    if not files: files = []
+    files.append(file)
+    return gr.update(value=files), gr.update(value=urls, choices=urls), gr.update(value=md)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument("--repo_id", default=None, type=str, required=True, help="HF Repo ID of the model to convert.")
+    parser.add_argument("--half", default=True, help="Save weights in half precision.")
+
+    args = parser.parse_args()
+    assert args.repo_id is not None, "Must provide a Repo ID!"
+
+    convert_repo_to_safetensors(args.repo_id, args.half)

convert_url_to_diffusers_sdxl_gr.py

@@ -0,0 +1,367 @@
+import argparse
+from pathlib import Path
+import os
+import torch
+from diffusers import StableDiffusionXLPipeline, AutoencoderKL
+import gradio as gr
+# also requires aria, gdown, peft, huggingface_hub, safetensors, transformers, accelerate, pytorch_lightning
+
+
+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 download_thing(directory, url, civitai_api_key="", progress=gr.Progress(track_tqdm=True)):
+    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
+
+
+from diffusers import (
+    DPMSolverMultistepScheduler,
+    DPMSolverSinglestepScheduler,
+    KDPM2DiscreteScheduler,
+    EulerDiscreteScheduler,
+    EulerAncestralDiscreteScheduler,
+    HeunDiscreteScheduler,
+    LMSDiscreteScheduler,
+    DDIMScheduler,
+    DEISMultistepScheduler,
+    UniPCMultistepScheduler,
+    LCMScheduler,
+    PNDMScheduler,
+    KDPM2AncestralDiscreteScheduler,
+    DPMSolverSDEScheduler,
+    EDMDPMSolverMultistepScheduler,
+    DDPMScheduler,
+    EDMEulerScheduler,
+    TCDScheduler,
+)
+
+
+SCHEDULER_CONFIG_MAP = {
+    "DPM++ 2M": (DPMSolverMultistepScheduler, {"use_karras_sigmas": False}),
+    "DPM++ 2M Karras": (DPMSolverMultistepScheduler, {"use_karras_sigmas": True}),
+    "DPM++ 2M SDE": (DPMSolverMultistepScheduler, {"use_karras_sigmas": False, "algorithm_type": "sde-dpmsolver++"}),
+    "DPM++ 2M SDE Karras": (DPMSolverMultistepScheduler, {"use_karras_sigmas": True, "algorithm_type": "sde-dpmsolver++"}),
+    "DPM++ 2S": (DPMSolverSinglestepScheduler, {"use_karras_sigmas": False}),
+    "DPM++ 2S Karras": (DPMSolverSinglestepScheduler, {"use_karras_sigmas": True}),
+    "DPM++ 1S": (DPMSolverMultistepScheduler, {"solver_order": 1}),
+    "DPM++ 1S Karras": (DPMSolverMultistepScheduler, {"solver_order": 1, "use_karras_sigmas": True}),
+    "DPM++ 3M": (DPMSolverMultistepScheduler, {"solver_order": 3}),
+    "DPM++ 3M Karras": (DPMSolverMultistepScheduler, {"solver_order": 3, "use_karras_sigmas": True}),
+    "DPM++ SDE": (DPMSolverSDEScheduler, {"use_karras_sigmas": False}),
+    "DPM++ SDE Karras": (DPMSolverSDEScheduler, {"use_karras_sigmas": True}),
+    "DPM2": (KDPM2DiscreteScheduler, {}),
+    "DPM2 Karras": (KDPM2DiscreteScheduler, {"use_karras_sigmas": True}),
+    "DPM2 a": (KDPM2AncestralDiscreteScheduler, {}),
+    "DPM2 a Karras": (KDPM2AncestralDiscreteScheduler, {"use_karras_sigmas": True}),
+    "Euler": (EulerDiscreteScheduler, {}),
+    "Euler a": (EulerAncestralDiscreteScheduler, {}),
+    "Euler trailing": (EulerDiscreteScheduler, {"timestep_spacing": "trailing", "prediction_type": "sample"}),
+    "Euler a trailing": (EulerAncestralDiscreteScheduler, {"timestep_spacing": "trailing"}),
+    "Heun": (HeunDiscreteScheduler, {}),
+    "Heun Karras": (HeunDiscreteScheduler, {"use_karras_sigmas": True}),
+    "LMS": (LMSDiscreteScheduler, {}),
+    "LMS Karras": (LMSDiscreteScheduler, {"use_karras_sigmas": True}),
+    "DDIM": (DDIMScheduler, {}),
+    "DDIM trailing": (DDIMScheduler, {"timestep_spacing": "trailing"}),
+    "DEIS": (DEISMultistepScheduler, {}),
+    "UniPC": (UniPCMultistepScheduler, {}),
+    "UniPC Karras": (UniPCMultistepScheduler, {"use_karras_sigmas": True}),
+    "PNDM": (PNDMScheduler, {}),
+    "Euler EDM": (EDMEulerScheduler, {}),
+    "Euler EDM Karras": (EDMEulerScheduler, {"use_karras_sigmas": True}),
+    "DPM++ 2M EDM": (EDMDPMSolverMultistepScheduler, {"solver_order": 2, "solver_type": "midpoint", "final_sigmas_type": "zero", "algorithm_type": "dpmsolver++"}),
+    "DPM++ 2M EDM Karras": (EDMDPMSolverMultistepScheduler, {"use_karras_sigmas": True, "solver_order": 2, "solver_type": "midpoint", "final_sigmas_type": "zero", "algorithm_type": "dpmsolver++"}),
+    "DDPM": (DDPMScheduler, {}),
+
+    "DPM++ 2M Lu": (DPMSolverMultistepScheduler, {"use_lu_lambdas": True}),
+    "DPM++ 2M Ef": (DPMSolverMultistepScheduler, {"euler_at_final": True}),
+    "DPM++ 2M SDE Lu": (DPMSolverMultistepScheduler, {"use_lu_lambdas": True, "algorithm_type": "sde-dpmsolver++"}),
+    "DPM++ 2M SDE Ef": (DPMSolverMultistepScheduler, {"algorithm_type": "sde-dpmsolver++", "euler_at_final": True}),
+
+    "LCM": (LCMScheduler, {}),
+    "TCD": (TCDScheduler, {}),
+    "LCM trailing": (LCMScheduler, {"timestep_spacing": "trailing"}),
+    "TCD trailing": (TCDScheduler, {"timestep_spacing": "trailing"}),
+    "LCM Auto-Loader": (LCMScheduler, {}),
+    "TCD Auto-Loader": (TCDScheduler, {}),
+}
+
+
+def get_scheduler_config(name):
+    if not name in SCHEDULER_CONFIG_MAP.keys(): return SCHEDULER_CONFIG_MAP["Euler a"]
+    return SCHEDULER_CONFIG_MAP[name]
+
+
+def save_readme_md(dir, url):
+    orig_url = ""
+    orig_name = ""
+    if is_repo_name(url): 
+        orig_name = url
+        orig_url = f"https://huggingface.co/{url}/"
+    elif "http" in url:
+        orig_name = url
+        orig_url = url
+    if orig_name and orig_url:
+       md = f"""---
+license: other
+language:
+- en
+library_name: diffusers
+pipeline_tag: text-to-image
+tags:
+- text-to-image
+---
+Converted from [{orig_name}]({orig_url}).
+"""
+    else:
+        md = f"""---
+license: other
+language:
+- en
+library_name: diffusers
+pipeline_tag: text-to-image
+tags:
+- text-to-image
+---
+"""
+    path = str(Path(dir, "README.md"))
+    with open(path, mode='w', encoding="utf-8") as f:
+        f.write(md)
+
+
+def fuse_loras(pipe, lora_dict={}, temp_dir=".", civitai_key=""):
+    if not lora_dict or not isinstance(lora_dict, dict): return
+    a_list = []
+    w_list = []
+    for k, v in lora_dict.items():
+        if not k: continue
+        new_lora_file = get_download_file(temp_dir, k, civitai_key)
+        if not new_lora_file or not Path(new_lora_file).exists():
+            print(f"LoRA not found: {k}")
+            continue
+        w_name = Path(new_lora_file).name
+        a_name = Path(new_lora_file).stem
+        pipe.load_lora_weights(new_lora_file, weight_name = w_name, adapter_name = a_name)
+        a_list.append(a_name)
+        w_list.append(v)
+    if not a_list: return
+    pipe.set_adapters(a_list, adapter_weights=w_list)
+    pipe.fuse_lora(adapter_names=a_list, lora_scale=1.0)
+    pipe.unload_lora_weights()
+
+
+def convert_url_to_diffusers_sdxl(url, civitai_key="", is_upload_sf=False, half=True, vae=None, scheduler="Euler a", lora_dict={}, 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(".", "_") #
+
+    pipe = None
+    if is_repo_name(url):
+        if half:
+            pipe = StableDiffusionXLPipeline.from_pretrained(new_file, use_safetensors=True, torch_dtype=torch.float16)
+        else:
+            pipe = StableDiffusionXLPipeline.from_pretrained(new_file, use_safetensors=True)
+    else:
+        if half:
+            pipe = StableDiffusionXLPipeline.from_single_file(new_file, use_safetensors=True, torch_dtype=torch.float16)
+        else:
+            pipe = StableDiffusionXLPipeline.from_single_file(new_file, use_safetensors=True)
+
+    new_vae_file = ""
+    if vae:
+        if is_repo_name(vae):
+            if half:
+                pipe.vae = AutoencoderKL.from_pretrained(vae, torch_dtype=torch.float16)
+            else:
+                pipe.vae = AutoencoderKL.from_pretrained(vae)
+        else:
+            new_vae_file = get_download_file(temp_dir, vae, civitai_key)
+            if new_vae_file and half:
+                pipe.vae = AutoencoderKL.from_single_file(new_vae_file, torch_dtype=torch.float16)
+            elif new_vae_file:
+                pipe.vae = AutoencoderKL.from_single_file(new_vae_file)
+
+    fuse_loras(pipe, lora_dict, temp_dir, civitai_key)
+
+    sconf = get_scheduler_config(scheduler)
+    pipe.scheduler = sconf[0].from_config(pipe.scheduler.config, **sconf[1])
+
+    if half:
+        pipe.save_pretrained(new_repo_name, safe_serialization=True, use_safetensors=True)
+    else:
+        pipe.save_pretrained(new_repo_name, safe_serialization=True, use_safetensors=True)
+
+    if Path(new_repo_name).exists():
+        save_readme_md(new_repo_name, url)
+
+    if not is_repo_name(new_file) and is_upload_sf:
+        import shutil
+        shutil.move(str(Path(new_file).resolve()), str(Path(new_repo_name, Path(new_file).name).resolve()))
+
+    progress(1, desc="Converted.")
+    return new_repo_name
+
+
+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)
+        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
+
+
+def convert_url_to_diffusers_repo(dl_url, hf_user, hf_repo, hf_token, civitai_key="", is_upload_sf=False, repo_urls=[], half=True, vae=None,
+                                  scheduler="Euler a", lora1=None, lora1s=1.0, lora2=None, lora2s=1.0, lora3=None, lora3s=1.0,
+                                  lora4=None, lora4s=1.0, lora5=None, lora5s=1.0, progress=gr.Progress(track_tqdm=True)):
+    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")
+    lora_dict = {lora1: lora1s, lora2: lora2s, lora3: lora3s, lora4: lora4s, lora5: lora5s}
+    new_path = convert_url_to_diffusers_sdxl(dl_url, civitai_key, is_upload_sf, half, vae, scheduler, lora_dict)
+    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="")
+    repo_url = create_diffusers_repo(new_repo_id, 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=True, help="URL of the model to convert.")
+    parser.add_argument("--half", default=True, help="Save weights in half precision.")
+    parser.add_argument("--scheduler", default="Euler a", type=str, choices=list(SCHEDULER_CONFIG_MAP.keys()), required=False, help="Scheduler name to use.")
+    parser.add_argument("--vae", default=None, type=str, required=False, help="URL of the VAE to use.")
+    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("--lora1", default=None, type=str, required=False, help="URL of the LoRA to use.")
+    parser.add_argument("--lora1s", default=1.0, type=float, required=False, help="LoRA weight scale of --lora1.")
+    parser.add_argument("--lora2", default=None, type=str, required=False, help="URL of the LoRA to use.")
+    parser.add_argument("--lora2s", default=1.0, type=float, required=False, help="LoRA weight scale of --lora2.")
+    parser.add_argument("--lora3", default=None, type=str, required=False, help="URL of the LoRA to use.")
+    parser.add_argument("--lora3s", default=1.0, type=float, required=False, help="LoRA weight scale of --lora3.")
+    parser.add_argument("--lora4", default=None, type=str, required=False, help="URL of the LoRA to use.")
+    parser.add_argument("--lora4s", default=1.0, type=float, required=False, help="LoRA weight scale of --lora4.")
+    parser.add_argument("--lora5", default=None, type=str, required=False, help="URL of the LoRA to use.")
+    parser.add_argument("--lora5s", default=1.0, type=float, required=False, help="LoRA weight scale of --lora5.")
+    parser.add_argument("--loras", default=None, type=str, required=False, help="Folder of the LoRA to use.")
+
+    args = parser.parse_args()
+    assert args.url is not None, "Must provide a URL!"
+
+    lora_dict = {args.lora1: args.lora1s, args.lora2: args.lora2s, args.lora3: args.lora3s, args.lora4: args.lora4s, args.lora5: args.lora5s}
+
+    if args.loras and Path(args.loras).exists():
+        for p in Path(args.loras).glob('**/*.safetensors'):
+            lora_dict[str(p)] = 1.0
+
+    convert_url_to_diffusers_sdxl(args.url, args.civitai_key, args.half, args.vae, args.scheduler, lora_dict)

hf_merge.py

@@ -0,0 +1,352 @@
+from tqdm import tqdm
+import argparse
+import requests
+import merge
+import os
+import sys
+import shutil
+import yaml
+from pathlib import Path
+import gradio as gr
+
+def parse_arguments():
+    parser = argparse.ArgumentParser(description="Merge HuggingFace models")
+    parser.add_argument('repo_list', type=str, help='File containing list of repositories to merge, supports mergekit yaml or txt')
+    parser.add_argument('output_dir', type=str, help='Directory for the merged models')
+    parser.add_argument('-base_model', type=str, default='staging/base_model', help='Base model directory')
+    parser.add_argument('-staging_model', type=str, default='staging/merge_model', help='Staging model directory')
+    parser.add_argument('-p', type=float, default=0.5, help='Dropout probability')
+    parser.add_argument('-lambda', dest='lambda_val', type=float, default=1.0, help='Scaling factor for the weight delta')
+    parser.add_argument('--dry', action='store_true', help='Run in dry mode without making any changes')
+    return parser.parse_args()
+
+def repo_list_generator(file_path, default_p, default_lambda_val):
+    _, file_extension = os.path.splitext(file_path)
+
+    # Branching based on file extension
+    if file_extension.lower() == '.yaml' or file_extension.lower() == ".yml":
+        with open(file_path, 'r', encoding='utf-8') as file:
+            data = yaml.safe_load(file)
+        for model_info in data['models']:
+            model_name = model_info['model']
+            p = model_info.get('parameters', {}).get('weight', default_p)
+            lambda_val = 1 / model_info.get('parameters', {}).get('density', default_lambda_val)
+            yield model_name, p, lambda_val
+
+    else:  # Defaulting to txt file processing
+        with open(file_path, "r", encoding='utf-8') as file:
+            repos_to_process = file.readlines()
+        for repo in repos_to_process:
+            yield repo.strip(), default_p, default_lambda_val
+
+def reset_directories(directories, dry_run):
+    for directory in directories:
+        if os.path.exists(directory):
+            if dry_run:
+                print(f"[DRY RUN] Would delete directory {directory}")
+            else:
+                shutil.rmtree(directory)
+                print(f"Directory {directory} deleted successfully.")
+
+def do_merge(tensor_map, staging_path, p, lambda_val, dry_run=False):
+    if dry_run:
+        print(f"[DRY RUN] Would merge with {staging_path}")
+    else:
+        try:
+            print(f"Merge operation for {staging_path}")
+            tensor_map = merge.merge_folder(tensor_map, staging_path, p, lambda_val)
+            print("Merge operation completed successfully.")
+        except Exception as e:
+            print(f"Error during merge operation: {e}")
+    return tensor_map
+
+def do_merge_files(base_path, staging_path, output_path, p, lambda_val, dry_run=False):
+    if dry_run:
+        print(f"[DRY RUN] Would merge with {staging_path}")
+    else:
+        try:
+            print(f"Merge operation for {staging_path}")
+            tensor_map = merge.merge_files(base_path, staging_path, output_path, p, lambda_val)
+            print("Merge operation completed successfully.")
+        except Exception as e:
+            print(f"Error during merge operation: {e}")
+    return tensor_map
+
+def do_merge_diffusers(tensor_map, staging_path, p, lambda_val, skip_dirs, dry_run=False):
+    if dry_run:
+        print(f"[DRY RUN] Would merge with {staging_path}")
+    else:
+        try:
+            print(f"Merge operation for {staging_path}")
+            tensor_map = merge.merge_folder_diffusers(tensor_map, staging_path, p, lambda_val, skip_dirs)
+            print("Merge operation completed successfully.")
+        except Exception as e:
+            print(f"Error during merge operation: {e}")
+    return tensor_map
+
+def download_repo(repo_name, path, dry_run=False):
+    from huggingface_hub import snapshot_download
+    if dry_run:
+        print(f"[DRY RUN] Would download repository {repo_name} to {path}")
+    else:
+        print(f"Repository {repo_name} cloning.")
+        try:
+            snapshot_download(repo_id=repo_name, local_dir=path)
+        except Exception as e:
+            print(e)
+            return
+        print(f"Repository {repo_name} cloned successfully.")
+
+def download_thing(directory, url, progress=gr.Progress(track_tqdm=True)):
+    civitai_api_key= os.environ.get("CIVITAI_API_KEY")
+    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 list_sub(a, b):
+    return [e for e in a if e not in b]
+
+def get_download_file(temp_dir, url):
+    new_file = None
+    if 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())
+        except Exception:
+            print(f"Download failed: {url}")
+            return None
+        after = get_local_model_list(temp_dir)
+        new_file = list_sub(after, before)[0] if list_sub(after, before) else None
+    if new_file is None:
+        print(f"Download failed: {url}")
+        return None
+    print(f"Download completed: {url}")
+    return new_file
+
+def download_file(url, path, dry_run=False):
+    if dry_run:
+        print(f"[DRY RUN] Would download file {url} to {path}")
+    else:
+        print(f"File {url} cloning.")
+        try:
+            path = get_download_file(path, url)
+        except Exception as e:
+            print(e)
+            return None
+        print(f"File {url} cloned successfully.")
+        return path
+
+def is_repo_name(s):
+    import re
+    return re.fullmatch(r'^[^/,\s]+?/[^/,\s]+?$', s)
+
+def should_create_symlink(repo_name):
+    if os.path.exists(repo_name):
+        return True, os.path.isfile(repo_name)
+    return False, False
+
+def download_or_link_repo(repo_name, path, dry_run=False):
+    symlink, is_file = should_create_symlink(repo_name)
+
+    if symlink and is_file:
+        os.makedirs(path, exist_ok=True)
+        symlink_path = os.path.join(path, os.path.basename(repo_name))
+        os.symlink(repo_name, symlink_path)
+    elif symlink:
+        os.symlink(repo_name, path)
+    elif "http" in repo_name:
+        return download_file(repo_name, path, dry_run)
+    elif is_repo_name(repo_name):
+        download_repo(repo_name, path, dry_run)
+    return None
+
+def delete_repo(path, dry_run=False):
+    if dry_run:
+        print(f"[DRY RUN] Would delete repository at {path}")
+    else:
+        try:
+            shutil.rmtree(path)
+            print(f"Repository at {path} deleted successfully.")
+        except Exception as e:
+            print(f"Error deleting repository at {path}: {e}")
+
+def get_max_vocab_size(repo_list):
+    max_vocab_size = 0
+    repo_with_max_vocab = None
+
+    for repo in repo_list:
+        repo_name = repo[0].strip()
+        url = f"https://huggingface.co/{repo_name}/raw/main/config.json"
+
+        try:
+            response = requests.get(url)
+            response.raise_for_status()
+            config = response.json()
+            vocab_size = config.get("vocab_size", 0)
+
+            if vocab_size > max_vocab_size:
+                max_vocab_size = vocab_size
+                repo_with_max_vocab = repo_name
+
+        except requests.RequestException as e:
+            print(f"Error fetching data from {url}: {e}")
+
+    return max_vocab_size, repo_with_max_vocab
+
+def download_json_files(repo_name, file_paths, output_dir):
+    base_url = f"https://huggingface.co/{repo_name}/raw/main/"
+
+    for file_path in file_paths:
+        url = base_url + file_path
+        response = requests.get(url)
+        if response.status_code == 200:
+            with open(os.path.join(output_dir, os.path.basename(file_path)), 'wb') as file:
+                file.write(response.content)
+        else:
+            print(f"Failed to download {file_path}")
+
+def get_merged_path(filename, output_dir):
+    from datetime import datetime, timezone, timedelta
+    dt_now = datetime.now(timezone(timedelta(hours=9)))
+    basename = dt_now.strftime('Merged_%Y%m%d_%H%M')
+    ext = Path(filename).suffix
+    return str(Path(output_dir, basename + ext)), str(Path(output_dir, basename + ".yaml"))
+
+def repo_list_to_yaml(repo_list_path, repo_list, output_yaml_path):
+    if Path(repo_list_path).suffix.lower() in (".yaml", ".yml"):
+        shutil.copy(repo_list_path, output_yaml_path)
+    else:
+        repos = list(repo_list)
+        yaml_dict = {}
+        yaml_dict.setdefault('models', {})
+        for repo in repos:
+            model, weight, density = repo
+            model_info = {}
+            model_info['model'] = str(model)
+            model_info.setdefault('parameters', {})
+            model_info['parameters']['weight'] = float(weight)
+            model_info['parameters']['density'] = float(density)
+            yaml_dict['models'][str(model.split("/")[-1])] = model_info
+        with open(output_yaml_path, mode='w', encoding='utf-8') as file:
+            yaml.dump(yaml_dict, file, default_flow_style=False, allow_unicode=True)
+
+def process_repos(output_dir, base_model, staging_model, repo_list_file, p, lambda_val, skip_dirs, dry_run=False, progress=gr.Progress(track_tqdm=True)):
+    repo_type = "Default" # ("Default", "Files", "Diffusers")
+    # Check if output_dir exists
+    if os.path.exists(output_dir):
+        sys.exit(f"Output directory '{output_dir}' already exists. Exiting to prevent data loss.")
+
+    # Reset base and staging directories
+    reset_directories([base_model, staging_model], dry_run)
+
+    # Make sure staging and output directories exist
+    os.makedirs(base_model, exist_ok=True)
+    os.makedirs(staging_model, exist_ok=True)
+
+    repo_list_gen = repo_list_generator(repo_list_file, p, lambda_val)
+
+    repos_to_process = list(repo_list_gen)
+
+    # Initial download for 'base_model'
+    path = download_or_link_repo(repos_to_process[0][0].strip(), base_model, dry_run)
+    if path is not None and (".safetensors" in path or ".sft" in path): repo_type = "Files"
+    elif Path(base_model, "model_index.json").exists(): repo_type = "Diffusers"
+    if repo_type == "Files":
+        os.makedirs(output_dir, exist_ok=True)
+        output_file_path, output_yaml_path = get_merged_path(path, output_dir)
+        repo_list_to_yaml(repo_list_file, repo_list_gen, output_yaml_path)
+        for i, repo in enumerate(tqdm(repos_to_process[1:], desc='Merging Files')):
+            repo_name = repo[0].strip()
+            repo_p = repo[1]
+            repo_lambda = repo[2]
+            delete_repo(staging_model, dry_run)
+            staging_path = download_or_link_repo(repo_name, staging_model, dry_run)
+            do_merge_files(path, staging_path, output_file_path, repo_p, repo_lambda, dry_run)
+        reset_directories([base_model, staging_model], dry_run)
+        return output_file_path, output_yaml_path
+    elif repo_type == "Diffusers":
+        merge.copy_dirs(base_model, output_dir)
+        tensor_map = merge.map_tensors_to_files_diffusers(base_model, skip_dirs)
+
+        for i, repo in enumerate(tqdm(repos_to_process[1:], desc='Merging Repos')):
+            repo_name = repo[0].strip()
+            repo_p = repo[1]
+            repo_lambda = repo[2]
+            delete_repo(staging_model, dry_run)
+            download_or_link_repo(repo_name, staging_model, dry_run)
+            tensor_map = do_merge_diffusers(tensor_map, staging_model, repo_p, repo_lambda, skip_dirs, dry_run)
+
+        os.makedirs(output_dir, exist_ok=True)
+        merge.copy_skipped_dirs(base_model, output_dir, skip_dirs)
+        merge.copy_nontensor_files(base_model, output_dir)
+        merge.save_tensor_map(tensor_map, output_dir)
+
+        reset_directories([base_model, staging_model], dry_run)
+        return None, None
+    elif repo_type == "Default":
+        merge.copy_dirs(base_model, output_dir)
+        tensor_map = merge.map_tensors_to_files(base_model)
+
+        for i, repo in enumerate(tqdm(repos_to_process[1:], desc='Merging Repos')):
+            repo_name = repo[0].strip()
+            repo_p = repo[1]
+            repo_lambda = repo[2]
+            delete_repo(staging_model, dry_run)
+            download_or_link_repo(repo_name, staging_model, dry_run)
+            tensor_map = do_merge(tensor_map, staging_model, repo_p, repo_lambda, dry_run)
+
+        os.makedirs(output_dir, exist_ok=True)
+        merge.copy_nontensor_files(base_model, output_dir)
+
+        # Handle LLMs that add tokens by taking the largest
+        if os.path.exists(os.path.join(output_dir, 'config.json')):
+            max_vocab_size, repo_name = get_max_vocab_size(repos_to_process)
+            if max_vocab_size > 0:
+                file_paths = ['config.json', 'special_tokens_map.json', 'tokenizer.json', 'tokenizer_config.json']
+                download_json_files(repo_name, file_paths, output_dir)
+
+        reset_directories([base_model, staging_model], dry_run)
+        merge.save_tensor_map(tensor_map, output_dir)
+        return None, None
+
+if __name__ == "__main__":
+    args = parse_arguments()
+    skip_dirs = ['vae', 'text_encoder']
+    process_repos(args.output_dir, args.base_model, args.staging_model, args.repo_list, args.p, args.lambda_val, skip_dirs, args.dry)
+

merge.py

@@ -0,0 +1,257 @@
+import argparse
+import numpy as np
+import os
+import shutil
+import torch
+import torch.nn.functional as F
+from safetensors.torch import safe_open, save_file
+import glob
+from pathlib import Path
+
+def merge_tensors(tensor1, tensor2, p):
+    # Calculate the delta of the weights
+    delta = tensor2 - tensor1
+    # Generate the mask m^t from Bernoulli distribution
+    m = torch.from_numpy(np.random.binomial(1, p, delta.shape)).to(tensor1.dtype)
+    # Apply the mask to the delta to get δ̃^t
+    delta_tilde = m * delta
+    # Scale the masked delta by the dropout rate to get δ̂^t
+    delta_hat = delta_tilde / (1 - p)
+    return delta_hat
+
+def merge_safetensors(file_path1, file_path2, p, lambda_val):
+    merged_tensors = {}
+
+    with safe_open(file_path1, framework="pt", device="cpu") as f1, safe_open(file_path2, framework="pt", device="cpu") as f2:
+        keys1 = set(f1.keys())
+        keys2 = set(f2.keys())
+        common_keys = keys1.intersection(keys2)
+
+        for key in common_keys:
+            tensor1 = f1.get_tensor(key)
+            tensor2 = f2.get_tensor(key)
+            tensor1, tensor2 = resize_tensors(tensor1, tensor2)
+            merged_tensors[key] = tensor1 + lambda_val * merge_tensors(tensor1, tensor2, p)
+            print("merging", key)
+
+    return merged_tensors
+
+class BinDataHandler():
+    def __init__(self, data):
+        self.data = data
+
+    def get_tensor(self, key):
+        return self.data[key]
+
+def read_tensors(file_path, ext):
+    if ext == ".safetensors" and (file_path.endswith(".safetensors") or file_path.endswith(".sft")):
+        print(f"Reading tensors from {file_path} in {ext} format.")
+        f = safe_open(file_path, framework="pt", device="cpu")
+        return f, set(f.keys())
+    if ext == ".bin" and file_path.endswith(".bin"):
+        print(f"Reading tensors from {file_path} in {ext} format.")
+        data = torch.load(file_path, map_location=torch.device('cpu'))
+        f = BinDataHandler(data)
+        return f, set(data.keys())
+    return None, None
+
+def resize_tensors(tensor1, tensor2):
+    if len(tensor1.shape) not in [1, 2]:
+        return tensor1, tensor2
+    
+    if len(tensor1.shape) == 1 and len(tensor2.shape) == 1:
+        if tensor1.shape[-1] < tensor2.shape[-1]:
+            padding_size = tensor2.shape[-1] - tensor1.shape[-1]
+            pad = torch.nn.ConstantPad1d((padding_size, 0), 0)
+            tensor1 = pad(tensor1)
+        elif tensor2.shape[-1] < tensor1.shape[-1]:
+            padding_size = tensor1.shape[-1] - tensor2.shape[-1]
+            pad = torch.nn.ConstantPad1d((padding_size, 0), 0)
+            tensor2 = pad(tensor2)
+    else:
+        # Pad along the last dimension (width)
+        if tensor1.shape[-1] < tensor2.shape[-1]:
+            padding_size = tensor2.shape[-1] - tensor1.shape[-1]
+            tensor1 = F.pad(tensor1, (0, padding_size, 0, 0))
+        elif tensor2.shape[-1] < tensor1.shape[-1]:
+            padding_size = tensor1.shape[-1] - tensor2.shape[-1]
+            tensor2 = F.pad(tensor2, (0, padding_size, 0, 0))
+
+        # Pad along the first dimension (height)
+        if tensor1.shape[0] < tensor2.shape[0]:
+            padding_size = tensor2.shape[0] - tensor1.shape[0]
+            tensor1 = F.pad(tensor1, (0, 0, 0, padding_size))
+        elif tensor2.shape[0] < tensor1.shape[0]:
+            padding_size = tensor1.shape[0] - tensor2.shape[0]
+            tensor2 = F.pad(tensor2, (0, 0, 0, padding_size))
+
+    return tensor1, tensor2
+
+def merge_folder(tensor_map, directory_path, p, lambda_val):
+    keys1 = set(tensor_map.keys())
+    # Some repos have both bin and safetensors, choose safetensors if so
+    ext = None
+    for filename in glob.glob(f'{directory_path}/**', recursive=True):
+        filename = os.path.normpath(filename)
+        # Default to safetensors
+        if filename.endswith(".safetensors") or filename.endswith(".sft"):
+            ext = ".safetensors"
+        if filename.endswith(".bin") and ext is None:
+            ext = ".bin"
+    if ext is None:
+        raise "Could not find model files"
+
+    for filename in glob.glob(f'{directory_path}/**', recursive=True):
+        filename = os.path.normpath(filename)
+        f2, keys2 = read_tensors(filename, ext)
+        if keys2:
+            common_keys = keys1.intersection(keys2)
+            for key in common_keys:
+                if "block_sparse_moe.gate" in key:
+                    tensor1 = tensor_map[key]['tensor']
+                    tensor2 = f2.get_tensor(key)
+                    tensor_map[key]['tensor'] = (tensor1 + tensor2) /2.0
+                    print("merging", key)
+                    continue
+                tensor1 = tensor_map[key]['tensor']
+                tensor2 = f2.get_tensor(key)
+                tensor1, tensor2 = resize_tensors(tensor1, tensor2)
+                tensor_map[key]['tensor'] = tensor1 + lambda_val * merge_tensors(tensor1, tensor2, p)
+                print("merging", key)
+    return tensor_map
+
+def merge_folder_diffusers(tensor_map, directory_path, p, lambda_val, skip_dirs):
+    keys1 = set(tensor_map.keys())
+    # Some repos have both bin and safetensors, choose safetensors if so
+    ext = None
+    for filename in [p for p in glob.glob(f'{directory_path}/*', recursive=False) if ".fp16." not in p]:
+        filename = os.path.normpath(filename)
+        # Default to safetensors
+        if filename.endswith(".safetensors") or filename.endswith(".sft"):
+            ext = ".safetensors"
+        if filename.endswith(".bin") and ext is None:
+            ext = ".bin"
+    if ext is None:
+        raise "Could not find model files"
+
+    for dirname in glob.glob(f'{directory_path}/*/', recursive=False):
+        if Path(dirname).stem in skip_dirs: continue
+        for filename in [p for p in glob.glob(f'{dirname}/*', recursive=False) if ".fp16." not in p]:
+            filename = os.path.normpath(filename)
+            f2, keys2 = read_tensors(filename, ext)
+            if keys2:
+                common_keys = keys1.intersection(keys2)
+                for key in common_keys:
+                    if "block_sparse_moe.gate" in key:
+                        tensor1 = tensor_map[key]['tensor']
+                        tensor2 = f2.get_tensor(key)
+                        tensor_map[key]['tensor'] = (tensor1 + tensor2) /2.0
+                        print("merging", key)
+                        continue
+                    tensor1 = tensor_map[key]['tensor']
+                    tensor2 = f2.get_tensor(key)
+                    tensor1, tensor2 = resize_tensors(tensor1, tensor2)
+                    tensor_map[key]['tensor'] = tensor1 + lambda_val * merge_tensors(tensor1, tensor2, p)
+                    print("merging", key)
+    return tensor_map
+
+def merge_files(base_model, second_model, output_model, p, lambda_val):
+        merged = merge_safetensors(base_model, second_model, p, lambda_val)
+        save_file(merged, output_model)
+
+def map_tensors_to_files(directory_path):
+    tensor_map = {}
+
+    for filename in glob.glob(f'{directory_path}/**', recursive=True):
+        filename = os.path.normpath(filename)
+        f, keys = read_tensors(filename, '.safetensors')
+        if keys:
+            for key in keys:
+                tensor = f.get_tensor(key)
+                tensor_map[key] = {'filename':filename, 'shape':tensor.shape, 'tensor': tensor}
+
+    return tensor_map
+
+def map_tensors_to_files_diffusers(directory_path, skip_dirs):
+    tensor_map = {}
+
+    for dirname in glob.glob(f'{directory_path}/*/', recursive=False):
+        if Path(dirname).stem in skip_dirs: continue
+        for filename in [p for p in glob.glob(f'{dirname}/*', recursive=False) if ".fp16." not in p]:
+            filename = os.path.normpath(filename)
+            f, keys = read_tensors(filename, '.safetensors')
+            if keys:
+                for key in keys:
+                    tensor = f.get_tensor(key)
+                    tensor_map[key] = {'filename':filename, 'shape':tensor.shape, 'tensor': tensor}
+
+    return tensor_map
+
+def copy_nontensor_files(from_path, to_path):
+    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*"), dirs_exist_ok=True)
+
+def copy_skipped_dirs(from_path, to_path, skip_dirs):
+    for dirname in glob.glob(f'{from_path}/*/', recursive=False):
+        if Path(dirname).stem in skip_dirs:
+            dirname = os.path.normpath(dirname)
+            print(f"Copying skipped files {dirname} to {to_path}")
+            shutil.copytree(Path(dirname).resolve(), Path(to_path, Path(dirname).stem).resolve(), ignore=shutil.ignore_patterns(".*", "README*"), dirs_exist_ok=True)
+
+def save_tensor_map(tensor_map, output_folder):
+    metadata = {'format': 'pt'}
+    by_filename = {}
+
+    for key, value in tensor_map.items():
+        filename = value["filename"]
+        tensor = value["tensor"]
+        filename = os.path.normpath(filename)
+        if filename not in by_filename:
+            by_filename[filename] = {}
+        by_filename[filename][key] = tensor
+
+    for filename in sorted(by_filename.keys()):
+        filename = os.path.normpath(filename)
+        if Path(output_folder, Path(filename).parent.name).exists():
+            output_file = str(Path(output_folder, Path(filename).parent.name, Path(filename).name))
+        else:
+            output_file = str(Path(output_folder, Path(filename).name))
+        print("Saving:", output_file)
+        save_file(by_filename[filename], output_file, metadata=metadata)
+
+def copy_dirs(src: str, dst: str):
+    shutil.copytree(src, dst, ignore=shutil.ignore_patterns("*.*"), dirs_exist_ok=True)
+
+def main():
+    # Parse command-line arguments
+    parser = argparse.ArgumentParser(description='Merge two safetensor model files.')
+    parser.add_argument('base_model', type=str, help='The base model safetensor file')
+    parser.add_argument('second_model', type=str, help='The second model safetensor file')
+    parser.add_argument('output_model', type=str, help='The output merged model safetensor file')
+    parser.add_argument('-p', type=float, default=0.5, help='Dropout probability')
+    parser.add_argument('-lambda', dest='lambda_val', type=float, default=1.0, help='Scaling factor for the weight delta')
+    args = parser.parse_args()
+
+    skip_dirs = ['vae', 'text_encoder']
+    if os.path.isdir(args.base_model):
+        if not os.path.exists(args.output_model):
+            os.makedirs(args.output_model)
+        if os.path.exists(args.base_model + "/model_index.json"): # assume Diffusers Repo
+            copy_dirs(args.base_model, args.output_model)
+            tensor_map = map_tensors_to_files_diffusers(args.base_model, skip_dirs)
+            tensor_map = merge_folder_diffusers(tensor_map, args.second_model, args.p, args.lambda_val, skip_dirs)
+            copy_skipped_dirs(args.base_model, args.output_model, skip_dirs)
+            copy_nontensor_files(args.base_model, args.output_model)
+            save_tensor_map(tensor_map, args.output_model)
+        else:
+            copy_dirs(args.base_model, args.output_model)
+            tensor_map = map_tensors_to_files(args.base_model)
+            tensor_map = merge_folder(tensor_map, args.second_model, args.p, args.lambda_val)
+            copy_nontensor_files(args.base_model, args.output_model)
+            save_tensor_map(tensor_map, args.output_model)
+    else:
+        merged = merge_safetensors(args.base_model, args.second_model, args.p, args.lambda_val)
+        save_file(merged, args.output_model)
+
+if __name__ == '__main__':
+    main()

merge_gr.py

@@ -0,0 +1,249 @@
+from pathlib import Path
+import os
+import shutil
+import yaml
+import gradio as gr
+from hf_merge import process_repos, repo_list_generator
+
+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 is_valid_model_name(s):
+    if is_repo_name(s) or Path(s).suffix in (".safetensors", ".bin", ".sft"): return True
+    else: return False
+
+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_repo(new_repo_id):
+    from huggingface_hub import HfApi
+    import os
+    hf_token = os.environ.get("HF_TOKEN")
+    api = HfApi()
+    try:
+        api.create_repo(repo_id=new_repo_id, token=hf_token, private=True)
+        url = f"https://huggingface.co/{new_repo_id}"
+    except Exception as e:
+        print(f"Error: Failed to create {new_repo_id}. ")
+        print(e)
+        return ""
+    return url
+
+def upload_dir_to_repo(new_repo_id, 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...")
+        for path in Path(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
+
+merge_yaml_path = "./merge_yaml.yaml"
+merge_text_path = "./merge_txt.txt"
+
+def load_yaml_dict(yaml_path: str):
+    yaml_dict = None
+    try:
+        data = None
+        with open(yaml_path, 'r', encoding='utf-8') as file:
+            data = yaml.safe_load(file)
+    except Exception as e:
+        print(e)
+        data = None
+    if isinstance(data, dict) and 'models' in data.keys() and data['models']:
+        yaml_dict = data
+    return yaml_dict
+
+def repo_text_to_yaml_dict(text_path: str, default_p: float, default_lambda_val: float):
+    yaml_dict = {}
+    repos = list(repo_list_generator(text_path, default_p, default_lambda_val))
+    yaml_dict.setdefault('models', {})
+    for repo in repos:
+        model, weight, density = repo
+        if not is_valid_model_name(model): continue
+        model_info = {}
+        model_info['model'] = str(model)
+        model_info.setdefault('parameters', {})
+        model_info['parameters']['weight'] = float(weight)
+        model_info['parameters']['density'] = float(density)
+        yaml_dict['models'][str(model.split("/")[-1])] = model_info
+    return yaml_dict
+
+def gen_repo_list(input_text: str, default_p: float, default_lambda_val: float):
+    yaml_dict = {}
+    if Path(merge_yaml_path).exists():
+        yaml_dict = load_yaml_dict(merge_yaml_path)
+    else:
+        with open(merge_text_path, mode='w', encoding='utf-8') as file:
+            file.write(input_text)
+        yaml_dict = repo_text_to_yaml_dict(merge_text_path, default_p, default_lambda_val)
+    yaml_str = yaml.dump(yaml_dict, allow_unicode=True)
+    md = f"""``` yaml
+    {yaml_str}
+    ```"""
+    return md
+
+def upload_repo_list(filepath: str, default_p: float, default_lambda_val: float):
+    yaml_dict = {}
+    if Path(filepath).suffix in [".yml", ".yaml"]:
+        yaml_dict = load_yaml_dict(filepath)
+    if yaml_dict is not None:
+        with open(merge_yaml_path, mode='w', encoding='utf-8') as file:
+            yaml.dump(yaml_dict, file, default_flow_style=False, allow_unicode=True)
+    else:
+        yaml_dict = repo_text_to_yaml_dict(filepath, default_p, default_lambda_val)
+        shutil.copy(filepath, merge_text_path)
+    yaml_str = yaml.dump(yaml_dict, allow_unicode=True)
+    md = f"""``` yaml
+    {yaml_str}
+    ```"""
+    return md
+
+def clear_repo_list():
+    Path(merge_text_path).unlink(missing_ok=True)
+    Path(merge_yaml_path).unlink(missing_ok=True)
+    return gr.update(value=""), gr.update(value="")
+
+def clear_output(output_dir: str):
+    shutil.rmtree(output_dir, ignore_errors=True)
+    print(f"Directory {output_dir} deleted successfully.")
+
+def process_repos_gr(mode, p, lambda_val, skip_dirs: list[str], hf_user: str, hf_repo: str, hf_token: str,
+                     is_upload=True, is_upload_sf=False, repo_exist_ok=False, files=[], repo_urls=[], progress=gr.Progress(track_tqdm=True)):
+    if is_upload and not hf_user:
+        print(f"Invalid user name: {hf_user}")
+        progress(1, desc=f"Invalid user name: {hf_user}")
+        return gr.update(value=files), gr.update(value=repo_urls, choices=repo_urls), gr.update(visible=True)
+    if hf_token and not os.environ.get("HF_TOKEN"): os.environ['HF_TOKEN'] = hf_token
+    output_dir = "output"
+    base_model = "base_model"
+    staging_model = "staging_model"
+    output_model = str(Path(output_dir, base_model))
+    output_model = output_dir
+    repo_list_file = None
+    if is_upload:
+        clear_output(output_dir)
+        files = []
+    if Path(merge_yaml_path).exists(): repo_list_file = merge_yaml_path
+    elif Path(merge_text_path).exists(): repo_list_file = merge_text_path
+    if repo_list_file is None:
+        print("Repo list is not found.")
+        progress(1, desc="Repo list is not found.")
+        return gr.update(value=files), gr.update(value=repo_urls, choices=repo_urls), gr.update(visible=True)
+    new_repo_id = f"{hf_user}/{hf_repo}"
+    if is_upload and 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=files), gr.update(value=repo_urls, choices=repo_urls), gr.update(visible=True)
+    if is_upload and is_repo_exists(new_repo_id):
+        print(f"Repo already exists: {new_repo_id}")
+        if not repo_exist_ok:
+            progress(1, desc=f"Repo already exists: {new_repo_id}")
+            return gr.update(value=files), gr.update(value=repo_urls, choices=repo_urls), gr.update(visible=True)
+    try:
+        progress(0, desc=f"Downloading Repos.")
+        if mode == "SDXL":
+            output_file_path, output_yaml_path = process_repos(output_dir, base_model, staging_model,
+             repo_list_file, p, lambda_val, skip_dirs + ["text_encoder"], False)
+        else:
+            output_file_path, output_yaml_path = process_repos(output_dir, base_model, staging_model,
+             repo_list_file, p, lambda_val, skip_dirs, False)
+        if mode == "Single files":
+            files.append(output_file_path)
+            files.append(output_yaml_path)
+    except Exception as e:
+        print(e)
+        progress(1, desc=f"Error occured: {e}")
+    repo_url = None
+    if Path(output_model).exists():
+        if mode != "Single files": save_readme_md(output_model, repo_list_file, p, lambda_val)
+        if is_upload_sf:
+            if mode == "SDXL": files.append(convert_output_to_safetensors(output_model, hf_repo))
+            elif mode == "SD1.5": files.append(convert_output_to_safetensors_sd(output_model, hf_repo))
+        if is_upload:
+            if not is_repo_exists(new_repo_id): create_repo(new_repo_id)
+            repo_url = upload_dir_to_repo(new_repo_id, output_model)
+    else:
+        progress(1, desc=f"Merging failed.")
+        return gr.update(value=files), gr.update(value=repo_urls, choices=repo_urls), gr.update(visible=True)
+    if not repo_urls: repo_urls = []
+    if repo_url: 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=files), gr.update(value=repo_urls, choices=repo_urls), gr.update(value=md)
+
+from convert_repo_to_safetensors_gr import convert_diffusers_to_safetensors
+def convert_output_to_safetensors(output_dir: str, repo_name: str, progress=gr.Progress(track_tqdm=True)):
+    output_filename = f"{repo_name}.safetensors"
+    convert_diffusers_to_safetensors(output_dir, Path(output_dir, output_filename))
+    return output_filename
+
+from convert_repo_to_safetensors_sd_gr import convert_diffusers_to_safetensors as convert_diffusers_to_safetensors_sd
+def convert_output_to_safetensors_sd(output_dir: str, repo_name: str, progress=gr.Progress(track_tqdm=True)):
+    output_filename = f"{repo_name}.safetensors"
+    convert_diffusers_to_safetensors_sd(output_dir, Path(output_dir, output_filename))
+    return output_filename
+
+def upload_repo_list(filepath: str, default_p: float, default_lambda_val: float):
+    yaml_dict = {}
+    if Path(filepath).suffix in [".yml", ".yaml"]:
+        yaml_dict = load_yaml_dict(filepath)
+    if yaml_dict is not None:
+        with open(merge_yaml_path, mode='w', encoding='utf-8') as file:
+            yaml.dump(yaml_dict, file, default_flow_style=False, allow_unicode=True)
+    else:
+        yaml_dict = repo_text_to_yaml_dict(filepath, default_p, default_lambda_val)
+        shutil.copy(filepath, merge_text_path)
+    yaml_str = yaml.dump(yaml_dict, allow_unicode=True)
+    md = f"""``` yaml
+    {yaml_str}
+    ```"""
+    return md
+
+def save_readme_md(dir: str, yaml_path:str, default_p: float, default_lambda_val: float):
+    yaml_dict = {}
+    if Path(yaml_path).suffix in [".yml", ".yaml"]:
+        yaml_dict = load_yaml_dict(yaml_path)
+    else:
+        yaml_dict = repo_text_to_yaml_dict(yaml_path, default_p, default_lambda_val)
+    yaml_str = yaml.dump(yaml_dict, allow_unicode=True)
+    md = f"""---
+license: other
+language:
+- en
+library_name: diffusers
+pipeline_tag: text-to-image
+tags:
+- text-to-image
+---
+<br>Merged model.<br>
+## 🧩 Configuration
+``` yaml
+{yaml_str}
+```"""
+    path = str(Path(dir, "README.md"))
+    with open(path, mode='w', encoding="utf-8") as f:
+        f.write(md)

requirements.txt

@@ -0,0 +1,13 @@
+huggingface_hub
+safetensors
+transformers
+accelerate
+git+https://github.com/huggingface/diffusers
+pytorch_lightning
+peft
+aria2
+gdown
+torch==2.2.0
+numpy
+GitPython
+PyYAML