Upload 2 files

app.py

@@ -43,6 +43,8 @@ It saves you the trouble of typing them in.<br>
         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)
+        is_private = gr.Checkbox(label="Create private repo", value=True)
+        is_overwrite = gr.Checkbox(label="Overweite repo", value=True)
         run_button = gr.Button(value="Submit")
         repo_urls = gr.CheckboxGroup(visible=False, choices=[], value=None)
         output_md = gr.Markdown(label="Output")
@@ -51,7 +53,7 @@ It saves you the trouble of typing them in.<br>
     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,
+        inputs=[dl_url, hf_user, hf_repo, hf_token, civitai_key, is_private, is_overwrite, is_upload_sf,
                 data_type, model_type, is_dequat, repo_urls, is_fix_only, use_original],
         outputs=[repo_urls, output_md],
     )

convert_url_to_diffusers_flux_gr.py

@@ -179,14 +179,14 @@ def is_repo_exists(repo_id):
         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)):
+def create_diffusers_repo(new_repo_id, diffusers_folder, is_private, is_overwrite, 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)
+        api.create_repo(repo_id=new_repo_id, token=hf_token, private=is_private, exist_ok=is_overwrite)
         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)
@@ -420,11 +420,13 @@ with torch.no_grad():
 # 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
+# https://huggingface.co/docs/accelerate/usage_guides/big_modeling
 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
+        from huggingface_hub import save_torch_state_dict, save_torch_model
+        from accelerate import init_empty_weights
         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.")
@@ -438,13 +440,29 @@ with torch.no_grad():
                 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:
-                    progress(0.5, desc=f"Saving FLUX.1 {name} metadata to: {path}")
-                    save_torch_state_dict(state_dict=sd, save_directory=path,
-                                        filename_pattern=pattern, max_shard_size=size, metadata=metadata)
+                if False and path.endswith("/transformer"):
+                    from diffusers import FluxTransformer2DModel
+                    has_guidance = any("guidance" in k for k in sd)
+                    with init_empty_weights():
+                        model = FluxTransformer2DModel(guidance_embeds=has_guidance)
+                    model.to("cpu")
+                    model.load_state_dict(sd, strict=True)
+                    print(f"Saving FLUX.1 {name} to: {path} (FluxTransformer2DModel)")
+                    if metadata is not None:
+                        progress(0.5, desc=f"Saving FLUX.1 {name} metadata to: {path}")
+                        save_torch_model(model=model, save_directory=path,
+                                            filename_pattern=pattern, max_shard_size=size, metadata=metadata)
+                    else:
+                        save_torch_model(model=model, save_directory=path,
+                                        filename_pattern=pattern, max_shard_size=size)
                 else:
-                    save_torch_state_dict(state_dict=sd, save_directory=path,
+                    print(f"Saving FLUX.1 {name} to: {path}")
+                    if metadata is not None:
+                        progress(0.5, desc=f"Saving FLUX.1 {name} metadata to: {path}")
+                        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}")
@@ -699,16 +717,16 @@ with torch.no_grad(): # Much lower memory consumption, but higher disk load
                           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"
+        unet_sd_size = "9.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"
+        clip_sd_size = "9.5GB"
         vae_sd_path = savepath.removesuffix("/") + "/vae"
         vae_sd_pattern = "diffusion_pytorch_model{suffix}.safetensors"
-        vae_sd_size = "10GB"
+        vae_sd_size = "9.5GB"
         print_resource_usage() #
         metadata = {"format": "pt", **read_safetensors_metadata(loadpath)}
         clear_cache()
@@ -743,6 +761,9 @@ with torch.no_grad(): # Much lower memory consumption, but higher disk load
             print("Deleted downloaded file.")
         clear_cache()
         print_resource_usage() #
+        unet_sd = convert_flux_transformer_sd_to_diffusers(unet_sd)
+        clear_cache()
+        print_resource_usage() #
         to_safetensors_flux_module(unet_sd, unet_sd_path, unet_sd_pattern, unet_sd_size,
                                         quantization, "Transformer", metadata)
         clear_sd(unet_sd)
@@ -871,7 +892,7 @@ def convert_url_to_fixed_flux_safetensors(url, civitai_key="", is_upload_sf=Fals
     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="",
+def convert_url_to_diffusers_repo_flux(dl_url, hf_user, hf_repo, hf_token, civitai_key="", is_private=True, is_overwrite=False,
                                        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)):
@@ -902,12 +923,12 @@ def convert_url_to_diffusers_repo_flux(dl_url, hf_user, hf_repo, hf_token, civit
         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):
+    if not is_overwrite and 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)
+    #save_readme_md(new_path, dl_url)
+    repo_url = create_diffusers_repo(new_repo_id, new_path, is_private, is_overwrite)
     shutil.rmtree(new_path)
     if not repo_urls: repo_urls = []
     repo_urls.append(repo_url)