New merged file with labels

CheckSafetensors.py

@@ -0,0 +1,10 @@
+from safetensors import safe_open
+
+with safe_open("flux1-depth-dev_fp4_merged_model.safetensors", framework="pt") as f:
+    keys = f.keys()
+    
+    has_vae = any('vae' in k or 'decoder' in k for k in keys)
+    has_clip = any('text_encoder' in k or 'clip' in k for k in keys)
+    has_unet = any('unet' in k or 'transformer' in k for k in keys)
+    
+    print(f"VAE: {has_vae}, CLIP: {has_clip}, UNet: {has_unet}")

InspectSafetensors.py

@@ -0,0 +1,220 @@
+from safetensors import safe_open
+from collections import defaultdict
+import os
+
+def inspect_checkpoint(checkpoint_path, detailed=False):
+    """
+    Inspect the structure of a safetensors checkpoint file.
+    
+    Args:
+        checkpoint_path: Path to the .safetensors file
+        detailed: If True, shows more detailed information
+    """
+    
+    if not os.path.exists(checkpoint_path):
+        print(f"❌ File not found: {checkpoint_path}")
+        return
+    
+    print("=" * 80)
+    print(f"INSPECTING: {os.path.basename(checkpoint_path)}")
+    print("=" * 80)
+    
+    # File size
+    size_bytes = os.path.getsize(checkpoint_path)
+    size_gb = size_bytes / (1024**3)
+    print(f"\n📦 File Size: {size_gb:.2f} GB ({size_bytes:,} bytes)")
+    
+    with safe_open(checkpoint_path, framework="pt") as f:
+        keys = list(f.keys())
+        
+        print(f"\n📊 Total Parameters: {len(keys):,}")
+        
+        # Categorize keys by component
+        print("\n" + "=" * 80)
+        print("COMPONENT BREAKDOWN")
+        print("=" * 80)
+        
+        categories = defaultdict(list)
+        
+        for key in keys:
+            # Categorize by prefix
+            if any(x in key.lower() for x in ['vae', 'first_stage', 'decoder', 'encoder', 'quant_conv', 'post_quant']):
+                categories['VAE'].append(key)
+            elif any(x in key.lower() for x in ['text_encoder', 'cond_stage', 'clip', 'transformer.text_model']):
+                categories['Text Encoder'].append(key)
+            elif any(x in key.lower() for x in ['model.diffusion', 'diffusion_model', 'transformer', 'double_blocks', 'single_blocks']):
+                categories['UNet/Transformer'].append(key)
+            else:
+                categories['Other'].append(key)
+        
+        # Print summary
+        for category, cat_keys in sorted(categories.items()):
+            print(f"\n{category}: {len(cat_keys)} parameters")
+        
+        # Analyze key patterns
+        print("\n" + "=" * 80)
+        print("KEY PATTERNS")
+        print("=" * 80)
+        
+        # Group by top-level prefix
+        prefix_groups = defaultdict(int)
+        for key in keys:
+            prefix = key.split('.')[0] if '.' in key else key
+            prefix_groups[prefix] += 1
+        
+        print("\nTop-level prefixes:")
+        for prefix, count in sorted(prefix_groups.items(), key=lambda x: -x[1]):
+            print(f"  {prefix}: {count} parameters")
+        
+        # Show sample keys from each category
+        print("\n" + "=" * 80)
+        print("SAMPLE KEYS FROM EACH COMPONENT")
+        print("=" * 80)
+        
+        for category, cat_keys in sorted(categories.items()):
+            if cat_keys:
+                print(f"\n{category} (showing first 5):")
+                for key in cat_keys[:5]:
+                    tensor = f.get_tensor(key)
+                    print(f"  {key}")
+                    print(f"    └─ shape: {tuple(tensor.shape)}, dtype: {tensor.dtype}")
+        
+        if detailed:
+            print("\n" + "=" * 80)
+            print("ALL KEYS (DETAILED)")
+            print("=" * 80)
+            
+            for i, key in enumerate(keys, 1):
+                tensor = f.get_tensor(key)
+                print(f"\n{i}. {key}")
+                print(f"   Shape: {tuple(tensor.shape)}")
+                print(f"   Dtype: {tensor.dtype}")
+                print(f"   Size: {tensor.numel():,} elements")
+        
+        # Check for common FLUX/SD patterns
+        print("\n" + "=" * 80)
+        print("MODEL TYPE DETECTION")
+        print("=" * 80)
+        
+        has_flux_blocks = any('double_blocks' in k or 'single_blocks' in k for k in keys)
+        has_sd_unet = any('model.diffusion_model' in k for k in keys)
+        has_vae = any('vae' in k.lower() or 'first_stage' in k for k in keys)
+        has_text_encoder = any('text_encoder' in k.lower() or 'cond_stage' in k for k in keys)
+        
+        print(f"\n✓ FLUX-style blocks: {'✅ YES' if has_flux_blocks else '❌ NO'}")
+        print(f"✓ SD-style UNet: {'✅ YES' if has_sd_unet else '❌ NO'}")
+        print(f"✓ VAE included: {'✅ YES' if has_vae else '❌ NO'}")
+        print(f"✓ Text Encoder included: {'✅ YES' if has_text_encoder else '❌ NO'}")
+        
+        if has_flux_blocks:
+            print("\n🔍 Likely model type: FLUX")
+        elif has_sd_unet:
+            print("\n🔍 Likely model type: Stable Diffusion")
+        else:
+            print("\n⚠️  Could not determine model type")
+        
+        # Check if complete checkpoint
+        print("\n" + "=" * 80)
+        print("CHECKPOINT COMPLETENESS")
+        print("=" * 80)
+        
+        if has_vae and has_text_encoder:
+            print("\n✅ This appears to be a COMPLETE checkpoint")
+            print("   (Contains UNet/Transformer + VAE + Text Encoder)")
+        else:
+            print("\n⚠️  This appears to be a PARTIAL checkpoint")
+            if not has_vae:
+                print("   Missing: VAE")
+            if not has_text_encoder:
+                print("   Missing: Text Encoder")
+    
+    print("\n" + "=" * 80)
+    print("INSPECTION COMPLETE")
+    print("=" * 80)
+
+
+def compare_checkpoints(working_checkpoint, broken_checkpoint):
+    """
+    Compare two checkpoints to see the differences.
+    
+    Args:
+        working_checkpoint: Path to checkpoint that works
+        broken_checkpoint: Path to checkpoint that doesn't work
+    """
+    
+    print("=" * 80)
+    print("COMPARING CHECKPOINTS")
+    print("=" * 80)
+    
+    with safe_open(working_checkpoint, framework="pt") as f1:
+        keys1 = set(f1.keys())
+    
+    with safe_open(broken_checkpoint, framework="pt") as f2:
+        keys2 = set(f2.keys())
+    
+    print(f"\nWorking checkpoint: {len(keys1)} keys")
+    print(f"Broken checkpoint: {len(keys2)} keys")
+    
+    only_in_working = keys1 - keys2
+    only_in_broken = keys2 - keys1
+    common = keys1 & keys2
+    
+    print(f"\nCommon keys: {len(common)}")
+    print(f"Only in working: {len(only_in_working)}")
+    print(f"Only in broken: {len(only_in_broken)}")
+    
+    if only_in_working:
+        print("\n🔍 Keys present in WORKING but missing in BROKEN (first 20):")
+        for key in sorted(only_in_working)[:20]:
+            print(f"  - {key}")
+    
+    if only_in_broken:
+        print("\n🔍 Keys present in BROKEN but missing in WORKING (first 20):")
+        for key in sorted(only_in_broken)[:20]:
+            print(f"  + {key}")
+    
+    # Compare key patterns
+    print("\n" + "=" * 80)
+    print("KEY PATTERN COMPARISON")
+    print("=" * 80)
+    
+    def get_prefixes(keys):
+        prefixes = defaultdict(int)
+        for key in keys:
+            prefix = key.split('.')[0]
+            prefixes[prefix] += 1
+        return prefixes
+    
+    prefixes1 = get_prefixes(keys1)
+    prefixes2 = get_prefixes(keys2)
+    
+    all_prefixes = set(prefixes1.keys()) | set(prefixes2.keys())
+    
+    print(f"\n{'Prefix':<30} {'Working':<15} {'Broken':<15}")
+    print("-" * 60)
+    for prefix in sorted(all_prefixes):
+        count1 = prefixes1.get(prefix, 0)
+        count2 = prefixes2.get(prefix, 0)
+        status = "✅" if count1 == count2 else "⚠️ "
+        print(f"{status} {prefix:<28} {count1:<15} {count2:<15}")
+
+
+# Example usage
+if __name__ == "__main__":
+    # Inspect a single checkpoint
+    print("OPTION 1: Inspect your working checkpoint")
+    print("-" * 80)
+    inspect_checkpoint(
+        "test/Juggernaut-XL_v9_RunDiffusionPhoto_v2.safetensors",
+        detailed=False  # Set to True for full key listing
+    )
+    
+    print("\n\n")
+    
+    # Compare two checkpoints
+    print("OPTION 2: Compare working vs broken checkpoint")
+    print("-" * 80)
+    # compare_checkpoints(
+    #     "path/to/working_checkpoint.safetensors",
+    #     "path/to/broken_checkpoint.safetensors"
+    # )

MergeSafetensors.py

@@ -67,8 +67,8 @@ def merge_model_components(
 # Example usage
 if __name__ == "__main__":
     merge_model_components(
-        unet_path="svdq-fp4_r32-flux.1-depth-dev.safetensors",
+        unet_path="flux1-depth-dev.safetensors",
         vae_path="vae/diffusion_pytorch_model.safetensors", 
         text_encoder_path="text_encoder/model.safetensors",
-        output_path="flux1-depth-dev_fp4_merged_model.safetensors"
+        output_path="flux1-depth-dev_merged_model.safetensors"
     )

MergeSafetensors2.py

@@ -0,0 +1,163 @@
+from safetensors.torch import save_file, load_file
+import torch
+import os
+
+def inspect_keys(file_path, max_keys=10):
+    """Helper function to inspect the structure of a safetensors file."""
+    state = load_file(file_path)
+    keys = list(state.keys())
+    print(f"\n{os.path.basename(file_path)} - Total keys: {len(keys)}")
+    print(f"First {max_keys} keys:")
+    for k in keys[:max_keys]:
+        print(f"  {k}")
+    return keys
+
+def merge_for_comfyui(
+    unet_path,
+    vae_path,
+    text_encoder_path,
+    output_path,
+    model_type="flux"  # "flux", "sd15", "sdxl"
+):
+    """
+    Merge components into ComfyUI-compatible safetensors checkpoint.
+    
+    Args:
+        unet_path: Path to the main model/transformer safetensors
+        vae_path: Path to the VAE safetensors
+        text_encoder_path: Path to the text encoder/CLIP safetensors
+        output_path: Path for the merged checkpoint
+        model_type: Type of model (flux, sd15, sdxl)
+    """
+    
+    print("=" * 60)
+    print("STEP 1: Inspecting input files...")
+    print("=" * 60)
+    
+    # Inspect each file to understand structure
+    unet_keys = inspect_keys(unet_path)
+    vae_keys = inspect_keys(vae_path)
+    text_encoder_keys = inspect_keys(text_encoder_path)
+    
+    print("\n" + "=" * 60)
+    print("STEP 2: Loading weights...")
+    print("=" * 60)
+    
+    unet_state = load_file(unet_path)
+    vae_state = load_file(vae_path)
+    text_encoder_state = load_file(text_encoder_path)
+    
+    print("\n" + "=" * 60)
+    print("STEP 3: Merging with proper key structure...")
+    print("=" * 60)
+    
+    merged_state = {}
+    
+    # Determine key prefixes based on existing structure
+    sample_unet_key = unet_keys[0]
+    sample_vae_key = vae_keys[0]
+    sample_te_key = text_encoder_keys[0]
+    
+    print(f"\nDetected key patterns:")
+    print(f"  UNet: {sample_unet_key}")
+    print(f"  VAE: {sample_vae_key}")
+    print(f"  Text Encoder: {sample_te_key}")
+    
+    # Add UNet/Transformer weights
+    for key, value in unet_state.items():
+        # Keep original keys or add model prefix if needed
+        if key.startswith('model.') or key.startswith('diffusion_model.'):
+            merged_state[key] = value
+        else:
+            # Add ComfyUI-expected prefix
+            merged_state[f'model.diffusion_model.{key}'] = value
+    
+    # Add VAE weights with proper structure
+    for key, value in vae_state.items():
+        if key.startswith('first_stage_model.') or key.startswith('vae.'):
+            merged_state[key] = value
+        elif key.startswith('decoder.') or key.startswith('encoder.'):
+            merged_state[f'first_stage_model.{key}'] = value
+        else:
+            merged_state[f'first_stage_model.decoder.{key}'] = value
+    
+    # Add text encoder weights
+    for key, value in text_encoder_state.items():
+        if key.startswith('cond_stage_model.') or key.startswith('text_encoder.'):
+            merged_state[key] = value
+        else:
+            # For FLUX, might need different structure
+            if model_type.lower() == "flux":
+                merged_state[f'text_encoders.{key}'] = value
+            else:
+                merged_state[f'cond_stage_model.transformer.{key}'] = value
+    
+    print(f"\nMerged state contains {len(merged_state)} parameters")
+    
+    # Add metadata for ComfyUI recognition
+    print("\n" + "=" * 60)
+    print("STEP 4: Saving merged checkpoint...")
+    print("=" * 60)
+    
+    save_file(merged_state, output_path)
+    
+    print("\n✅ Merge complete!")
+    print(f"File saved to: {output_path}")
+    
+    size_gb = os.path.getsize(output_path) / (1024**3)
+    print(f"File size: {size_gb:.2f} GB")
+    
+    # Verify the merged file
+    print("\n" + "=" * 60)
+    print("STEP 5: Verifying merged file...")
+    print("=" * 60)
+    inspect_keys(output_path, max_keys=20)
+
+
+def simple_merge_keep_structure(
+    unet_path,
+    vae_path, 
+    text_encoder_path,
+    output_path
+):
+    """
+    Simple merge that preserves original key structure.
+    Use this if the files already have proper ComfyUI keys.
+    """
+    print("Loading all components...")
+    
+    unet_state = load_file(unet_path)
+    vae_state = load_file(vae_path)
+    text_encoder_state = load_file(text_encoder_path)
+    
+    print("Merging...")
+    merged_state = {}
+    merged_state.update(unet_state)
+    merged_state.update(vae_state)
+    merged_state.update(text_encoder_state)
+    
+    print(f"Saving {len(merged_state)} parameters...")
+    save_file(merged_state, output_path)
+    
+    size_gb = os.path.getsize(output_path) / (1024**3)
+    print(f"✅ Done! File size: {size_gb:.2f} GB")
+
+
+# Example usage
+if __name__ == "__main__":
+    # Option 1: Smart merge with key detection
+    merge_for_comfyui(
+        unet_path="svdq-fp4_r32-flux.1-depth-dev.safetensors",
+        vae_path="vae/diffusion_pytorch_model.safetensors",
+        text_encoder_path="text_encoder/model.safetensors",
+        output_path="flux1-depth-dev_fp4_merged_model.safetensors",
+        model_type="flux"
+    )
+    
+    # Option 2: Simple merge (if keys are already correct)
+    # simple_merge_keep_structure(
+    #     unet_path="path/to/model.safetensors",
+    #     vae_path="path/to/vae.safetensors",
+    #     text_encoder_path="path/to/text_encoder.safetensors",
+    #     output_path="merged_checkpoint.safetensors"
+    # )

ae.safetensors

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

flux1-depth-dev_fp4_merged_model.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:44d0a7a1c2353131a545f3a62ceff6a5affa2b5cfcc28f334a075bb58df8819b
-size 7866673892
+oid sha256:a7eff742003708c77b291d7ca416bf695dc7c01a3a26250febac7c79ee6f390d
+size 7866741316