Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| import os | |
| import tempfile | |
| import shutil | |
| import re | |
| import json | |
| from pathlib import Path | |
| from huggingface_hub import HfApi, hf_hub_download, snapshot_download, list_repo_files | |
| from safetensors.torch import load_file, save_file | |
| import torch | |
| import torch.nn.functional as F | |
| import traceback | |
| import glob | |
| import time | |
| from concurrent.futures import ThreadPoolExecutor, as_completed | |
| try: | |
| from modelscope.hub.file_download import model_file_download as ms_file_download | |
| from modelscope.hub.api import HubApi as ModelScopeApi | |
| MODELScope_AVAILABLE = True | |
| except ImportError: | |
| MODELScope_AVAILABLE = False | |
| def load_model_files(model_paths, model_format="safetensors", progress_callback=None): | |
| """ | |
| Load model weights from one or more files, supporting sharded safetensors and other formats. | |
| """ | |
| state_dict = {} | |
| if model_format == "safetensors": | |
| # Handle sharded safetensors files | |
| for i, path in enumerate(model_paths): | |
| if progress_callback: | |
| progress_callback(f"Loading shard {i+1}/{len(model_paths)}: {os.path.basename(path)}") | |
| part_dict = load_file(path) | |
| state_dict.update(part_dict) | |
| elif model_format in ["pth", "pt"]: | |
| # PyTorch checkpoint files | |
| for i, path in enumerate(model_paths): | |
| if progress_callback: | |
| progress_callback(f"Loading checkpoint {i+1}/{len(model_paths)}: {os.path.basename(path)}") | |
| checkpoint = torch.load(path, map_location="cpu") | |
| if isinstance(checkpoint, dict): | |
| # Try to extract state dict from checkpoint | |
| if "state_dict" in checkpoint: | |
| state_dict.update(checkpoint["state_dict"]) | |
| elif "model_state_dict" in checkpoint: | |
| state_dict.update(checkpoint["model_state_dict"]) | |
| elif "model" in checkpoint and isinstance(checkpoint["model"], dict): | |
| state_dict.update(checkpoint["model"]) | |
| else: | |
| # Assume the checkpoint itself is the state dict | |
| state_dict.update(checkpoint) | |
| elif model_format == "ckpt": | |
| # Checkpoint files (similar to pth) | |
| for i, path in enumerate(model_paths): | |
| if progress_callback: | |
| progress_callback(f"Loading checkpoint {i+1}/{len(model_paths)}: {os.path.basename(path)}") | |
| checkpoint = torch.load(path, map_location="cpu") | |
| if isinstance(checkpoint, dict): | |
| if "state_dict" in checkpoint: | |
| state_dict.update(checkpoint["state_dict"]) | |
| elif "model_state_dict" in checkpoint: | |
| state_dict.update(checkpoint["model_state_dict"]) | |
| elif "model" in checkpoint and isinstance(checkpoint["model"], dict): | |
| state_dict.update(checkpoint["model"]) | |
| else: | |
| state_dict.update(checkpoint) | |
| return state_dict | |
| def read_model_metadata(model_paths, model_format="safetensors"): | |
| """Read metadata from model files.""" | |
| metadata = {} | |
| if model_format == "safetensors": | |
| # Read metadata from the first safetensors file | |
| if model_paths: | |
| with open(model_paths[0], 'rb') as f: | |
| header_size = int.from_bytes(f.read(8), 'little') | |
| header_json = f.read(header_size).decode('utf-8') | |
| header = json.loads(header_json) | |
| metadata = header.get('__metadata__', {}) | |
| elif model_format in ["pth", "pt", "ckpt"]: | |
| # Try to extract metadata from checkpoint files | |
| if model_paths: | |
| checkpoint = torch.load(model_paths[0], map_location="cpu") | |
| if isinstance(checkpoint, dict): | |
| # Look for common metadata keys | |
| for key in ["hyperparameters", "args", "config", "metadata"]: | |
| if key in checkpoint: | |
| metadata[key] = checkpoint[key] | |
| return metadata | |
| def extract_base_name_from_sharded_files(model_paths): | |
| """Extract a common base name from sharded files.""" | |
| if not model_paths: | |
| return "model" | |
| if len(model_paths) == 1: | |
| # Single file case | |
| base_name = os.path.splitext(os.path.basename(model_paths[0]))[0] | |
| # Remove common suffixes | |
| for suffix in ["-fp8", "-fp16", "-bf16", "-32", "-16"]: | |
| if base_name.endswith(suffix): | |
| base_name = base_name[:-len(suffix)] | |
| return base_name | |
| # Multiple files case - find common prefix | |
| base_names = [os.path.splitext(os.path.basename(p))[0] for p in model_paths] | |
| # Handle Hugging Face pattern: model-00001-of-00002.safetensors | |
| # Extract the part before the shard numbering | |
| if all("-of-" in name for name in base_names): | |
| # All files follow the "model-XXXXX-of-YYYYY" pattern | |
| common_parts = [] | |
| for name in base_names: | |
| # Split at the shard numbering | |
| parts = name.split("-") | |
| if len(parts) >= 3 and parts[-2].isdigit() and parts[-1].startswith("of"): | |
| # Remove the last two parts (shard number and total) | |
| common_part = "-".join(parts[:-2]) | |
| common_parts.append(common_part) | |
| else: | |
| common_parts.append(name) | |
| # Use the most common base name | |
| from collections import Counter | |
| base_name = Counter(common_parts).most_common(1)[0][0] | |
| return base_name | |
| # Fallback: find common prefix | |
| common_prefix = "" | |
| for chars in zip(*base_names): | |
| if len(set(chars)) == 1: | |
| common_prefix += chars[0] | |
| else: | |
| break | |
| # Clean up the common prefix | |
| base_name = re.sub(r'[-_]+$', '', common_prefix) | |
| if not base_name: | |
| base_name = "model" | |
| return base_name | |
| def convert_model_to_fp8(model_paths, output_dir, fp8_format, | |
| model_format="safetensors", progress=gr.Progress()): | |
| """Simple and fast FP8 conversion without recovery strategies.""" | |
| progress(0.05, desc=f"Starting FP8 conversion for {model_format}...") | |
| try: | |
| metadata = read_model_metadata(model_paths, model_format) | |
| progress(0.1, desc="Loaded metadata.") | |
| # Load model with progress tracking | |
| state_dict = load_model_files( | |
| model_paths, | |
| model_format, | |
| progress_callback=lambda msg: progress(0.15, desc=msg) | |
| ) | |
| progress(0.25, desc=f"Loaded {len(model_paths)} model files with {len(state_dict)} tensors.") | |
| # Setup FP8 format | |
| fp8_dtype = torch.float8_e5m2 if fp8_format == "e5m2" else torch.float8_e4m3fn | |
| # Initialize outputs | |
| sd_fp8 = {} | |
| conversion_stats = { | |
| "total_tensors": len(state_dict), | |
| "converted_tensors": 0, | |
| "skipped_tensors": 0, | |
| "skipped_reasons": [] | |
| } | |
| # Process each tensor | |
| total = len(state_dict) | |
| for i, key in enumerate(state_dict): | |
| if i % 100 == 0: # Update progress every 100 tensors for speed | |
| progress(0.3 + 0.6 * (i / total), desc=f"Converting {i}/{total} tensors...") | |
| weight = state_dict[key] | |
| # Convert only float tensors to FP8 | |
| if weight.dtype in [torch.float16, torch.float32, torch.bfloat16]: | |
| fp8_weight = weight.to(fp8_dtype) | |
| sd_fp8[key] = fp8_weight | |
| conversion_stats["converted_tensors"] += 1 | |
| else: | |
| # Keep non-float tensors as-is (e.g., ints, bools) | |
| sd_fp8[key] = weight | |
| conversion_stats["skipped_tensors"] += 1 | |
| conversion_stats["skipped_reasons"].append(f"{key}: {weight.dtype}") | |
| # Extract base name for output files | |
| base_name = extract_base_name_from_sharded_files(model_paths) | |
| # Save FP8 model | |
| fp8_path = os.path.join(output_dir, f"{base_name}-fp8-{fp8_format}.safetensors") | |
| save_file(sd_fp8, fp8_path, metadata={ | |
| "format": model_format, | |
| "fp8_format": fp8_format, | |
| "original_files": str(len(model_paths)), | |
| "conversion_stats": json.dumps(conversion_stats), | |
| **metadata | |
| }) | |
| progress(0.95, desc="Saved FP8 file.") | |
| # Generate stats message | |
| stats_msg = f"✅ FP8 ({fp8_format}) conversion complete!\n" | |
| stats_msg += f"- Total tensors: {conversion_stats['total_tensors']}\n" | |
| stats_msg += f"- Converted to FP8: {conversion_stats['converted_tensors']}\n" | |
| stats_msg += f"- Skipped (non-float): {conversion_stats['skipped_tensors']}\n" | |
| stats_msg += f"- Output file: {os.path.basename(fp8_path)}\n" | |
| if conversion_stats["skipped_tensors"] > 0: | |
| stats_msg += "\n⚠️ Some tensors were skipped (non-float types):\n" | |
| for i, reason in enumerate(conversion_stats["skipped_reasons"][:5]): # Show first 5 | |
| stats_msg += f" - {reason}\n" | |
| if len(conversion_stats["skipped_reasons"]) > 5: | |
| stats_msg += f" - ... and {len(conversion_stats['skipped_reasons']) - 5} more\n" | |
| progress(1.0, desc="✅ FP8 conversion complete!") | |
| return True, stats_msg, conversion_stats, fp8_path, None | |
| except Exception as e: | |
| traceback.print_exc() | |
| return False, str(e), None, None, None | |
| def parse_hf_url(url): | |
| url = url.strip().rstrip("/") | |
| if not url.startswith("https://huggingface.co/"): | |
| raise ValueError("URL must start with https://huggingface.co/") | |
| path = url.replace("https://huggingface.co/", "") | |
| parts = path.split("/") | |
| if len(parts) < 2: | |
| raise ValueError("Invalid repo format") | |
| repo_id = "/".join(parts[:2]) | |
| subfolder = "" | |
| if len(parts) > 3 and parts[2] == "tree": | |
| subfolder = "/".join(parts[4:]) if len(parts) > 4 else "" | |
| elif len(parts) > 2: | |
| subfolder = "/".join(parts[2:]) | |
| return repo_id, subfolder | |
| def download_single_file(args): | |
| """Helper function for parallel downloads.""" | |
| repo_id, filename, subfolder, cache_dir, token = args | |
| try: | |
| path = hf_hub_download( | |
| repo_id=repo_id, | |
| filename=filename, | |
| subfolder=subfolder, | |
| cache_dir=cache_dir, | |
| token=token, | |
| resume_download=True | |
| ) | |
| return path, None | |
| except Exception as e: | |
| return None, str(e) | |
| def find_sharded_safetensors_files(repo_id, subfolder=None, hf_token=None, max_shards=50): | |
| """Find all sharded safetensors files in a repository.""" | |
| try: | |
| # List all files in the repository | |
| repo_files = list_repo_files(repo_id, repo_type="model", token=hf_token) | |
| # Filter for safetensors files in the subfolder | |
| if subfolder: | |
| pattern = f"{subfolder}/" if not subfolder.endswith("/") else subfolder | |
| safetensors_files = [f for f in repo_files if f.endswith('.safetensors') and f.startswith(pattern)] | |
| # Remove subfolder prefix | |
| safetensors_files = [f[len(pattern):] for f in safetensors_files if len(f) > len(pattern)] | |
| else: | |
| safetensors_files = [f for f in repo_files if f.endswith('.safetensors')] | |
| # Check if files follow sharding pattern | |
| sharded_files = [] | |
| single_files = [] | |
| for f in safetensors_files: | |
| # Check for sharding pattern: model-XXXXX-of-YYYYY.safetensors | |
| match = re.search(r'-\d{5}-of-\d{5}\.safetensors$', f) | |
| if match: | |
| sharded_files.append(f) | |
| else: | |
| single_files.append(f) | |
| # If we have sharded files, return them sorted by shard number | |
| if sharded_files: | |
| # Sort by shard number for consistent ordering | |
| def extract_shard_num(filename): | |
| match = re.search(r'-(\d{5})-of-\d{5}\.safetensors$', filename) | |
| return int(match.group(1)) if match else 0 | |
| sharded_files.sort(key=extract_shard_num) | |
| # Limit number of shards to prevent accidental downloads of huge models | |
| if len(sharded_files) > max_shards: | |
| raise ValueError(f"Too many shards found ({len(sharded_files)}). Maximum allowed is {max_shards}. " | |
| f"Please specify a more specific pattern.") | |
| return sharded_files | |
| elif single_files: | |
| # Return single files (non-sharded) | |
| return single_files | |
| else: | |
| return [] | |
| except Exception as e: | |
| print(f"Error listing repository files: {e}") | |
| return [] | |
| def download_model_files(source_type, repo_url, filename_pattern, model_format, hf_token=None, progress=gr.Progress()): | |
| temp_dir = tempfile.mkdtemp() | |
| try: | |
| if source_type == "huggingface": | |
| repo_id, subfolder = parse_hf_url(repo_url) | |
| if model_format == "safetensors": | |
| # Handle different patterns for safetensors | |
| if filename_pattern == "auto" or filename_pattern == "": | |
| # Auto-detect sharded files | |
| progress(0.1, desc="Discovering model files...") | |
| found_files = find_sharded_safetensors_files(repo_id, subfolder, hf_token) | |
| if not found_files: | |
| raise ValueError("No safetensors files found in repository") | |
| progress(0.2, desc=f"Found {len(found_files)} shard(s). Downloading...") | |
| # Download files in parallel for better performance | |
| model_paths = [] | |
| download_args = [ | |
| (repo_id, filename, subfolder, temp_dir, hf_token) | |
| for filename in found_files | |
| ] | |
| with ThreadPoolExecutor(max_workers=4) as executor: | |
| futures = {executor.submit(download_single_file, args): args[1] for args in download_args} | |
| for i, future in enumerate(as_completed(futures)): | |
| filename = futures[future] | |
| try: | |
| path, error = future.result() | |
| if error: | |
| raise Exception(f"Failed to download {filename}: {error}") | |
| model_paths.append(path) | |
| progress(0.2 + 0.6 * (i + 1) / len(futures), | |
| desc=f"Downloaded {i+1}/{len(futures)}: {filename}") | |
| except Exception as e: | |
| raise e | |
| return model_paths, temp_dir | |
| elif "*" in filename_pattern: | |
| # For wildcard patterns, download the entire directory and filter | |
| progress(0.1, desc="Downloading repository snapshot...") | |
| local_dir = os.path.join(temp_dir, "download") | |
| snapshot_download( | |
| repo_id=repo_id, | |
| subfolder=subfolder or None, | |
| local_dir=local_dir, | |
| token=hf_token, | |
| resume_download=True | |
| ) | |
| # Find files matching the pattern | |
| if subfolder: | |
| pattern_dir = os.path.join(local_dir, subfolder) | |
| else: | |
| pattern_dir = local_dir | |
| model_files = glob.glob(os.path.join(pattern_dir, filename_pattern)) | |
| if not model_files: | |
| raise ValueError(f"No files found matching pattern: {filename_pattern}") | |
| # Limit number of files | |
| if len(model_files) > 50: | |
| raise ValueError(f"Too many files found ({len(model_files)}). Please use a more specific pattern.") | |
| return model_files, temp_dir | |
| else: | |
| # SINGLE FILE SAFETENSORS - separate from shard discovery | |
| progress(0.2, desc=f"Downloading {filename_pattern}...") | |
| model_path = hf_hub_download( | |
| repo_id=repo_id, | |
| filename=filename_pattern, | |
| subfolder=subfolder or None, | |
| cache_dir=temp_dir, | |
| token=hf_token, | |
| resume_download=True | |
| ) | |
| return [model_path], temp_dir | |
| else: | |
| # For non-safetensors formats | |
| if "*" in filename_pattern: | |
| raise ValueError("Wildcards only supported for safetensors format") | |
| progress(0.2, desc=f"Downloading {filename_pattern}...") | |
| model_path = hf_hub_download( | |
| repo_id=repo_id, | |
| filename=filename_pattern, | |
| subfolder=subfolder or None, | |
| cache_dir=temp_dir, | |
| token=hf_token, | |
| resume_download=True | |
| ) | |
| return [model_path], temp_dir | |
| elif source_type == "modelscope": | |
| if not MODELScope_AVAILABLE: | |
| raise ImportError("ModelScope not installed") | |
| repo_id = repo_url.strip() | |
| if model_format == "safetensors" and "*" in filename_pattern: | |
| # For ModelScope, we need to handle sharded files differently | |
| # This is a simplified approach - in a real implementation, you might need to list files first | |
| raise NotImplementedError("Pattern matching for ModelScope sharded files not fully implemented") | |
| else: | |
| progress(0.2, desc=f"Downloading {filename_pattern}...") | |
| model_path = ms_file_download(model_id=repo_id, file_path=filename_pattern) | |
| return [model_path], temp_dir | |
| else: | |
| raise ValueError("Unknown source") | |
| except Exception as e: | |
| shutil.rmtree(temp_dir, ignore_errors=True) | |
| raise e | |
| def upload_to_target(target_type, new_repo_id, output_dir, fp8_format, hf_token=None, modelscope_token=None, private_repo=False): | |
| if target_type == "huggingface": | |
| api = HfApi(token=hf_token) | |
| api.create_repo(repo_id=new_repo_id, private=private_repo, repo_type="model", exist_ok=True) | |
| api.upload_folder(repo_id=new_repo_id, folder_path=output_dir, repo_type="model", token=hf_token) | |
| return f"https://huggingface.co/{new_repo_id}" | |
| elif target_type == "modelscope": | |
| api = ModelScopeApi() | |
| if modelscope_token: | |
| api.login(modelscope_token) | |
| api.push_model(model_id=new_repo_id, model_dir=output_dir) | |
| return f"https://modelscope.cn/models/{new_repo_id}" | |
| else: | |
| raise ValueError("Unknown target") | |
| def process_and_upload_fp8( | |
| source_type, | |
| repo_url, | |
| filename_pattern, | |
| model_format, | |
| fp8_format, | |
| target_type, | |
| new_repo_id, | |
| hf_token, | |
| modelscope_token, | |
| private_repo, | |
| progress=gr.Progress() | |
| ): | |
| if not re.match(r"^[a-zA-Z0-9._-]+/[a-zA-Z0-9._-]+$", new_repo_id): | |
| return None, "❌ Invalid repo ID format. Use 'username/model-name'.", "", "" | |
| if source_type == "huggingface" and not hf_token: | |
| return None, "❌ Hugging Face token required for source.", "", "" | |
| if target_type == "huggingface" and not hf_token: | |
| return None, "❌ Hugging Face token required for target.", "", "" | |
| temp_dir = None | |
| output_dir = tempfile.mkdtemp() | |
| try: | |
| progress(0.05, desc="Downloading model...") | |
| model_paths, temp_dir = download_model_files( | |
| source_type, repo_url, filename_pattern, model_format, hf_token, progress | |
| ) | |
| progress(0.8, desc="Converting to FP8...") | |
| success, msg, stats, fp8_path, _ = convert_model_to_fp8( | |
| model_paths, output_dir, fp8_format, model_format, progress | |
| ) | |
| if not success: | |
| return None, f"❌ Conversion failed: {msg}", "", "" | |
| progress(0.9, desc="Uploading...") | |
| repo_url_final = upload_to_target( | |
| target_type, new_repo_id, output_dir, fp8_format, hf_token, modelscope_token, private_repo | |
| ) | |
| # Generate README | |
| if len(model_paths) == 1: | |
| original_filename = os.path.basename(model_paths[0]) | |
| else: | |
| original_filename = f"{len(model_paths)} sharded files" | |
| # Add the pattern if not auto | |
| if filename_pattern != "auto": | |
| original_filename += f" matching '{filename_pattern}'" | |
| fp8_filename = os.path.basename(fp8_path) | |
| readme = f"""--- | |
| library_name: diffusers | |
| tags: | |
| - fp8 | |
| - safetensors | |
| - converted-by-gradio | |
| --- | |
| # FP8 Model Conversion | |
| - **Source**: `{repo_url}` | |
| - **Original File(s)**: `{original_filename}` | |
| - **Original Format**: `{model_format}` | |
| - **FP8 Format**: `{fp8_format.upper()}` | |
| - **FP8 File**: `{fp8_filename}` | |
| ## Usage | |
| ```python | |
| from safetensors.torch import load_file | |
| import torch | |
| # Load FP8 model | |
| fp8_state = load_file("{fp8_filename}") | |
| # Convert tensors back to float32 for computation (auto-converted by PyTorch) | |
| model.load_state_dict(fp8_state) | |
| ``` | |
| > **Note**: FP8 tensors are automatically converted to float32 when loaded in PyTorch. | |
| > Requires PyTorch ≥ 2.1 for FP8 support. | |
| ## Statistics | |
| - **Total tensors**: {stats['total_tensors']} | |
| - **Converted to FP8**: {stats['converted_tensors']} | |
| - **Skipped (non-float)**: {stats['skipped_tensors']} | |
| """ | |
| with open(os.path.join(output_dir, "README.md"), "w") as f: | |
| f.write(readme) | |
| if target_type == "huggingface": | |
| HfApi(token=hf_token).upload_file( | |
| path_or_fileobj=os.path.join(output_dir, "README.md"), | |
| path_in_repo="README.md", | |
| repo_id=new_repo_id, | |
| repo_type="model", | |
| token=hf_token | |
| ) | |
| progress(1.0, desc="✅ Done!") | |
| # Generate result HTML | |
| result_html = f""" | |
| ✅ Success! | |
| Model uploaded to: <a href="{repo_url_final}" target="_blank">{new_repo_id}</a> | |
| - FP8 model: `{fp8_filename}` | |
| - Converted {stats['converted_tensors']} tensors to {fp8_format.upper()} | |
| """ | |
| return (gr.HTML(result_html), | |
| "✅ FP8 conversion successful!", | |
| msg, | |
| "") | |
| except Exception as e: | |
| traceback.print_exc() | |
| return None, f"❌ Error: {str(e)}", "", "" | |
| finally: | |
| if temp_dir: | |
| shutil.rmtree(temp_dir, ignore_errors=True) | |
| shutil.rmtree(output_dir, ignore_errors=True) | |
| with gr.Blocks(title="Fast FP8 Model Converter") as demo: | |
| gr.Markdown("# ⚡ Fast FP8 Model Converter") | |
| gr.Markdown("Convert model files (safetensors, pth, ckpt) → **FP8**. Supports sharded files with auto-discovery. Simple and fast!") | |
| with gr.Row(): | |
| with gr.Column(): | |
| source_type = gr.Radio(["huggingface", "modelscope"], value="huggingface", label="Source") | |
| repo_url = gr.Textbox(label="Repo URL or ID", placeholder="https://huggingface.co/... or modelscope-id") | |
| with gr.Row(): | |
| model_format = gr.Dropdown( | |
| choices=["safetensors", "pth", "pt", "ckpt"], | |
| value="safetensors", | |
| label="Model Format" | |
| ) | |
| filename_pattern = gr.Textbox( | |
| label="Filename or Pattern", | |
| placeholder="auto (detects sharded files) or model-*.safetensors", | |
| value="auto" | |
| ) | |
| with gr.Accordion("FP8 Settings", open=True): | |
| fp8_format = gr.Radio(["e4m3fn", "e5m2"], value="e5m2", label="FP8 Format") | |
| with gr.Accordion("Authentication", open=False): | |
| hf_token = gr.Textbox(label="Hugging Face Token", type="password") | |
| modelscope_token = gr.Textbox(label="ModelScope Token (optional)", type="password", visible=MODELScope_AVAILABLE) | |
| with gr.Column(): | |
| target_type = gr.Radio(["huggingface", "modelscope"], value="huggingface", label="Target") | |
| new_repo_id = gr.Textbox(label="New Repo ID", placeholder="user/model-fp8") | |
| private_repo = gr.Checkbox(label="Private Repository (HF only)", value=False) | |
| status_output = gr.Markdown() | |
| detailed_log = gr.Textbox(label="Processing Log", interactive=False, lines=10) | |
| recovery_summary = gr.Textbox(label="Additional Info", interactive=False, lines=3) | |
| convert_btn = gr.Button("🚀 Convert & Upload", variant="primary") | |
| repo_link_output = gr.HTML() | |
| convert_btn.click( | |
| fn=process_and_upload_fp8, | |
| inputs=[ | |
| source_type, | |
| repo_url, | |
| filename_pattern, | |
| model_format, | |
| fp8_format, | |
| target_type, | |
| new_repo_id, | |
| hf_token, | |
| modelscope_token, | |
| private_repo | |
| ], | |
| outputs=[repo_link_output, status_output, detailed_log, recovery_summary], | |
| show_progress=True | |
| ) | |
| gr.Examples( | |
| examples=[ | |
| [ | |
| "huggingface", | |
| "https://huggingface.co/stabilityai/sdxl-vae", | |
| "auto", | |
| "safetensors", | |
| "e4m3fn", | |
| "huggingface" | |
| ], | |
| [ | |
| "huggingface", | |
| "https://huggingface.co/runwayml/stable-diffusion-v1-5/tree/main/text_encoder", | |
| "auto", | |
| "safetensors", | |
| "e5m2", | |
| "huggingface" | |
| ], | |
| [ | |
| "huggingface", | |
| "https://huggingface.co/Yabo/FramePainter/tree/main", | |
| "auto", | |
| "safetensors", | |
| "e5m2", | |
| "huggingface" | |
| ], | |
| [ | |
| "huggingface", | |
| "https://huggingface.co/stabilityai/stable-diffusion-2-1", | |
| "model-*.safetensors", | |
| "safetensors", | |
| "e5m2", | |
| "huggingface" | |
| ], | |
| [ | |
| "huggingface", | |
| "https://huggingface.co/CompVis/stable-diffusion-v1-4", | |
| "sd-v1-4.ckpt", | |
| "ckpt", | |
| "e5m2", | |
| "huggingface" | |
| ] | |
| ], | |
| inputs=[source_type, repo_url, filename_pattern, model_format, fp8_format, target_type], | |
| label="Example Conversions", | |
| cache_examples=False | |
| ) | |
| gr.Markdown(""" | |
| ## 📁 Fast FP8 Conversion Tool | |
| This tool provides **fast and simple FP8 conversion** for various model formats: | |
| ### **Supported Formats:** | |
| - **Safetensors**: Modern, secure format. Supports sharded files (e.g., `model-00001-of-00005.safetensors`) | |
| - **PTH/PT**: PyTorch checkpoint files | |
| - **CKPT**: Checkpoint files (commonly used for stable diffusion models) | |
| ### **Shard Support:** | |
| - **Unlimited Shards**: Supports any number of sharded files (2, 5, 10, 20+) | |
| - **Auto-Detection**: Automatically finds all shards when using "auto" pattern | |
| - **Parallel Downloads**: Downloads multiple shards simultaneously (up to 4 at once) | |
| - **Memory Efficient**: Processes files efficiently to manage memory | |
| ### **Performance Features:** | |
| - **Fast Conversion**: Simple dtype conversion without complex recovery strategies | |
| - **Batch Processing**: Processes tensors in batches for better performance | |
| - **Progress Tracking**: Shows detailed progress for each step | |
| ### **How It Works:** | |
| 1. **Discovery**: Automatically detects sharded files or uses your specified pattern | |
| 2. **Download**: Downloads files in parallel for maximum speed | |
| 3. **Conversion**: Converts float tensors to FP8, leaves other types unchanged | |
| 4. **Upload**: Uploads the converted model to your target repository | |
| ### **Usage Tips:** | |
| - Use "auto" pattern to automatically detect all sharded safetensors files | |
| - Use `model-*.safetensors` to match specific shard patterns | |
| - For single files, just enter the filename (e.g., `model.safetensors`) | |
| - FP8 conversion reduces model size by ~4x compared to FP32 | |
| - FP8 tensors are automatically converted to float32 when loaded in PyTorch | |
| > **Note**: This is a simple conversion tool. For precision recovery options, use the advanced version. | |
| """) | |
| demo.launch() |