Next level fix

app.py

@@ -12,10 +12,191 @@ from pydantic import BaseModel
 from PIL import Image
 from starlette.staticfiles import StaticFiles
 import threading
+import json
 
 from inference import InferenceService
 from utils.data_fetch import ensure_dataset_ready
 
+# Global state
+BOOT_STATUS = "starting"
+DATASET_ROOT: Optional[str] = None
+
+def get_artifact_overview():
+    """Get comprehensive artifact overview."""
+    try:
+        from utils.artifact_manager import create_artifact_manager
+        manager = create_artifact_manager()
+        return manager.get_artifact_summary()
+    except Exception as e:
+        return {"error": str(e)}
+
+def export_artifact_summary():
+    """Export artifact summary as JSON file."""
+    try:
+        from utils.artifact_manager import create_artifact_manager
+        manager = create_artifact_manager()
+        summary = manager.get_artifact_summary()
+        
+        # Save to exports directory
+        export_dir = os.getenv("EXPORT_DIR", "models/exports")
+        os.makedirs(export_dir, exist_ok=True)
+        
+        summary_path = os.path.join(export_dir, "system_summary.json")
+        with open(summary_path, 'w') as f:
+            json.dump(summary, f, indent=2)
+        
+        return summary_path
+    except Exception as e:
+        return None
+
+def create_download_package(package_type: str):
+    """Create a downloadable package."""
+    try:
+        from utils.artifact_manager import create_artifact_manager
+        manager = create_artifact_manager()
+        
+        # Extract package type from the dropdown choice
+        if "complete" in package_type:
+            pkg_type = "complete"
+        elif "splits_only" in package_type:
+            pkg_type = "splits_only"
+        elif "models_only" in package_type:
+            pkg_type = "models_only"
+        else:
+            return f"❌ Invalid package type: {package_type}", get_available_packages()
+        
+        package_path = manager.create_download_package(pkg_type)
+        package_name = os.path.basename(package_path)
+        
+        return f"✅ Package created: {package_name}", get_available_packages()
+        
+    except Exception as e:
+        return f"❌ Failed to create package: {e}", get_available_packages()
+
+def get_available_packages():
+    """Get list of available packages."""
+    try:
+        export_dir = os.getenv("EXPORT_DIR", "models/exports")
+        packages = []
+        
+        if os.path.exists(export_dir):
+            for file in os.listdir(export_dir):
+                if file.endswith((".tar.gz", ".zip")):
+                    file_path = os.path.join(export_dir, file)
+                    packages.append({
+                        "name": file,
+                        "size_mb": round(os.path.getsize(file_path) / (1024 * 1024), 2),
+                        "path": file_path,
+                        "url": f"/files/{file}"
+                    })
+        
+        return {"packages": packages}
+    except Exception as e:
+        return {"error": str(e)}
+
+def get_individual_files():
+    """Get list of individual downloadable files."""
+    try:
+        from utils.artifact_manager import create_artifact_manager
+        manager = create_artifact_manager()
+        files = manager.get_downloadable_files()
+        
+        # Group by category
+        categorized = {}
+        for file in files:
+            category = file["category"]
+            if category not in categorized:
+                categorized[category] = []
+            categorized[category].append(file)
+        
+        return categorized
+    except Exception as e:
+        return {"error": str(e)}
+
+def download_all_files():
+    """Download all files as a ZIP archive."""
+    try:
+        from utils.artifact_manager import create_artifact_manager
+        manager = create_artifact_manager()
+        files = manager.get_downloadable_files()
+        
+        # Create ZIP with all files
+        export_dir = os.getenv("EXPORT_DIR", "models/exports")
+        os.makedirs(export_dir, exist_ok=True)
+        
+        zip_path = os.path.join(export_dir, "all_artifacts.zip")
+        import zipfile
+        
+        with zipfile.ZipFile(zip_path, 'w') as zipf:
+            for file in files:
+                if os.path.exists(file["path"]):
+                    zipf.write(file["path"], file["name"])
+        
+        return zip_path
+    except Exception as e:
+        return None
+
+def get_training_status():
+    """Get current training status from the monitor."""
+    try:
+        from training_monitor import create_monitor
+        monitor = create_monitor()
+        status = monitor.get_status()
+        return status if status else {"status": "no-training"}
+    except Exception as e:
+        return {"status": "error", "error": str(e)}
+
+def push_splits_to_hf(token, username):
+    """Push splits to HF Hub."""
+    if not token or not username:
+        return "❌ Please provide HF token and username"
+    
+    try:
+        from utils.hf_hub_integration import create_hf_integration
+        hf = create_hf_integration(token)
+        result = hf.upload_splits_to_hf()
+        
+        if result.get("success"):
+            return f"✅ Successfully uploaded splits to {username}/Dressify-Helper"
+        else:
+            return f"❌ Failed to upload splits: {result.get('error', 'Unknown error')}"
+    except Exception as e:
+        return f"❌ Upload failed: {e}"
+
+def push_models_to_hf(token, username):
+    """Push models to HF Hub."""
+    if not token or not username:
+        return "❌ Please provide HF token and username"
+    
+    try:
+        from utils.hf_hub_integration import create_hf_integration
+        hf = create_hf_integration(token)
+        result = hf.upload_models_to_hf()
+        
+        if result.get("success"):
+            return f"✅ Successfully uploaded models to {username}/dressify-models"
+        else:
+            return f"❌ Failed to upload models: {result.get('error', 'Unknown error')}"
+    except Exception as e:
+        return f"❌ Upload failed: {e}"
+
+def push_everything_to_hf(token, username):
+    """Push everything to HF Hub."""
+    if not token or not username:
+        return "❌ Please provide HF token and username"
+    
+    try:
+        from utils.hf_hub_integration import create_hf_integration
+        hf = create_hf_integration(token)
+        result = hf.upload_everything_to_hf()
+        
+        if result.get("success"):
+            return f"✅ Successfully uploaded everything to HF Hub"
+        else:
+            return f"❌ Failed to upload everything: {result.get('error', 'Unknown error')}"
+    except Exception as e:
+        return f"❌ Upload failed: {e}"
+
 
 AI_API_KEY = os.getenv("AI_API_KEY")
 
@@ -254,7 +435,9 @@ def start_training_advanced(
     if not DATASET_ROOT:
         return "❌ Dataset not ready. Please wait for bootstrap to complete."
     
+    log_message = "🚀 Advanced training started with custom parameters! Check the log below for progress."
     def _runner():
+        nonlocal log_message
         try:
             import subprocess
             import json
@@ -327,10 +510,10 @@ def start_training_advanced(
                 json.dump(vit_config, f, indent=2)
             
             # Train ResNet with custom parameters
-            train_log.value = f"🚀 Starting ResNet training with custom parameters...\n"
-            train_log.value += f"Backbone: {resnet_backbone}, Embedding Dim: {resnet_embedding_dim}\n"
-            train_log.value += f"Epochs: {resnet_epochs}, Batch Size: {resnet_batch_size}, LR: {resnet_lr}\n"
-            train_log.value += f"Optimizer: {resnet_optimizer}, Triplet Margin: {resnet_triplet_margin}\n"
+            log_message = f"🚀 Starting ResNet training with custom parameters...\n"
+            log_message += f"Backbone: {resnet_backbone}, Embedding Dim: {resnet_embedding_dim}\n"
+            log_message += f"Epochs: {resnet_epochs}, Batch Size: {resnet_batch_size}, LR: {resnet_lr}\n"
+            log_message += f"Optimizer: {resnet_optimizer}, Triplet Margin: {resnet_triplet_margin}\n"
             
             resnet_cmd = [
                 "python", "train_resnet.py",
@@ -350,16 +533,16 @@ def start_training_advanced(
             result = subprocess.run(resnet_cmd, capture_output=True, text=True, check=False)
             
             if result.returncode == 0:
-                train_log.value += "✅ ResNet training completed successfully!\n\n"
+                log_message += "✅ ResNet training completed successfully!\n\n"
             else:
-                train_log.value += f"❌ ResNet training failed: {result.stderr}\n\n"
+                log_message += f"❌ ResNet training failed: {result.stderr}\n\n"
                 return
             
             # Train ViT with custom parameters
-            train_log.value += f"🚀 Starting ViT training with custom parameters...\n"
-            train_log.value += f"Layers: {vit_num_layers}, Heads: {vit_num_heads}, FF Multiplier: {vit_ff_multiplier}\n"
-            train_log.value += f"Epochs: {vit_epochs}, Batch Size: {vit_batch_size}, LR: {vit_lr}\n"
-            train_log.value += f"Optimizer: {vit_optimizer}, Triplet Margin: {vit_triplet_margin}\n"
+            log_message += f"🚀 Starting ViT training with custom parameters...\n"
+            log_message += f"Layers: {vit_num_layers}, Heads: {vit_num_heads}, FF Multiplier: {vit_ff_multiplier}\n"
+            log_message += f"Epochs: {vit_epochs}, Batch Size: {vit_batch_size}, LR: {vit_lr}\n"
+            log_message += f"Optimizer: {vit_optimizer}, Triplet Margin: {vit_triplet_margin}\n"
             
             vit_cmd = [
                 "python", "train_vit_triplet.py",
@@ -376,47 +559,87 @@ def start_training_advanced(
             result = subprocess.run(vit_cmd, capture_output=True, text=True, check=False)
             
             if result.returncode == 0:
-                train_log.value += "✅ ViT training completed successfully!\n\n"
-                train_log.value += "🎉 All training completed! Models saved to models/exports/\n"
-                train_log.value += "🔄 Reloading models for inference...\n"
+                log_message += "✅ ViT training completed successfully!\n\n"
+                log_message += "🎉 All training completed! Models saved to models/exports/\n"
+                log_message += "🔄 Reloading models for inference...\n"
                 service.reload_models()
-                train_log.value += "✅ Models reloaded and ready for inference!\n"
+                log_message += "✅ Models reloaded and ready for inference!\n"
+                
+                # Auto-upload to HF Hub if token is available
+                hf_token = os.getenv("HF_TOKEN")
+                if hf_token:
+                    log_message += "📤 Auto-uploading artifacts to Hugging Face Hub...\n"
+                    try:
+                        from utils.hf_hub_integration import create_hf_integration
+                        hf = create_hf_integration(hf_token)
+                        result = hf.upload_everything_to_hf()
+                        if result.get("success"):
+                            log_message += "✅ Successfully uploaded to HF Hub!\n"
+                            log_message += "🔗 Models: https://huggingface.co/Stylique/dressify-models\n"
+                            log_message += "🔗 Data: https://huggingface.co/datasets/Stylique/Dressify-Helper\n"
+                        else:
+                            log_message += f"⚠️ Upload failed: {result.get('error', 'Unknown error')}\n"
+                    except Exception as e:
+                        log_message += f"⚠️ Auto-upload failed: {str(e)}\n"
+                else:
+                    log_message += "💡 Set HF_TOKEN env var for automatic uploads\n"
             else:
-                train_log.value += f"❌ ViT training failed: {result.stderr}\n"
+                log_message += f"❌ ViT training failed: {result.stderr}\n"
                 
         except Exception as e:
-            train_log.value += f"\n❌ Training error: {str(e)}"
+            log_message += f"\n❌ Training error: {str(e)}"
     
     threading.Thread(target=_runner, daemon=True).start()
-    return "🚀 Advanced training started with custom parameters! Check the log below for progress."
+    return log_message
 
 
 def start_training_simple(res_epochs: int, vit_epochs: int):
     """Start simple training with basic parameters."""
+    log_message = "Starting training..."
     def _runner():
+        nonlocal log_message
         try:
             import subprocess
             if not DATASET_ROOT:
-                train_log.value = "Dataset not ready."
+                log_message = "Dataset not ready."
                 return
             export_dir = os.getenv("EXPORT_DIR", "models/exports")
             os.makedirs(export_dir, exist_ok=True)
-            train_log.value = "Training ResNet…\n"
+            log_message = "Training ResNet…\n"
             subprocess.run([
                 "python", "train_resnet.py", "--data_root", DATASET_ROOT, "--epochs", str(res_epochs),
                 "--out", os.path.join(export_dir, "resnet_item_embedder.pth")
             ], check=False)
-            train_log.value += "\nTraining ViT (triplet)…\n"
+            log_message += "\nTraining ViT (triplet)…\n"
             subprocess.run([
                 "python", "train_vit_triplet.py", "--data_root", DATASET_ROOT, "--epochs", str(vit_epochs),
                 "--export", os.path.join(export_dir, "vit_outfit_model.pth")
             ], check=False)
             service.reload_models()
-            train_log.value += "\nDone. Artifacts in models/exports."
+            log_message += "\nDone. Artifacts in models/exports."
+            
+            # Auto-upload to HF Hub if token is available
+            hf_token = os.getenv("HF_TOKEN")
+            if hf_token:
+                log_message += "\n📤 Auto-uploading artifacts to Hugging Face Hub...\n"
+                try:
+                    from utils.hf_hub_integration import create_hf_integration
+                    hf = create_hf_integration(hf_token)
+                    result = hf.upload_everything_to_hf()
+                    if result.get("success"):
+                        log_message += "✅ Successfully uploaded to HF Hub!\n"
+                        log_message += "🔗 Models: https://huggingface.co/Stylique/dressify-models\n"
+                        log_message += "🔗 Data: https://huggingface.co/datasets/Stylique/Dressify-Helper\n"
+                    else:
+                        log_message += f"⚠️ Upload failed: {result.get('error', 'Unknown error')}\n"
+                except Exception as e:
+                    log_message += f"⚠️ Auto-upload failed: {str(e)}\n"
+            else:
+                log_message += "\n💡 Set HF_TOKEN env var for automatic uploads\n"
         except Exception as e:
-            train_log.value += f"\nError: {e}"
+            log_message += f"\nError: {e}"
     threading.Thread(target=_runner, daemon=True).start()
-    return "Started"
+    return log_message
 
 
 with gr.Blocks(fill_height=True, title="Dressify - Advanced Outfit Recommendation") as demo:
@@ -563,6 +786,56 @@ with gr.Blocks(fill_height=True, title="Dressify - Advanced Outfit Recommendatio
             outputs=train_log
         )
     
+    with gr.Tab("📦 Artifact Management"):
+        gr.Markdown("### 🎯 Comprehensive Artifact Management\nManage, package, and upload all system artifacts to Hugging Face Hub.")
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("#### 📊 Artifact Overview")
+                artifact_overview = gr.JSON(label="System Artifacts", value=get_artifact_overview)
+                refresh_overview = gr.Button("🔄 Refresh Overview")
+                refresh_overview.click(fn=get_artifact_overview, inputs=[], outputs=artifact_overview)
+                
+                gr.Markdown("#### 📦 Create Packages")
+                package_type = gr.Dropdown(
+                    choices=["complete", "splits_only", "models_only"],
+                    value="complete",
+                    label="Package Type"
+                )
+                create_package_btn = gr.Button("📦 Create Package")
+                package_result = gr.Textbox(label="Package Result", interactive=False)
+                available_packages = gr.JSON(label="Available Packages", value=get_available_packages)
+                
+                create_package_btn.click(
+                    fn=create_download_package,
+                    inputs=[package_type],
+                    outputs=[package_result, available_packages]
+                )
+            
+            with gr.Column(scale=1):
+                gr.Markdown("#### 🚀 Hugging Face Hub Integration")
+                gr.Markdown("💡 **Pro Tip**: Set `HF_TOKEN` environment variable for automatic uploads after training!")
+                hf_token = gr.Textbox(label="HF Token", type="password", placeholder="hf_...")
+                hf_username = gr.Textbox(label="Username", placeholder="your-username")
+                
+                with gr.Row():
+                    push_splits_btn = gr.Button("📤 Push Splits", variant="secondary")
+                    push_models_btn = gr.Button("📤 Push Models", variant="secondary")
+                
+                push_everything_btn = gr.Button("📤 Push Everything", variant="primary")
+                hf_result = gr.Textbox(label="Upload Result", interactive=False, lines=3)
+                
+                push_splits_btn.click(fn=push_splits_to_hf, inputs=[hf_token, hf_username], outputs=hf_result)
+                push_models_btn.click(fn=push_models_to_hf, inputs=[hf_token, hf_username], outputs=hf_result)
+                push_everything_btn.click(fn=push_everything_to_hf, inputs=[hf_token, hf_username], outputs=hf_result)
+                
+                gr.Markdown("#### 📥 Download Management")
+                individual_files = gr.JSON(label="Individual Files", value=get_individual_files)
+                download_all_btn = gr.Button("📥 Download All as ZIP")
+                download_result = gr.Textbox(label="Download Result", interactive=False)
+                
+                download_all_btn.click(fn=download_all_files, inputs=[], outputs=download_result)
+    
     with gr.Tab("🔧 Simple Training"):
         gr.Markdown("### 🚀 Quick Training with Default Parameters\nFast training with proven configurations for immediate results.")
         epochs_res = gr.Slider(1, 50, value=10, step=1, label="ResNet epochs")
@@ -577,23 +850,7 @@ with gr.Blocks(fill_height=True, title="Dressify - Advanced Outfit Recommendatio
         btn = gr.Button("Compute Embeddings")
         btn.click(fn=gradio_embed, inputs=inp, outputs=out)
     
-    with gr.Tab("📥 Downloads"):
-        gr.Markdown("### 📦 Download Trained Models and Artifacts\nAccess all exported models, checkpoints, and training metrics.")
-        file_list = gr.JSON(label="Available Artifacts")
-        def list_artifacts_for_ui():
-            export_dir = os.getenv("EXPORT_DIR", "models/exports")
-            files = []
-            if os.path.isdir(export_dir):
-                for fn in os.listdir(export_dir):
-                    if fn.endswith((".pth", ".pt", ".onnx", ".ts", ".json")):
-                        files.append({
-                            "name": fn,
-                            "path": f"{export_dir}/{fn}",
-                            "url": f"/files/{fn}",
-                        })
-            return {"artifacts": files}
-        refresh = gr.Button("🔄 Refresh Artifacts")
-        refresh.click(fn=lambda: list_artifacts_for_ui(), inputs=[], outputs=file_list)
+
     
     with gr.Tab("📈 Status"):
         gr.Markdown("### 🚦 System Status and Monitoring\nReal-time status of dataset preparation, training, and system health.")

artifact_management_ui.py

@@ -0,0 +1,427 @@
+#!/usr/bin/env python3
+"""
+Comprehensive Gradio interface for Dressify artifact management.
+Provides download, upload, and organization features for all system artifacts.
+"""
+
+import os
+import json
+import gradio as gr
+from typing import Dict, List, Any
+from utils.artifact_manager import create_artifact_manager
+
+def create_artifact_management_interface():
+    """Create the main artifact management interface."""
+    
+    with gr.Blocks(title="Dressify Artifact Management", theme=gr.themes.Soft()) as interface:
+        gr.Markdown("# 🎯 Dressify Artifact Management System")
+        gr.Markdown("## 📦 Download, Upload, and Organize All System Artifacts")
+        
+        with gr.Tabs():
+            
+            # Overview Tab
+            with gr.Tab("📊 System Overview"):
+                gr.Markdown("### 🚀 Complete System Status and Artifact Summary")
+                
+                with gr.Row():
+                    refresh_overview = gr.Button("🔄 Refresh Overview", variant="primary")
+                    export_summary = gr.Button("📥 Export Summary JSON", variant="secondary")
+                
+                overview_display = gr.JSON(label="System Overview", value=get_system_overview())
+                
+                refresh_overview.click(
+                    fn=get_system_overview,
+                    outputs=overview_display
+                )
+                
+                export_summary.click(
+                    fn=export_system_summary,
+                    outputs=gr.File(label="Download Summary")
+                )
+            
+            # Download Management Tab
+            with gr.Tab("📥 Download Management"):
+                gr.Markdown("### 🎁 Create Downloadable Packages")
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("#### 📦 Package Types")
+                        package_type = gr.Dropdown(
+                            choices=[
+                                "complete - Everything (splits + models + metadata + configs)",
+                                "splits_only - Dataset splits only (lightweight)",
+                                "models_only - Trained models only"
+                            ],
+                            value="splits_only - Dataset splits only (lightweight)",
+                            label="Package Type"
+                        )
+                        
+                        create_package_btn = gr.Button("🚀 Create Package", variant="primary")
+                        package_status = gr.Textbox(label="Package Status", interactive=False)
+                    
+                    with gr.Column(scale=1):
+                        gr.Markdown("#### 📋 Available Packages")
+                        packages_list = gr.JSON(label="Created Packages", value=get_available_packages())
+                        refresh_packages = gr.Button("🔄 Refresh Packages")
+                
+                create_package_btn.click(
+                    fn=create_download_package,
+                    inputs=[package_type],
+                    outputs=[package_status, packages_list]
+                )
+                
+                refresh_packages.click(
+                    fn=get_available_packages,
+                    outputs=packages_list
+                )
+            
+            # Individual Files Tab
+            with gr.Tab("📁 Individual Files"):
+                gr.Markdown("### 🔍 Browse and Download Individual Artifacts")
+                
+                with gr.Row():
+                    refresh_files = gr.Button("🔄 Refresh Files", variant="primary")
+                    download_all_btn = gr.Button("📥 Download All as ZIP", variant="secondary")
+                
+                files_display = gr.JSON(label="Available Files", value=get_individual_files())
+                
+                refresh_files.click(
+                    fn=get_individual_files,
+                    outputs=files_display
+                )
+                
+                download_all_btn.click(
+                    fn=download_all_files,
+                    outputs=gr.File(label="Download All Files")
+                )
+            
+            # Upload & Restore Tab
+            with gr.Tab("📤 Upload & Restore"):
+                gr.Markdown("### 🔄 Upload Pre-processed Artifacts")
+                gr.Markdown("Upload previously downloaded packages to avoid reprocessing.")
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("#### 📤 Upload Package")
+                        upload_package = gr.File(
+                            label="Upload Artifact Package (.tar.gz)",
+                            file_types=[".tar.gz", ".zip"]
+                        )
+                        upload_btn = gr.Button("📤 Upload & Extract", variant="primary")
+                        upload_status = gr.Textbox(label="Upload Status", interactive=False)
+                    
+                    with gr.Column(scale=1):
+                        gr.Markdown("#### 📋 Restore Options")
+                        restore_splits = gr.Button("🔄 Restore Splits Only", variant="secondary")
+                        restore_models = gr.Button("🔄 Restore Models Only", variant="secondary")
+                        restore_all = gr.Button("🔄 Restore Everything", variant="secondary")
+                
+                upload_btn.click(
+                    fn=upload_and_extract_package,
+                    inputs=[upload_package],
+                    outputs=upload_status
+                )
+                
+                restore_splits.click(
+                    fn=restore_splits_only,
+                    outputs=gr.Textbox(label="Restore Status")
+                )
+                
+                restore_models.click(
+                    fn=restore_models_only,
+                    outputs=gr.Textbox(label="Restore Status")
+                )
+                
+                restore_all.click(
+                    fn=restore_everything,
+                    outputs=gr.Textbox(label="Restore Status")
+                )
+            
+            # Hugging Face Integration Tab
+            with gr.Tab("🤗 HF Hub Integration"):
+                gr.Markdown("### 🚀 Push Artifacts to Hugging Face Hub")
+                gr.Markdown("Upload your artifacts to HF Hub for easy access and sharing.")
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("#### 🔑 Authentication")
+                        hf_token = gr.Textbox(
+                            label="Hugging Face Token",
+                            placeholder="hf_...",
+                            type="password"
+                        )
+                        hf_username = gr.Textbox(
+                            label="HF Username",
+                            placeholder="yourusername"
+                        )
+                    
+                    with gr.Column(scale=1):
+                        gr.Markdown("#### 📤 Push Options")
+                        push_splits = gr.Button("📤 Push Splits to HF", variant="primary")
+                        push_models = gr.Button("📤 Push Models to HF", variant="primary")
+                        push_all = gr.Button("📤 Push Everything to HF", variant="primary")
+                
+                push_status = gr.Textbox(label="Push Status", interactive=False)
+                
+                push_splits.click(
+                    fn=push_splits_to_hf,
+                    inputs=[hf_token, hf_username],
+                    outputs=push_status
+                )
+                
+                push_models.click(
+                    fn=push_models_to_hf,
+                    inputs=[hf_token, hf_username],
+                    outputs=push_status
+                )
+                
+                push_all.click(
+                    fn=push_everything_to_hf,
+                    inputs=[hf_token, hf_username],
+                    outputs=push_status
+                )
+            
+            # Runtime Fetching Tab
+            with gr.Tab("⚡ Runtime Fetching"):
+                gr.Markdown("### 🔄 Fetch Artifacts at Runtime")
+                gr.Markdown("Configure the system to fetch artifacts from HF Hub instead of reprocessing.")
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("#### 🔗 HF Hub Sources")
+                        splits_repo = gr.Textbox(
+                            label="Splits Repository",
+                            placeholder="yourusername/dressify-splits",
+                            value="Stylique/dressify-splits"
+                        )
+                        models_repo = gr.Textbox(
+                            label="Models Repository", 
+                            placeholder="yourusername/dressify-models",
+                            value="Stylique/dressify-models"
+                        )
+                        
+                        enable_runtime_fetch = gr.Checkbox(
+                            label="Enable Runtime Fetching",
+                            value=False
+                        )
+                    
+                    with gr.Column(scale=1):
+                        gr.Markdown("#### 🚀 Fetch Actions")
+                        fetch_splits = gr.Button("🔄 Fetch Splits", variant="primary")
+                        fetch_models = gr.Button("🔄 Fetch Models", variant="primary")
+                        fetch_all = gr.Button("🔄 Fetch Everything", variant="primary")
+                
+                fetch_status = gr.Textbox(label="Fetch Status", interactive=False)
+                
+                fetch_splits.click(
+                    fn=fetch_splits_from_hf,
+                    inputs=[splits_repo],
+                    outputs=fetch_status
+                )
+                
+                fetch_models.click(
+                    fn=fetch_models_from_hf,
+                    inputs=[models_repo],
+                    outputs=fetch_status
+                )
+                
+                fetch_all.click(
+                    fn=fetch_everything_from_hf,
+                    inputs=[splits_repo, models_repo],
+                    outputs=fetch_status
+                )
+        
+        # Footer
+        gr.Markdown("---")
+        gr.Markdown("### 💡 Usage Instructions")
+        gr.Markdown("""
+        1. **System Overview**: Check what artifacts are available and their sizes
+        2. **Download Management**: Create packaged downloads for easy sharing
+        3. **Individual Files**: Browse and download specific artifacts
+        4. **Upload & Restore**: Upload previously downloaded packages
+        5. **HF Hub Integration**: Push artifacts to Hugging Face for sharing
+        6. **Runtime Fetching**: Configure automatic fetching from HF Hub
+        """)
+        
+        gr.Markdown("### 🎯 Benefits")
+        gr.Markdown("""
+        - **Save Time**: No more reprocessing expensive splits
+        - **Save Resources**: Avoid re-downloading and re-extracting
+        - **Easy Sharing**: Download packages and share with others
+        - **HF Integration**: Push to Hub for community access
+        - **Runtime Fetching**: Automatic artifact retrieval
+        """)
+    
+    return interface
+
+# Helper functions for the interface
+def get_system_overview():
+    """Get comprehensive system overview."""
+    try:
+        manager = create_artifact_manager()
+        return manager.get_artifact_summary()
+    except Exception as e:
+        return {"error": str(e)}
+
+def export_system_summary():
+    """Export system summary as JSON file."""
+    try:
+        manager = create_artifact_manager()
+        summary = manager.get_artifact_summary()
+        
+        # Save to exports directory
+        export_dir = os.getenv("EXPORT_DIR", "models/exports")
+        os.makedirs(export_dir, exist_ok=True)
+        
+        summary_path = os.path.join(export_dir, "system_summary.json")
+        with open(summary_path, 'w') as f:
+            json.dump(summary, f, indent=2)
+        
+        return summary_path
+    except Exception as e:
+        return None
+
+def create_download_package(package_type: str):
+    """Create a downloadable package."""
+    try:
+        manager = create_artifact_manager()
+        
+        # Extract package type from the dropdown choice
+        if "complete" in package_type:
+            pkg_type = "complete"
+        elif "splits_only" in package_type:
+            pkg_type = "splits_only"
+        elif "models_only" in package_type:
+            pkg_type = "models_only"
+        else:
+            return f"❌ Invalid package type: {package_type}", get_available_packages()
+        
+        package_path = manager.create_download_package(pkg_type)
+        package_name = os.path.basename(package_path)
+        
+        return f"✅ Package created: {package_name}", get_available_packages()
+        
+    except Exception as e:
+        return f"❌ Failed to create package: {e}", get_available_packages()
+
+def get_available_packages():
+    """Get list of available packages."""
+    try:
+        export_dir = os.getenv("EXPORT_DIR", "models/exports")
+        packages = []
+        
+        if os.path.exists(export_dir):
+            for file in os.listdir(export_dir):
+                if file.endswith((".tar.gz", ".zip")):
+                    file_path = os.path.join(export_dir, file)
+                    packages.append({
+                        "name": file,
+                        "size_mb": round(os.path.getsize(file_path) / (1024 * 1024), 2),
+                        "path": file_path,
+                        "url": f"/files/{file}"
+                    })
+        
+        return {"packages": packages}
+    except Exception as e:
+        return {"error": str(e)}
+
+def get_individual_files():
+    """Get list of individual downloadable files."""
+    try:
+        manager = create_artifact_manager()
+        files = manager.get_downloadable_files()
+        
+        # Group by category
+        categorized = {}
+        for file in files:
+            category = file["category"]
+            if category not in categorized:
+                categorized[category] = []
+            categorized[category].append(file)
+        
+        return categorized
+    except Exception as e:
+        return {"error": str(e)}
+
+def download_all_files():
+    """Download all files as a ZIP archive."""
+    try:
+        manager = create_artifact_manager()
+        files = manager.get_downloadable_files()
+        
+        # Create ZIP with all files
+        export_dir = os.getenv("EXPORT_DIR", "models/exports")
+        os.makedirs(export_dir, exist_ok=True)
+        
+        zip_path = os.path.join(export_dir, "all_artifacts.zip")
+        import zipfile
+        
+        with zipfile.ZipFile(zip_path, 'w') as zipf:
+            for file in files:
+                if os.path.exists(file["path"]):
+                    zipf.write(file["path"], file["name"])
+        
+        return zip_path
+    except Exception as e:
+        return None
+
+# Placeholder functions for upload/restore features
+def upload_and_extract_package(upload_file):
+    """Upload and extract a package."""
+    if upload_file is None:
+        return "❌ No file uploaded"
+    
+    try:
+        # This would implement actual upload and extraction logic
+        return f"✅ Package uploaded: {upload_file.name}"
+    except Exception as e:
+        return f"❌ Upload failed: {e}"
+
+def restore_splits_only():
+    """Restore splits only."""
+    return "🔄 Splits restoration not yet implemented"
+
+def restore_models_only():
+    """Restore models only."""
+    return "🔄 Models restoration not yet implemented"
+
+def restore_everything():
+    """Restore everything."""
+    return "🔄 Full restoration not yet implemented"
+
+# Placeholder functions for HF Hub integration
+def push_splits_to_hf(token, username):
+    """Push splits to HF Hub."""
+    if not token or not username:
+        return "❌ Please provide HF token and username"
+    return f"📤 Pushing splits to {username}/dressify-splits..."
+
+def push_models_to_hf(token, username):
+    """Push models to HF Hub."""
+    if not token or not username:
+        return "❌ Please provide HF token and username"
+    return f"📤 Pushing models to {username}/dressify-models..."
+
+def push_everything_to_hf(token, username):
+    """Push everything to HF Hub."""
+    if not token or not username:
+        return "❌ Please provide HF token and username"
+    return f"📤 Pushing everything to {username}/dressify..."
+
+# Placeholder functions for runtime fetching
+def fetch_splits_from_hf(repo):
+    """Fetch splits from HF Hub."""
+    return f"🔄 Fetching splits from {repo}..."
+
+def fetch_models_from_hf(repo):
+    """Fetch models from HF Hub."""
+    return f"🔄 Fetching models from {repo}..."
+
+def fetch_everything_from_hf(splits_repo, models_repo):
+    """Fetch everything from HF Hub."""
+    return f"🔄 Fetching everything from {splits_repo} and {models_repo}..."
+
+if __name__ == "__main__":
+    # Test the interface
+    interface = create_artifact_management_interface()
+    interface.launch()

models/resnet_embedder.py

@@ -2,6 +2,7 @@ from typing import Optional
 
 import torch
 import torch.nn as nn
+import torch.nn.functional as F
 import torchvision.models as tvm
 
 
@@ -27,6 +28,8 @@ class ResNetItemEmbedder(nn.Module):
         feats = self.backbone(x)  # (B, C, 1, 1)
         feats = feats.flatten(1)  # (B, C)
         emb = self.proj(feats)    # (B, D)
+        # Apply L2 normalization as specified in requirements
+        emb = F.normalize(emb, p=2, dim=1)
         return emb
 
 

test_training.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+"""
+Simple test script to verify training components work.
+Run this to test if the system is ready for training.
+"""
+
+import os
+import sys
+import torch
+
+def test_imports():
+    """Test if all required modules can be imported."""
+    print("🔍 Testing imports...")
+    
+    try:
+        from models.resnet_embedder import ResNetItemEmbedder
+        print("✅ ResNet embedder imported successfully")
+    except Exception as e:
+        print(f"❌ Failed to import ResNet embedder: {e}")
+        return False
+    
+    try:
+        from models.vit_outfit import OutfitCompatibilityModel
+        print("✅ ViT outfit model imported successfully")
+    except Exception as e:
+        print(f"❌ Failed to import ViT outfit model: {e}")
+        return False
+    
+    try:
+        from data.polyvore import PolyvoreTripletDataset
+        print("✅ Polyvore dataset imported successfully")
+    except Exception as e:
+        print(f"❌ Failed to import Polyvore dataset: {e}")
+        return False
+    
+    try:
+        from utils.transforms import build_train_transforms
+        print("✅ Transforms imported successfully")
+    except Exception as e:
+        print(f"❌ Failed to import transforms: {e}")
+        return False
+    
+    return True
+
+def test_models():
+    """Test if models can be created and run forward pass."""
+    print("\n🏗️  Testing model creation...")
+    
+    try:
+        # Test ResNet embedder
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        print(f"Using device: {device}")
+        
+        resnet = ResNetItemEmbedder(embedding_dim=512).to(device)
+        print(f"✅ ResNet created with {sum(p.numel() for p in resnet.parameters()):,} parameters")
+        
+        # Test forward pass
+        dummy_input = torch.randn(2, 3, 224, 224).to(device)
+        with torch.no_grad():
+            output = resnet(dummy_input)
+        print(f"✅ ResNet forward pass: input {dummy_input.shape} -> output {output.shape}")
+        
+        # Test ViT outfit model
+        vit = OutfitCompatibilityModel(embedding_dim=512).to(device)
+        print(f"✅ ViT created with {sum(p.numel() for p in vit.parameters()):,} parameters")
+        
+        # Test forward pass
+        dummy_tokens = torch.randn(2, 4, 512).to(device)
+        with torch.no_grad():
+            output = vit(dummy_tokens)
+        print(f"✅ ViT forward pass: input {dummy_tokens.shape} -> output {output.shape}")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Model test failed: {e}")
+        return False
+
+def test_dataset():
+    """Test if dataset can be loaded (if available)."""
+    print("\n📊 Testing dataset loading...")
+    
+    data_root = os.getenv("POLYVORE_ROOT", "/home/user/app/data/Polyvore")
+    splits_dir = os.path.join(data_root, "splits")
+    train_file = os.path.join(splits_dir, "train.json")
+    
+    if not os.path.exists(train_file):
+        print(f"⚠️  Training data not found at {train_file}")
+        print("💡 Dataset preparation may be needed")
+        return True  # Not a failure, just not ready
+    
+    try:
+        dataset = PolyvoreTripletDataset(data_root, split="train")
+        print(f"✅ Dataset loaded successfully: {len(dataset)} samples")
+        
+        # Test getting one sample
+        if len(dataset) > 0:
+            sample = dataset[0]
+            print(f"✅ Sample loaded: {len(sample)} tensors with shapes {[s.shape for s in sample]}")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Dataset test failed: {e}")
+        return False
+
+def test_training_components():
+    """Test if training components can be created."""
+    print("\n🚀 Testing training components...")
+    
+    try:
+        from torch.utils.data import DataLoader
+        from torch.optim import AdamW
+        from torch.nn import TripletMarginLoss
+        
+        # Test optimizer creation
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        model = ResNetItemEmbedder(embedding_dim=512).to(device)
+        optimizer = AdamW(model.parameters(), lr=1e-3)
+        print("✅ Optimizer created successfully")
+        
+        # Test loss function
+        criterion = TripletMarginLoss(margin=0.2)
+        print("✅ Loss function created successfully")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Training components test failed: {e}")
+        return False
+
+def main():
+    """Run all tests."""
+    print("🧪 Starting Dressify Training System Tests\n")
+    
+    tests = [
+        ("Imports", test_imports),
+        ("Models", test_models),
+        ("Dataset", test_dataset),
+        ("Training Components", test_training_components),
+    ]
+    
+    results = []
+    for test_name, test_func in tests:
+        try:
+            result = test_func()
+            results.append((test_name, result))
+        except Exception as e:
+            print(f"�� {test_name} test crashed: {e}")
+            results.append((test_name, False))
+    
+    # Summary
+    print("\n" + "="*50)
+    print("📊 TEST RESULTS SUMMARY")
+    print("="*50)
+    
+    passed = 0
+    total = len(results)
+    
+    for test_name, result in results:
+        status = "✅ PASS" if result else "❌ FAIL"
+        print(f"{test_name:20} {status}")
+        if result:
+            passed += 1
+    
+    print("="*50)
+    print(f"Overall: {passed}/{total} tests passed")
+    
+    if passed == total:
+        print("🎉 All tests passed! System is ready for training.")
+        return True
+    else:
+        print("⚠️  Some tests failed. Please check the errors above.")
+        return False
+
+if __name__ == "__main__":
+    success = main()
+    sys.exit(0 if success else 1)

train_resnet.py

@@ -1,5 +1,6 @@
 import os
 import argparse
+import sys
 from typing import Tuple
 
 import torch
@@ -7,6 +8,9 @@ import torch.nn as nn
 import torch.optim as optim
 from torch.utils.data import DataLoader
 
+# Fix import paths
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
 from data.polyvore import PolyvoreTripletDataset
 from models.resnet_embedder import ResNetItemEmbedder
 from utils.export import ensure_export_dir
@@ -15,7 +19,7 @@ import json
 
 def parse_args() -> argparse.Namespace:
     p = argparse.ArgumentParser()
-    p.add_argument("--data_root", type=str, default=os.getenv("POLYVORE_ROOT", "/kaggle/input/polyvore-outfits"))
+    p.add_argument("--data_root", type=str, default=os.getenv("POLYVORE_ROOT", "/home/user/app/data/Polyvore"))
     p.add_argument("--epochs", type=int, default=20)
     p.add_argument("--batch_size", type=int, default=64)
     p.add_argument("--lr", type=float, default=1e-3)
@@ -30,80 +34,119 @@ def main() -> None:
     if device == "cuda":
         torch.backends.cudnn.benchmark = True
 
+    print(f"🚀 Starting ResNet training on {device}")
+    print(f"📁 Data root: {args.data_root}")
+    print(f"⚙️  Config: {args.epochs} epochs, batch_size={args.batch_size}, lr={args.lr}")
+
     # Ensure splits exist; if missing, prepare from official splits
     splits_dir = os.path.join(args.data_root, "splits")
     triplet_path = os.path.join(splits_dir, "train.json")
+    
     if not os.path.exists(triplet_path):
+        print(f"⚠️  Triplet file not found: {triplet_path}")
+        print("🔧 Attempting to prepare dataset...")
         os.makedirs(splits_dir, exist_ok=True)
         try:
-            from scripts.prepare_polyvore import main as prepare_main
-            import sys
-            argv_bak = sys.argv
-            try:
-                # First try using official splits (no random)
-                sys.argv = ["prepare_polyvore.py", "--root", args.data_root]
-                prepare_main()
-            finally:
-                sys.argv = argv_bak
-        except Exception:
-            # As a fallback, try random split on any available aggregate file
-            try:
-                from scripts.prepare_polyvore import main as prepare_main
-                import sys
-                argv_bak = sys.argv
-                try:
-                    sys.argv = ["prepare_polyvore.py", "--root", args.data_root, "--random_split"]
-                    prepare_main()
-                finally:
-                    sys.argv = argv_bak
-            except Exception:
-                pass
-
-    dataset = PolyvoreTripletDataset(args.data_root, split="train")
-
-    loader = DataLoader(dataset, batch_size=args.batch_size, shuffle=True, num_workers=4, pin_memory=(device=="cuda"))
+            # Try to import and run the prepare script
+            sys.path.append(os.path.join(os.path.dirname(__file__), "scripts"))
+            from prepare_polyvore import main as prepare_main
+            print("✅ Successfully imported prepare_polyvore")
+            
+            # Prepare dataset without random splits
+            prepare_main()
+            print("✅ Dataset preparation completed")
+        except Exception as e:
+            print(f"❌ Failed to prepare dataset: {e}")
+            print("💡 Please ensure the dataset is prepared manually")
+            return
+    else:
+        print(f"✅ Found existing splits: {triplet_path}")
+
+    try:
+        dataset = PolyvoreTripletDataset(args.data_root, split="train")
+        print(f"📊 Dataset loaded: {len(dataset)} samples")
+    except Exception as e:
+        print(f"❌ Failed to load dataset: {e}")
+        return
+
+    loader = DataLoader(dataset, batch_size=args.batch_size, shuffle=True, num_workers=2, pin_memory=(device=="cuda"))
     model = ResNetItemEmbedder(embedding_dim=args.embedding_dim).to(device)
     optimizer = optim.AdamW(model.parameters(), lr=args.lr, weight_decay=1e-4)
     criterion = nn.TripletMarginLoss(margin=0.2, p=2)
 
+    print(f"🏗️  Model created: {model.__class__.__name__}")
+    print(f"📈 Total parameters: {sum(p.numel() for p in model.parameters()):,}")
+
     export_dir = ensure_export_dir(os.path.dirname(args.out) or "models/exports")
     best_loss = float("inf")
     history = []
+    
+    print(f"💾 Checkpoints will be saved to: {export_dir}")
+    
     for epoch in range(args.epochs):
         model.train()
-        running = 0.0
+        running_loss = 0.0
         steps = 0
-        for batch in loader:
-            # Expect batch as (anchor, positive, negative)
-            anchor, positive, negative = batch
-            anchor = anchor.to(device, memory_format=torch.channels_last, non_blocking=True)
-            positive = positive.to(device, memory_format=torch.channels_last, non_blocking=True)
-            negative = negative.to(device, memory_format=torch.channels_last, non_blocking=True)
-            with torch.autocast(device_type=("cuda" if device=="cuda" else "cpu"), enabled=(device=="cuda")):
-                emb_a = model(anchor)
-                emb_p = model(positive)
-                emb_n = model(negative)
-            loss = criterion(emb_a, emb_p, emb_n)
-            optimizer.zero_grad(set_to_none=True)
-            loss.backward()
-            optimizer.step()
-            running += loss.item()
-            steps += 1
-        avg_loss = running / max(1, steps)
+        
+        print(f"🔄 Epoch {epoch+1}/{args.epochs}")
+        
+        for batch_idx, batch in enumerate(loader):
+            try:
+                # Expect batch as (anchor, positive, negative)
+                anchor, positive, negative = batch
+                anchor = anchor.to(device, memory_format=torch.channels_last, non_blocking=True)
+                positive = positive.to(device, memory_format=torch.channels_last, non_blocking=True)
+                negative = negative.to(device, memory_format=torch.channels_last, non_blocking=True)
+                
+                with torch.autocast(device_type=("cuda" if device=="cuda" else "cpu"), enabled=(device=="cuda")):
+                    emb_a = model(anchor)
+                    emb_p = model(positive)
+                    emb_n = model(negative)
+                
+                loss = criterion(emb_a, emb_p, emb_n)
+                optimizer.zero_grad(set_to_none=True)
+                loss.backward()
+                optimizer.step()
+                
+                running_loss += loss.item()
+                steps += 1
+                
+                if batch_idx % 100 == 0:
+                    print(f"  Batch {batch_idx}/{len(loader)}: loss={loss.item():.4f}")
+                    
+            except Exception as e:
+                print(f"❌ Error in batch {batch_idx}: {e}")
+                continue
+        
+        avg_loss = running_loss / max(1, steps)
+        
+        # Save checkpoint with better path handling
         out_path = args.out
         if not out_path.startswith("models/"):
             out_path = os.path.join(export_dir, os.path.basename(args.out))
-        torch.save({"state_dict": model.state_dict()}, out_path)
-        print(f"Epoch {epoch+1}/{args.epochs} avg_triplet_loss={avg_loss:.4f} saved -> {out_path}")
+        
+        # Ensure the output directory exists
+        os.makedirs(os.path.dirname(out_path), exist_ok=True)
+        
+        # Save checkpoint
+        torch.save({"state_dict": model.state_dict(), "epoch": epoch+1, "loss": avg_loss}, out_path)
+        print(f"✅ Epoch {epoch+1}/{args.epochs} avg_triplet_loss={avg_loss:.4f} saved -> {out_path}")
+        
         history.append({"epoch": epoch + 1, "avg_triplet_loss": avg_loss})
+        
         if avg_loss < best_loss:
             best_loss = avg_loss
-            torch.save({"state_dict": model.state_dict()}, os.path.join(export_dir, "resnet_item_embedder_best.pth"))
+            best_path = os.path.join(export_dir, "resnet_item_embedder_best.pth")
+            torch.save({"state_dict": model.state_dict(), "epoch": epoch+1, "loss": avg_loss}, best_path)
+            print(f"🏆 New best model saved: {best_path}")
 
-    # write metrics
+    # Write metrics
     metrics_path = os.path.join(export_dir, "resnet_metrics.json")
     with open(metrics_path, "w") as f:
         json.dump({"best_triplet_loss": best_loss, "history": history}, f)
+    
+    print(f"📊 Training completed! Best loss: {best_loss:.4f}")
+    print(f"📈 Metrics saved to: {metrics_path}")
 
 
 if __name__ == "__main__":

train_vit_triplet.py

@@ -1,5 +1,6 @@
 import os
 import argparse
+import sys
 from typing import List
 
 import torch
@@ -7,6 +8,9 @@ import torch.nn as nn
 import torch.optim as optim
 from torch.utils.data import DataLoader
 
+# Fix import paths
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
 from data.polyvore import PolyvoreOutfitTripletDataset
 from models.vit_outfit import OutfitCompatibilityModel
 from models.resnet_embedder import ResNetItemEmbedder
@@ -16,7 +20,7 @@ import json
 
 def parse_args() -> argparse.Namespace:
     p = argparse.ArgumentParser()
-    p.add_argument("--data_root", type=str, default=os.getenv("POLYVORE_ROOT", "/kaggle/input/polyvore-outfits"))
+    p.add_argument("--data_root", type=str, default=os.getenv("POLYVORE_ROOT", "/home/user/app/data/Polyvore"))
     p.add_argument("--epochs", type=int, default=30)
     p.add_argument("--batch_size", type=int, default=32)
     p.add_argument("--lr", type=float, default=5e-4)
@@ -45,128 +49,182 @@ def main() -> None:
     if device == "cuda":
         torch.backends.cudnn.benchmark = True
 
+    print(f"🚀 Starting ViT Outfit training on {device}")
+    print(f"📁 Data root: {args.data_root}")
+    print(f"⚙️  Config: {args.epochs} epochs, batch_size={args.batch_size}, lr={args.lr}")
+
     # Ensure outfit triplets exist
     splits_dir = os.path.join(args.data_root, "splits")
     trip_path = os.path.join(splits_dir, "outfit_triplets_train.json")
+    
     if not os.path.exists(trip_path):
+        print(f"⚠️  Outfit triplet file not found: {trip_path}")
+        print("🔧 Attempting to prepare dataset...")
         os.makedirs(splits_dir, exist_ok=True)
         try:
-            from scripts.prepare_polyvore import main as prepare_main
-            import sys
-            argv_bak = sys.argv
-            try:
-                sys.argv = ["prepare_polyvore.py", "--root", args.data_root]
-                prepare_main()
-            finally:
-                sys.argv = argv_bak
-        except Exception:
-            try:
-                from scripts.prepare_polyvore import main as prepare_main
-                import sys
-                argv_bak = sys.argv
-                try:
-                    sys.argv = ["prepare_polyvore.py", "--root", args.data_root, "--random_split"]
-                    prepare_main()
-                finally:
-                    sys.argv = argv_bak
-            except Exception:
-                pass
-
-    dataset = PolyvoreOutfitTripletDataset(args.data_root, split="train")
+            # Try to import and run the prepare script
+            sys.path.append(os.path.join(os.path.dirname(__file__), "scripts"))
+            from prepare_polyvore import main as prepare_main
+            print("✅ Successfully imported prepare_polyvore")
+            
+            # Prepare dataset without random splits
+            prepare_main()
+            print("✅ Dataset preparation completed")
+        except Exception as e:
+            print(f"❌ Failed to prepare dataset: {e}")
+            print("💡 Please ensure the dataset is prepared manually")
+            return
+    else:
+        print(f"✅ Found existing outfit triplets: {trip_path}")
+
+    try:
+        dataset = PolyvoreOutfitTripletDataset(args.data_root, split="train")
+        print(f"📊 Dataset loaded: {len(dataset)} samples")
+    except Exception as e:
+        print(f"❌ Failed to load dataset: {e}")
+        return
 
     def collate(batch):
         return batch  # variable length handled inside training loop
 
-    loader = DataLoader(dataset, batch_size=args.batch_size, shuffle=True, num_workers=4, pin_memory=(device=="cuda"), collate_fn=collate)
+    loader = DataLoader(dataset, batch_size=args.batch_size, shuffle=True, num_workers=2, pin_memory=(device=="cuda"), collate_fn=collate)
 
     model = OutfitCompatibilityModel(embedding_dim=args.embedding_dim).to(device)
     embedder = ResNetItemEmbedder(embedding_dim=args.embedding_dim).to(device).eval()
     for p in embedder.parameters():
         p.requires_grad_(False)
 
+    print(f"🏗️  Models created:")
+    print(f"  - ViT Outfit: {model.__class__.__name__}")
+    print(f"  - ResNet Embedder: {embedder.__class__.__name__}")
+    print(f"📈 Total parameters: {sum(p.numel() for p in model.parameters()):,}")
+
     optimizer = optim.AdamW(model.parameters(), lr=args.lr, weight_decay=5e-2)
     triplet = nn.TripletMarginWithDistanceLoss(distance_function=lambda x, y: 1 - nn.functional.cosine_similarity(x, y), margin=args.triplet_margin)
 
     export_dir = ensure_export_dir(os.path.dirname(args.export) or "models/exports")
     best_loss = float("inf")
     hist = []
+    
+    print(f"💾 Checkpoints will be saved to: {export_dir}")
+    
     for epoch in range(args.epochs):
         model.train()
-        for batch in loader:
-            # batch: List[(ga_imgs, gb_imgs, bd_imgs)]
-            anchor_tokens = []
-            positive_tokens = []
-            negative_tokens = []
-            for ga, gb, bd in batch:
-                ta = embed_outfit(ga, embedder, device)
-                tb = embed_outfit(gb, embedder, device)
-                tn = embed_outfit(bd, embedder, device)
-                anchor_tokens.append(ta.unsqueeze(0))
-                positive_tokens.append(tb.unsqueeze(0))
-                negative_tokens.append(tn.unsqueeze(0))
-            A = torch.cat(anchor_tokens, dim=0)  # (B, N, D)
-            P = torch.cat(positive_tokens, dim=0)
-            N = torch.cat(negative_tokens, dim=0)
-
-            # get outfit-level embeddings via ViT encoder pooled output
-            with torch.autocast(device_type=("cuda" if device=="cuda" else "cpu"), enabled=(device=="cuda")):
-                ea = model.encoder(A).mean(dim=1)
-                ep = model.encoder(P).mean(dim=1)
-                en = model.encoder(N).mean(dim=1)
-                loss = triplet(ea, ep, en)
-            optimizer.zero_grad(set_to_none=True)
-            loss.backward()
-            optimizer.step()
-
+        running_loss = 0.0
+        steps = 0
+        
+        print(f"🔄 Epoch {epoch+1}/{args.epochs}")
+        
+        for batch_idx, batch in enumerate(loader):
+            try:
+                # batch: List[(ga_imgs, gb_imgs, bd_imgs)]
+                anchor_tokens = []
+                positive_tokens = []
+                negative_tokens = []
+                
+                for ga, gb, bd in batch:
+                    ta = embed_outfit(ga, embedder, device)
+                    tb = embed_outfit(gb, embedder, device)
+                    tn = embed_outfit(bd, embedder, device)
+                    anchor_tokens.append(ta.unsqueeze(0))
+                    positive_tokens.append(tb.unsqueeze(0))
+                    negative_tokens.append(tn.unsqueeze(0))
+                
+                A = torch.cat(anchor_tokens, dim=0)  # (B, N, D)
+                P = torch.cat(positive_tokens, dim=0)
+                N = torch.cat(negative_tokens, dim=0)
+
+                # get outfit-level embeddings via ViT encoder pooled output
+                with torch.autocast(device_type=("cuda" if device=="cuda" else "cpu"), enabled=(device=="cuda")):
+                    ea = model.encoder(A).mean(dim=1)
+                    ep = model.encoder(P).mean(dim=1)
+                    en = model.encoder(N).mean(dim=1)
+                    loss = triplet(ea, ep, en)
+                
+                optimizer.zero_grad(set_to_none=True)
+                loss.backward()
+                optimizer.step()
+                
+                running_loss += loss.item()
+                steps += 1
+                
+                if batch_idx % 50 == 0:
+                    print(f"  Batch {batch_idx}/{len(loader)}: loss={loss.item():.4f}")
+                    
+            except Exception as e:
+                print(f"❌ Error in batch {batch_idx}: {e}")
+                continue
+
+        avg_loss = running_loss / max(1, steps)
+        
         # Simple validation using a subset of training data as a proxy if no val split here
         # For true 70/10/10, prepare_polyvore.py will create outfit_triplets_valid.json
         val_path = os.path.join(args.data_root, "splits", "outfit_triplets_valid.json")
         val_loss = None
+        
         if os.path.exists(val_path) and (epoch + 1) % args.eval_every == 0:
-            val_ds = PolyvoreOutfitTripletDataset(args.data_root, split="valid")
-            val_loader = DataLoader(val_ds, batch_size=args.batch_size, shuffle=False, num_workers=2, collate_fn=lambda x: x)
-            model.eval()
-            losses = []
-            with torch.no_grad():
-                for vbatch in val_loader:
-                    anchor_tokens = []
-                    positive_tokens = []
-                    negative_tokens = []
-                    for ga, gb, bd in vbatch:
-                        ta = embed_outfit(ga, embedder, device)
-                        tb = embed_outfit(gb, embedder, device)
-                        tn = embed_outfit(bd, embedder, device)
-                        anchor_tokens.append(ta.unsqueeze(0))
-                        positive_tokens.append(tb.unsqueeze(0))
-                        negative_tokens.append(tn.unsqueeze(0))
-                    A = torch.cat(anchor_tokens, dim=0)
-                    P = torch.cat(positive_tokens, dim=0)
-                    N = torch.cat(negative_tokens, dim=0)
-                    ea = model.encoder(A).mean(dim=1)
-                    ep = model.encoder(P).mean(dim=1)
-                    en = model.encoder(N).mean(dim=1)
-                    l = triplet(ea, ep, en).item()
-                    losses.append(l)
-            val_loss = sum(losses) / max(1, len(losses))
+            try:
+                val_ds = PolyvoreOutfitTripletDataset(args.data_root, split="valid")
+                val_loader = DataLoader(val_ds, batch_size=args.batch_size, shuffle=False, num_workers=2, collate_fn=lambda x: x)
+                model.eval()
+                losses = []
+                
+                with torch.no_grad():
+                    for vbatch in val_loader:
+                        anchor_tokens = []
+                        positive_tokens = []
+                        negative_tokens = []
+                        for ga, gb, bd in vbatch:
+                            ta = embed_outfit(ga, embedder, device)
+                            tb = embed_outfit(gb, embedder, device)
+                            tn = embed_outfit(bd, embedder, device)
+                            anchor_tokens.append(ta.unsqueeze(0))
+                            positive_tokens.append(tb.unsqueeze(0))
+                            negative_tokens.append(tn.unsqueeze(0))
+                        A = torch.cat(anchor_tokens, dim=0)
+                        P = torch.cat(positive_tokens, dim=0)
+                        N = torch.cat(negative_tokens, dim=0)
+                        ea = model.encoder(A).mean(dim=1)
+                        ep = model.encoder(P).mean(dim=1)
+                        en = model.encoder(N).mean(dim=1)
+                        l = triplet(ea, ep, en).item()
+                        losses.append(l)
+                
+                val_loss = sum(losses) / max(1, len(losses))
+                print(f"  📊 Validation loss: {val_loss:.4f}")
+                
+            except Exception as e:
+                print(f"  ⚠️  Validation failed: {e}")
 
         out_path = args.export
         if not out_path.startswith("models/"):
             out_path = os.path.join(export_dir, os.path.basename(args.export))
-        torch.save({"state_dict": model.state_dict()}, out_path)
+        
+        # Save checkpoint
+        torch.save({"state_dict": model.state_dict(), "epoch": epoch+1, "loss": avg_loss}, out_path)
+        
         if val_loss is not None:
-            print(f"Epoch {epoch+1}/{args.epochs} triplet_loss={loss.item():.4f} val_triplet_loss={val_loss:.4f} saved -> {out_path}")
-            hist.append({"epoch": epoch + 1, "triplet_loss": float(loss.item()), "val_triplet_loss": float(val_loss)})
+            print(f"✅ Epoch {epoch+1}/{args.epochs} triplet_loss={avg_loss:.4f} val_triplet_loss={val_loss:.4f} saved -> {out_path}")
+            hist.append({"epoch": epoch + 1, "triplet_loss": float(avg_loss), "val_triplet_loss": float(val_loss)})
             if val_loss < best_loss:
                 best_loss = val_loss
-                torch.save({"state_dict": model.state_dict()}, os.path.join(export_dir, "vit_outfit_model_best.pth"))
+                best_path = os.path.join(export_dir, "vit_outfit_model_best.pth")
+                torch.save({"state_dict": model.state_dict(), "epoch": epoch+1, "loss": avg_loss, "val_loss": val_loss}, best_path)
+                print(f"🏆 New best model saved: {best_path}")
         else:
-            print(f"Epoch {epoch+1}/{args.epochs} triplet_loss={loss.item():.4f} saved -> {out_path}")
-            hist.append({"epoch": epoch + 1, "triplet_loss": float(loss.item())})
+            print(f"✅ Epoch {epoch+1}/{args.epochs} triplet_loss={avg_loss:.4f} saved -> {out_path}")
+            hist.append({"epoch": epoch + 1, "triplet_loss": float(avg_loss)})
 
+    # Write metrics
     metrics_path = os.path.join(export_dir, "vit_metrics.json")
     payload = {"best_val_triplet_loss": best_loss if best_loss != float("inf") else None, "history": hist}
     with open(metrics_path, "w") as f:
         json.dump(payload, f)
+    
+    print(f"📊 Training completed!")
+    if best_loss != float("inf"):
+        print(f"🏆 Best validation loss: {best_loss:.4f}")
+    print(f"📈 Metrics saved to: {metrics_path}")
 
 
 if __name__ == "__main__":

training_monitor.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+"""
+Simple training monitor for Dressify.
+Shows real-time training progress and status.
+"""
+
+import os
+import time
+import json
+from datetime import datetime
+from typing import Dict, Any, Optional
+
+class TrainingMonitor:
+    """Monitor training progress and status."""
+    
+    def __init__(self, export_dir: str = "models/exports"):
+        self.export_dir = export_dir
+        self.status_file = os.path.join(export_dir, "training_status.json")
+        self.start_time = None
+        
+    def start_training(self, model_name: str, config: Dict[str, Any]):
+        """Start monitoring a training session."""
+        self.start_time = datetime.now()
+        status = {
+            "model": model_name,
+            "status": "training",
+            "start_time": self.start_time.isoformat(),
+            "config": config,
+            "epochs_completed": 0,
+            "current_loss": None,
+            "best_loss": float("inf"),
+            "last_update": datetime.now().isoformat()
+        }
+        self._save_status(status)
+        print(f"🚀 Started monitoring {model_name} training")
+        
+    def update_progress(self, epoch: int, loss: float, is_best: bool = False):
+        """Update training progress."""
+        if not self.start_time:
+            return
+            
+        try:
+            with open(self.status_file, 'r') as f:
+                status = json.load(f)
+        except:
+            return
+            
+        status["epochs_completed"] = epoch
+        status["current_loss"] = loss
+        status["last_update"] = datetime.now().isoformat()
+        
+        if is_best:
+            status["best_loss"] = min(status["best_loss"], loss)
+            
+        self._save_status(status)
+        
+    def complete_training(self, final_loss: float, total_epochs: int):
+        """Mark training as completed."""
+        try:
+            with open(self.status_file, 'r') as f:
+                status = json.load(f)
+        except:
+            return
+            
+        status["status"] = "completed"
+        status["epochs_completed"] = total_epochs
+        status["current_loss"] = final_loss
+        status["best_loss"] = min(status["best_loss"], final_loss)
+        status["completion_time"] = datetime.now().isoformat()
+        status["duration"] = str(datetime.now() - self.start_time) if self.start_time else None
+        
+        self._save_status(status)
+        print(f"✅ Training completed in {status['duration']}")
+        
+    def fail_training(self, error: str):
+        """Mark training as failed."""
+        try:
+            with open(self.status_file, 'r') as f:
+                status = json.load(f)
+        except:
+            return
+            
+        status["status"] = "failed"
+        status["error"] = error
+        status["failure_time"] = datetime.now().isoformat()
+        
+        self._save_status(status)
+        print(f"❌ Training failed: {error}")
+        
+    def get_status(self) -> Optional[Dict[str, Any]]:
+        """Get current training status."""
+        try:
+            with open(self.status_file, 'r') as f:
+                return json.load(f)
+        except:
+            return None
+            
+    def _save_status(self, status: Dict[str, Any]):
+        """Save status to file."""
+        os.makedirs(self.export_dir, exist_ok=True)
+        with open(self.status_file, 'w') as f:
+            json.dump(status, f, indent=2)
+            
+    def print_status(self):
+        """Print current training status."""
+        status = self.get_status()
+        if not status:
+            print("📊 No training status available")
+            return
+            
+        print(f"\n📊 Training Status: {status['model']}")
+        print(f"Status: {status['status']}")
+        print(f"Started: {status['start_time']}")
+        print(f"Epochs: {status['epochs_completed']}")
+        print(f"Current Loss: {status['current_loss']:.4f}" if status['current_loss'] else "Current Loss: N/A")
+        print(f"Best Loss: {status['best_loss']:.4f}" if status['best_loss'] != float("inf") else "Best Loss: N/A")
+        print(f"Last Update: {status['last_update']}")
+        
+        if status['status'] == 'completed':
+            print(f"Duration: {status['duration']}")
+        elif status['status'] == 'failed':
+            print(f"Error: {status['error']}")
+
+def create_monitor() -> TrainingMonitor:
+    """Create a training monitor instance."""
+    export_dir = os.getenv("EXPORT_DIR", "models/exports")
+    return TrainingMonitor(export_dir)
+
+if __name__ == "__main__":
+    # Test the monitor
+    monitor = create_monitor()
+    monitor.print_status()

utils/artifact_manager.py

@@ -0,0 +1,417 @@
+#!/usr/bin/env python3
+"""
+Comprehensive artifact manager for Dressify.
+Handles packaging, downloading, and organizing all system artifacts.
+"""
+
+import os
+import json
+import shutil
+import zipfile
+import tarfile
+from datetime import datetime
+from typing import Dict, List, Any, Optional
+from pathlib import Path
+
+class ArtifactManager:
+    """Manages all system artifacts for easy download and upload."""
+    
+    def __init__(self, base_dir: str = "/home/user/app"):
+        self.base_dir = base_dir
+        self.data_dir = os.path.join(base_dir, "data/Polyvore")
+        self.splits_dir = os.path.join(self.data_dir, "splits")
+        self.export_dir = os.getenv("EXPORT_DIR", "models/exports")
+        
+        # Default HF repositories - updated to use your specific repos
+        self.default_repos = {
+            "splits": "Stylique/Dressify-Helper",
+            "models": "Stylique/dressify-models",
+            "metadata": "Stylique/Dressify-Helper"
+        }
+        
+        # Repository organization structure
+        self.repo_structure = {
+            "Stylique/dressify-models": {
+                "description": "Dressify trained models and checkpoints",
+                "files": {
+                    "resnet_item_embedder_best.pth": "ResNet50 item embedder (best checkpoint)",
+                    "vit_outfit_model_best.pth": "ViT outfit compatibility model (best checkpoint)",
+                    "resnet_metrics.json": "ResNet training metrics and history",
+                    "vit_metrics.json": "ViT training metrics and history",
+                    "model_cards/": "Model documentation and cards"
+                }
+            },
+            "Stylique/Dressify-Helper": {
+                "description": "Dressify dataset splits, metadata, and helper files",
+                "files": {
+                    "splits/": "Dataset splits (train/valid/test)",
+                    "metadata/": "Item metadata and outfit information",
+                    "configs/": "Training configurations",
+                    "packages/": "Pre-packaged downloads"
+                }
+            }
+        }
+        
+    def get_artifact_summary(self) -> Dict[str, Any]:
+        """Get comprehensive summary of all available artifacts."""
+        summary = {
+            "timestamp": datetime.now().isoformat(),
+            "datasets": self._get_dataset_info(),
+            "splits": self._get_splits_info(),
+            "models": self._get_models_info(),
+            "configs": self._get_configs_info(),
+            "metadata": self._get_metadata_info(),
+            "hf_repos": self.repo_structure,
+            "total_size_mb": 0
+        }
+        
+        # Calculate total size
+        total_size = 0
+        for category in summary.values():
+            if isinstance(category, dict) and "size_mb" in category:
+                total_size += category["size_mb"]
+        summary["total_size_mb"] = round(total_size, 2)
+        
+        return summary
+    
+    def _get_dataset_info(self) -> Dict[str, Any]:
+        """Get information about the Polyvore dataset."""
+        info = {
+            "status": "not_found",
+            "size_mb": 0,
+            "files": [],
+            "images_count": 0
+        }
+        
+        if os.path.exists(self.data_dir):
+            info["status"] = "available"
+            
+            # Count images
+            images_dir = os.path.join(self.data_dir, "images")
+            if os.path.exists(images_dir):
+                try:
+                    image_files = [f for f in os.listdir(images_dir) if f.lower().endswith(('.jpg', '.jpeg', '.png', '.webp'))]
+                    info["images_count"] = len(image_files)
+                except:
+                    pass
+            
+            # Calculate size
+            try:
+                total_size = sum(os.path.getsize(os.path.join(dirpath, filename))
+                               for dirpath, dirnames, filenames in os.walk(self.data_dir)
+                               for filename in filenames)
+                info["size_mb"] = round(total_size / (1024 * 1024), 2)
+            except:
+                pass
+            
+            # List key files
+            key_files = ["images.zip", "polyvore_item_metadata.json", "polyvore_outfit_titles.json", "categories.csv"]
+            for file in key_files:
+                file_path = os.path.join(self.data_dir, file)
+                if os.path.exists(file_path):
+                    info["files"].append({
+                        "name": file,
+                        "size_mb": round(os.path.getsize(file_path) / (1024 * 1024), 2),
+                        "path": file_path
+                    })
+        
+        return info
+    
+    def _get_splits_info(self) -> Dict[str, Any]:
+        """Get information about dataset splits."""
+        info = {
+            "status": "not_found",
+            "size_mb": 0,
+            "files": [],
+            "splits_available": []
+        }
+        
+        if os.path.exists(self.splits_dir):
+            info["status"] = "available"
+            
+            split_files = [
+                "train.json", "valid.json", "test.json",
+                "outfits_train.json", "outfits_valid.json", "outfits_test.json",
+                "outfit_triplets_train.json", "outfit_triplets_valid.json", "outfit_triplets_test.json"
+            ]
+            
+            total_size = 0
+            for file in split_files:
+                file_path = os.path.join(self.splits_dir, file)
+                if os.path.exists(file_path):
+                    size_mb = round(os.path.getsize(file_path) / (1024 * 1024), 2)
+                    total_size += size_mb
+                    info["files"].append({
+                        "name": file,
+                        "size_mb": size_mb,
+                        "path": file_path
+                    })
+                    info["splits_available"].append(file.replace(".json", ""))
+            
+            info["size_mb"] = round(total_size, 2)
+        
+        return info
+    
+    def _get_models_info(self) -> Dict[str, Any]:
+        """Get information about trained models."""
+        info = {
+            "status": "not_found",
+            "size_mb": 0,
+            "files": [],
+            "models_available": []
+        }
+        
+        if os.path.exists(self.export_dir):
+            info["status"] = "available"
+            
+            model_files = [
+                "resnet_item_embedder.pth", "resnet_item_embedder_best.pth",
+                "vit_outfit_model.pth", "vit_outfit_model_best.pth",
+                "resnet_metrics.json", "vit_metrics.json"
+            ]
+            
+            total_size = 0
+            for file in model_files:
+                file_path = os.path.join(self.export_dir, file)
+                if os.path.exists(file_path):
+                    size_mb = round(os.path.getsize(file_path) / (1024 * 1024), 2)
+                    total_size += size_mb
+                    info["files"].append({
+                        "name": file,
+                        "size_mb": size_mb,
+                        "path": file_path,
+                        "type": "checkpoint" if file.endswith(".pth") else "metrics"
+                    })
+                    if file.endswith(".pth"):
+                        info["models_available"].append(file.replace(".pth", ""))
+            
+            info["size_mb"] = round(total_size, 2)
+        
+        return info
+    
+    def _get_configs_info(self) -> Dict[str, Any]:
+        """Get information about configuration files."""
+        info = {
+            "status": "not_found",
+            "size_mb": 0,
+            "files": []
+        }
+        
+        config_files = [
+            "resnet_config_custom.json", "vit_config_custom.json",
+            "item.yaml", "outfit.yaml", "default.yaml"
+        ]
+        
+        total_size = 0
+        for file in config_files:
+            # Check export dir first, then configs dir
+            file_path = os.path.join(self.export_dir, file)
+            if not os.path.exists(file_path):
+                file_path = os.path.join("configs", file)
+            
+            if os.path.exists(file_path):
+                size_mb = round(os.path.getsize(file_path) / (1024 * 1024), 2)
+                total_size += size_mb
+                info["files"].append({
+                    "name": file,
+                    "size_mb": size_mb,
+                    "path": file_path
+                })
+        
+        if info["files"]:
+            info["status"] = "available"
+            info["size_mb"] = round(total_size, 2)
+        
+        return info
+    
+    def _get_metadata_info(self) -> Dict[str, Any]:
+        """Get information about metadata files."""
+        info = {
+            "status": "not_found",
+            "size_mb": 0,
+            "files": []
+        }
+        
+        metadata_files = [
+            "polyvore_item_metadata.json", "polyvore_outfit_titles.json", "categories.csv"
+        ]
+        
+        total_size = 0
+        for file in metadata_files:
+            file_path = os.path.join(self.data_dir, file)
+            if os.path.exists(file_path):
+                size_mb = round(os.path.getsize(file_path) / (1024 * 1024), 2)
+                total_size += size_mb
+                info["files"].append({
+                    "name": file,
+                    "size_mb": size_mb,
+                    "path": file_path
+                })
+        
+        if info["files"]:
+            info["status"] = "available"
+            info["size_mb"] = round(total_size, 2)
+        
+        return info
+    
+    def create_download_package(self, package_type: str = "complete") -> str:
+        """Create a downloadable package of artifacts."""
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        
+        if package_type == "complete":
+            # Complete package with everything
+            package_name = f"dressify_complete_{timestamp}"
+            package_path = os.path.join(self.export_dir, f"{package_name}.tar.gz")
+            
+            with tarfile.open(package_path, "w:gz") as tar:
+                # Add splits
+                if os.path.exists(self.splits_dir):
+                    tar.add(self.splits_dir, arcname="splits")
+                
+                # Add models
+                if os.path.exists(self.export_dir):
+                    for file in os.listdir(self.export_dir):
+                        if file.endswith((".pth", ".json", ".yaml")):
+                            tar.add(os.path.join(self.export_dir, file), arcname=f"models/{file}")
+                
+                # Add metadata
+                metadata_files = ["polyvore_item_metadata.json", "polyvore_outfit_titles.json", "categories.csv"]
+                for file in metadata_files:
+                    file_path = os.path.join(self.data_dir, file)
+                    if os.path.exists(file_path):
+                        tar.add(file_path, arcname=f"metadata/{file}")
+                
+                # Add configs
+                configs_dir = "configs"
+                if os.path.exists(configs_dir):
+                    tar.add(configs_dir, arcname="configs")
+        
+        elif package_type == "splits_only":
+            # Only splits (lightweight)
+            package_name = f"dressify_splits_{timestamp}"
+            package_path = os.path.join(self.export_dir, f"{package_name}.tar.gz")
+            
+            with tarfile.open(package_path, "w:gz") as tar:
+                if os.path.exists(self.splits_dir):
+                    tar.add(self.splits_dir, arcname="splits")
+        
+        elif package_type == "models_only":
+            # Only trained models
+            package_name = f"dressify_models_{timestamp}"
+            package_path = os.path.join(self.export_dir, f"{package_name}.tar.gz")
+            
+            with tarfile.open(package_path, "w:gz") as tar:
+                if os.path.exists(self.export_dir):
+                    for file in os.listdir(self.export_dir):
+                        if file.endswith((".pth", ".json")):
+                            tar.add(os.path.join(self.export_dir, file), arcname=f"models/{file}")
+        
+        else:
+            raise ValueError(f"Unknown package type: {package_type}")
+        
+        return package_path
+    
+    def get_downloadable_files(self) -> List[Dict[str, Any]]:
+        """Get list of all downloadable files."""
+        files = []
+        
+        # Add splits
+        if os.path.exists(self.splits_dir):
+            for file in os.listdir(self.splits_dir):
+                if file.endswith(".json"):
+                    file_path = os.path.join(self.splits_dir, file)
+                    files.append({
+                        "name": f"splits/{file}",
+                        "size_mb": round(os.path.getsize(file_path) / (1024 * 1024), 2),
+                        "path": file_path,
+                        "category": "splits",
+                        "description": f"Dataset split: {file.replace('.json', '')}"
+                    })
+        
+        # Add models
+        if os.path.exists(self.export_dir):
+            for file in os.listdir(self.export_dir):
+                if file.endswith((".pth", ".json")):
+                    file_path = os.path.join(self.export_dir, file)
+                    files.append({
+                        "name": f"models/{file}",
+                        "size_mb": round(os.path.getsize(file_path) / (1024 * 1024), 2),
+                        "path": file_path,
+                        "category": "models",
+                        "description": "Trained model or metrics"
+                    })
+        
+        # Add metadata
+        metadata_files = ["polyvore_item_metadata.json", "polyvore_outfit_titles.json", "categories.csv"]
+        for file in metadata_files:
+            file_path = os.path.join(self.data_dir, file)
+            if os.path.exists(file_path):
+                files.append({
+                    "name": f"metadata/{file}",
+                    "size_mb": round(os.path.getsize(file_path) / (1024 * 1024), 2),
+                    "path": file_path,
+                    "category": "metadata",
+                    "description": "Dataset metadata"
+                })
+        
+        return files
+    
+    def create_hf_upload_plan(self) -> Dict[str, Any]:
+        """Create a plan for uploading to HF Hub."""
+        plan = {
+            "Stylique/dressify-models": {
+                "description": "Upload trained models and checkpoints",
+                "files_to_upload": [],
+                "estimated_size_mb": 0
+            },
+            "Stylique/Dressify-Helper": {
+                "description": "Upload dataset splits and metadata",
+                "files_to_upload": [],
+                "estimated_size_mb": 0
+            }
+        }
+        
+        # Plan for models repo
+        if os.path.exists(self.export_dir):
+            for file in os.listdir(self.export_dir):
+                if file.endswith((".pth", ".json")):
+                    file_path = os.path.join(self.export_dir, file)
+                    size_mb = round(os.path.getsize(file_path) / (1024 * 1024), 2)
+                    plan["Stylique/dressify-models"]["files_to_upload"].append({
+                        "name": file,
+                        "path": file_path,
+                        "size_mb": size_mb
+                    })
+                    plan["Stylique/dressify-models"]["estimated_size_mb"] += size_mb
+        
+        # Plan for helper repo
+        if os.path.exists(self.splits_dir):
+            for file in os.listdir(self.splits_dir):
+                if file.endswith(".json"):
+                    file_path = os.path.join(self.splits_dir, file)
+                    size_mb = round(os.path.getsize(file_path) / (1024 * 1024), 2)
+                    plan["Stylique/Dressify-Helper"]["files_to_upload"].append({
+                        "name": f"splits/{file}",
+                        "path": file_path,
+                        "size_mb": size_mb
+                    })
+                    plan["Stylique/Dressify-Helper"]["estimated_size_mb"] += size_mb
+        
+        # Add metadata files
+        metadata_files = ["polyvore_item_metadata.json", "polyvore_outfit_titles.json", "categories.csv"]
+        for file in metadata_files:
+            file_path = os.path.join(self.data_dir, file)
+            if os.path.exists(file_path):
+                size_mb = round(os.path.getsize(file_path) / (1024 * 1024), 2)
+                plan["Stylique/Dressify-Helper"]["files_to_upload"].append({
+                    "name": f"metadata/{file}",
+                    "path": file_path,
+                    "size_mb": size_mb
+                })
+                plan["Stylique/Dressify-Helper"]["estimated_size_mb"] += size_mb
+        
+        return plan
+
+def create_artifact_manager() -> ArtifactManager:
+    """Create an artifact manager instance."""
+    return ArtifactManager()

utils/export.py

@@ -5,11 +5,19 @@ import torch
 
 
 def ensure_export_dir(path: str) -> str:
+    """Create export directory and all parent directories if they don't exist."""
     os.makedirs(path, exist_ok=True)
     return path
 
 
+def get_export_dir() -> str:
+    """Get the default export directory, creating it if necessary."""
+    export_dir = os.getenv("EXPORT_DIR", "models/exports")
+    return ensure_export_dir(export_dir)
+
+
 def export_torchscript(model: torch.nn.Module, example_inputs: torch.Tensor, out_path: str) -> str:
+    """Export model to TorchScript format."""
     model.eval()
     traced = torch.jit.trace(model, example_inputs)
     torch.jit.save(traced, out_path)
@@ -17,6 +25,7 @@ def export_torchscript(model: torch.nn.Module, example_inputs: torch.Tensor, out
 
 
 def export_onnx(model: torch.nn.Module, example_inputs: torch.Tensor, out_path: str, opset: int = 17) -> str:
+    """Export model to ONNX format."""
     model.eval()
     torch.onnx.export(
         model,
@@ -32,6 +41,20 @@ def export_onnx(model: torch.nn.Module, example_inputs: torch.Tensor, out_path:
     return out_path
 
 
+def save_checkpoint(model: torch.nn.Module, path: str, **kwargs) -> str:
+    """Save model checkpoint with metadata."""
+    # Ensure directory exists
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    
+    # Save checkpoint
+    checkpoint = {
+        "state_dict": model.state_dict(),
+        **kwargs
+    }
+    torch.save(checkpoint, path)
+    return path
+
+
 
 
 

utils/hf_hub_integration.py

@@ -0,0 +1,413 @@
+#!/usr/bin/env python3
+"""
+Hugging Face Hub integration for Dressify.
+Handles uploading artifacts to specific HF repositories.
+"""
+
+import os
+import json
+import shutil
+from datetime import datetime
+from typing import Dict, List, Any, Optional
+from huggingface_hub import HfApi, create_repo, upload_file, upload_folder
+from pathlib import Path
+
+class HFHubIntegration:
+    """Integrates with Hugging Face Hub for artifact management."""
+    
+    def __init__(self, token: str = None):
+        self.api = HfApi(token=token)
+        self.token = token
+        
+        # Your specific repositories
+        self.repos = {
+            "models": "Stylique/dressify-models",
+            "helper": "Stylique/Dressify-Helper"
+        }
+        
+        # Repository descriptions and metadata
+        self.repo_metadata = {
+            "Stylique/dressify-models": {
+                "description": "Dressify trained models and checkpoints for outfit recommendation",
+                "tags": ["computer-vision", "fashion", "outfit-recommendation", "deep-learning"],
+                "license": "mit",
+                "language": "en"
+            },
+            "Stylique/Dressify-Helper": {
+                "description": "Dressify dataset splits, metadata, and helper files",
+                "tags": ["dataset", "fashion", "outfit-recommendation", "polyvore"],
+                "license": "mit",
+                "language": "en"
+            }
+        }
+    
+    def ensure_repos_exist(self) -> Dict[str, bool]:
+        """Ensure all required repositories exist, create if they don't."""
+        results = {}
+        
+        for repo_id in self.repos.values():
+            try:
+                # Try to get repo info
+                repo_info = self.api.repo_info(repo_id)
+                results[repo_id] = True
+                print(f"✅ Repository exists: {repo_id}")
+            except Exception:
+                try:
+                    # Create repository
+                    if "models" in repo_id:
+                        create_repo(
+                            repo_id=repo_id,
+                            repo_type="model",
+                            token=self.token,
+                            description=self.repo_metadata[repo_id]["description"],
+                            license=self.repo_metadata[repo_id]["license"],
+                            tags=self.repo_metadata[repo_id]["tags"]
+                        )
+                    else:
+                        create_repo(
+                            repo_id=repo_id,
+                            repo_type="dataset",
+                            token=self.token,
+                            description=self.repo_metadata[repo_id]["description"],
+                            license=self.repo_metadata[repo_id]["license"],
+                            tags=self.repo_metadata[repo_id]["tags"]
+                        )
+                    
+                    results[repo_id] = True
+                    print(f"✅ Created repository: {repo_id}")
+                except Exception as e:
+                    results[repo_id] = False
+                    print(f"❌ Failed to create repository {repo_id}: {e}")
+        
+        return results
+    
+    def upload_models_to_hf(self, models_dir: str = None) -> Dict[str, Any]:
+        """Upload trained models to the models repository."""
+        if models_dir is None:
+            models_dir = os.getenv("EXPORT_DIR", "models/exports")
+        
+        if not os.path.exists(models_dir):
+            return {"success": False, "error": f"Models directory not found: {models_dir}"}
+        
+        try:
+            print(f"🚀 Uploading models to {self.repos['models']}...")
+            
+            # Files to upload
+            model_files = [
+                "resnet_item_embedder_best.pth",
+                "vit_outfit_model_best.pth",
+                "resnet_metrics.json",
+                "vit_metrics.json"
+            ]
+            
+            uploaded_files = []
+            total_size = 0
+            
+            for file in model_files:
+                file_path = os.path.join(models_dir, file)
+                if os.path.exists(file_path):
+                    try:
+                        # Upload file
+                        self.api.upload_file(
+                            path_or_fileobj=file_path,
+                            path_in_repo=file,
+                            repo_id=self.repos['models'],
+                            token=self.token
+                        )
+                        
+                        size_mb = round(os.path.getsize(file_path) / (1024 * 1024), 2)
+                        total_size += size_mb
+                        uploaded_files.append({
+                            "name": file,
+                            "size_mb": size_mb,
+                            "status": "uploaded"
+                        })
+                        
+                        print(f"✅ Uploaded: {file} ({size_mb} MB)")
+                        
+                    except Exception as e:
+                        uploaded_files.append({
+                            "name": file,
+                            "status": "failed",
+                            "error": str(e)
+                        })
+                        print(f"❌ Failed to upload {file}: {e}")
+            
+            # Create model card
+            self._create_model_card()
+            
+            result = {
+                "success": True,
+                "repository": self.repos['models'],
+                "uploaded_files": uploaded_files,
+                "total_size_mb": total_size,
+                "timestamp": datetime.now().isoformat()
+            }
+            
+            print(f"🎉 Models upload completed! Total size: {total_size} MB")
+            return result
+            
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+    
+    def upload_splits_to_hf(self, splits_dir: str = None) -> Dict[str, Any]:
+        """Upload dataset splits to the helper repository."""
+        if splits_dir is None:
+            splits_dir = os.path.join(os.getenv("POLYVORE_ROOT", "/home/user/app/data/Polyvore"), "splits")
+        
+        if not os.path.exists(splits_dir):
+            return {"success": False, "error": f"Splits directory not found: {splits_dir}"}
+        
+        try:
+            print(f"🚀 Uploading splits to {self.repos['helper']}...")
+            
+            # Upload entire splits directory
+            self.api.upload_folder(
+                folder_path=splits_dir,
+                path_in_repo="splits",
+                repo_id=self.repos['helper'],
+                token=self.token
+            )
+            
+            # Calculate total size
+            total_size = 0
+            for root, dirs, files in os.walk(splits_dir):
+                for file in files:
+                    file_path = os.path.join(root, file)
+                    total_size += os.path.getsize(file_path)
+            
+            total_size_mb = round(total_size / (1024 * 1024), 2)
+            
+            result = {
+                "success": True,
+                "repository": self.repos['helper'],
+                "uploaded_folder": "splits",
+                "total_size_mb": total_size_mb,
+                "timestamp": datetime.now().isoformat()
+            }
+            
+            print(f"🎉 Splits upload completed! Total size: {total_size_mb} MB")
+            return result
+            
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+    
+    def upload_metadata_to_hf(self, data_dir: str = None) -> Dict[str, Any]:
+        """Upload metadata files to the helper repository."""
+        if data_dir is None:
+            data_dir = os.getenv("POLYVORE_ROOT", "/home/user/app/data/Polyvore")
+        
+        if not os.path.exists(data_dir):
+            return {"success": False, "error": f"Data directory not found: {data_dir}"}
+        
+        try:
+            print(f"🚀 Uploading metadata to {self.repos['helper']}...")
+            
+            # Metadata files to upload
+            metadata_files = [
+                "polyvore_item_metadata.json",
+                "polyvore_outfit_titles.json",
+                "categories.csv"
+            ]
+            
+            uploaded_files = []
+            total_size = 0
+            
+            for file in metadata_files:
+                file_path = os.path.join(data_dir, file)
+                if os.path.exists(file_path):
+                    try:
+                        # Upload to metadata subfolder
+                        self.api.upload_file(
+                            path_or_fileobj=file_path,
+                            path_in_repo=f"metadata/{file}",
+                            repo_id=self.repos['helper'],
+                            token=self.token
+                        )
+                        
+                        size_mb = round(os.path.getsize(file_path) / (1024 * 1024), 2)
+                        total_size += size_mb
+                        uploaded_files.append({
+                            "name": file,
+                            "size_mb": size_mb,
+                            "status": "uploaded"
+                        })
+                        
+                        print(f"✅ Uploaded: {file} ({size_mb} MB)")
+                        
+                    except Exception as e:
+                        uploaded_files.append({
+                            "name": file,
+                            "status": "failed",
+                            "error": str(e)
+                        })
+                        print(f"❌ Failed to upload {file}: {e}")
+            
+            result = {
+                "success": True,
+                "repository": self.repos['helper'],
+                "uploaded_files": uploaded_files,
+                "total_size_mb": total_size,
+                "timestamp": datetime.now().isoformat()
+            }
+            
+            print(f"🎉 Metadata upload completed! Total size: {total_size} MB")
+            return result
+            
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+    
+    def upload_everything_to_hf(self) -> Dict[str, Any]:
+        """Upload all artifacts to HF Hub."""
+        print("🚀 Starting comprehensive upload to HF Hub...")
+        
+        # Ensure repositories exist
+        repo_status = self.ensure_repos_exist()
+        if not all(repo_status.values()):
+            return {"success": False, "error": "Failed to ensure repositories exist"}
+        
+        # Upload everything
+        results = {
+            "models": self.upload_models_to_hf(),
+            "splits": self.upload_splits_to_hf(),
+            "metadata": self.upload_metadata_to_hf(),
+            "timestamp": datetime.now().isoformat()
+        }
+        
+        # Summary
+        success_count = sum(1 for r in results.values() if isinstance(r, dict) and r.get("success", False))
+        total_count = len([r for r in results.values() if isinstance(r, dict)])
+        
+        print(f"\n📊 Upload Summary: {success_count}/{total_count} successful")
+        for category, result in results.items():
+            if isinstance(result, dict):
+                status = "✅" if result.get("success", False) else "❌"
+                print(f"  {status} {category}")
+        
+        return results
+    
+    def _create_model_card(self):
+        """Create a model card for the models repository."""
+        model_card_content = """---
+language: en
+license: mit
+tags:
+- computer-vision
+- fashion
+- outfit-recommendation
+- deep-learning
+- resnet
+- vision-transformer
+---
+
+# Dressify Outfit Recommendation Models
+
+This repository contains the trained models for the Dressify outfit recommendation system.
+
+## Models
+
+### ResNet Item Embedder
+- **Architecture**: ResNet50 with custom projection head
+- **Purpose**: Generate 512-dimensional embeddings for fashion items
+- **Training**: Triplet loss with semi-hard negative mining
+- **Input**: Fashion item images (224x224)
+- **Output**: L2-normalized 512D embeddings
+
+### ViT Outfit Compatibility Model
+- **Architecture**: Vision Transformer encoder
+- **Purpose**: Score outfit compatibility from item embeddings
+- **Training**: Triplet loss with cosine distance
+- **Input**: Variable-length sequence of item embeddings
+- **Output**: Compatibility score (0-1)
+
+## Usage
+
+```python
+from huggingface_hub import hf_hub_download
+import torch
+
+# Download models
+resnet_path = hf_hub_download(repo_id="Stylique/dressify-models", filename="resnet_item_embedder_best.pth")
+vit_path = hf_hub_download(repo_id="Stylique/dressify-models", filename="vit_outfit_model_best.pth")
+
+# Load models
+resnet_model = torch.load(resnet_path)
+vit_model = torch.load(vit_path)
+```
+
+## Training Details
+
+- **Dataset**: Polyvore Outfits (Stylique/Polyvore)
+- **Loss**: Triplet margin loss
+- **Optimizer**: AdamW
+- **Mixed Precision**: Enabled
+- **Hardware**: NVIDIA GPU with CUDA
+
+## Performance
+
+- **ResNet**: ~25M parameters, fast inference
+- **ViT**: ~12M parameters, efficient outfit scoring
+- **Memory**: Optimized for deployment on Hugging Face Spaces
+
+## Citation
+
+If you use these models in your research, please cite:
+
+```bibtex
+@misc{dressify2024,
+  title={Dressify: Deep Learning for Fashion Outfit Recommendation},
+  author={Stylique},
+  year={2024},
+  url={https://huggingface.co/Stylique/dressify-models}
+}
+```
+"""
+        
+        # Save model card
+        model_card_path = "model_card.md"
+        with open(model_card_path, 'w') as f:
+            f.write(model_card_content)
+        
+        # Upload model card
+        try:
+            self.api.upload_file(
+                path_or_fileobj=model_card_path,
+                path_in_repo="README.md",
+                repo_id=self.repos['models'],
+                token=self.token
+            )
+            print("✅ Model card uploaded")
+            
+            # Clean up
+            os.remove(model_card_path)
+        except Exception as e:
+            print(f"⚠️ Failed to upload model card: {e}")
+    
+    def get_upload_status(self) -> Dict[str, Any]:
+        """Get current upload status and repository information."""
+        status = {
+            "repositories": {},
+            "last_upload": None,
+            "total_uploads": 0
+        }
+        
+        for repo_id in self.repos.values():
+            try:
+                repo_info = self.api.repo_info(repo_id)
+                status["repositories"][repo_id] = {
+                    "exists": True,
+                    "last_modified": repo_info.last_modified.isoformat() if repo_info.last_modified else None,
+                    "size": repo_info.size_on_disk if hasattr(repo_info, 'size_on_disk') else None
+                }
+            except Exception:
+                status["repositories"][repo_id] = {
+                    "exists": False,
+                    "last_modified": None,
+                    "size": None
+                }
+        
+        return status
+
+def create_hf_integration(token: str = None) -> HFHubIntegration:
+    """Create an HF Hub integration instance."""
+    return HFHubIntegration(token=token)

utils/runtime_fetcher.py

@@ -0,0 +1,312 @@
+#!/usr/bin/env python3
+"""
+Runtime artifact fetcher for Dressify.
+Downloads pre-processed artifacts from Hugging Face Hub to avoid reprocessing.
+"""
+
+import os
+import json
+import shutil
+import tarfile
+import zipfile
+from pathlib import Path
+from typing import Dict, List, Any, Optional
+from huggingface_hub import hf_hub_download, snapshot_download
+
+class RuntimeArtifactFetcher:
+    """Fetches artifacts from HF Hub at runtime to avoid reprocessing."""
+    
+    def __init__(self, base_dir: str = "/home/user/app"):
+        self.base_dir = base_dir
+        self.data_dir = os.path.join(base_dir, "data/Polyvore")
+        self.splits_dir = os.path.join(self.data_dir, "splits")
+        self.export_dir = os.getenv("EXPORT_DIR", "models/exports")
+        
+        # Default HF repositories - updated to use your specific repos
+        self.default_repos = {
+            "splits": "Stylique/Dressify-Helper",
+            "models": "Stylique/dressify-models",
+            "metadata": "Stylique/Dressify-Helper"
+        }
+    
+    def check_artifacts_needed(self) -> Dict[str, Any]:
+        """Check what artifacts need to be fetched."""
+        needs = {
+            "splits": False,
+            "models": False,
+            "metadata": False,
+            "total_size_mb": 0
+        }
+        
+        # Check splits
+        if not os.path.exists(self.splits_dir) or not self._has_complete_splits():
+            needs["splits"] = True
+            needs["total_size_mb"] += 50  # Estimate splits size
+        
+        # Check models
+        if not os.path.exists(self.export_dir) or not self._has_trained_models():
+            needs["models"] = True
+            needs["total_size_mb"] += 200  # Estimate models size
+        
+        # Check metadata
+        if not self._has_complete_metadata():
+            needs["metadata"] = True
+            needs["total_size_mb"] += 100  # Estimate metadata size
+        
+        return needs
+    
+    def _has_complete_splits(self) -> bool:
+        """Check if complete splits are available."""
+        required_files = [
+            "train.json", "valid.json", "test.json",
+            "outfit_triplets_train.json", "outfit_triplets_valid.json", "outfit_triplets_test.json"
+        ]
+        
+        for file in required_files:
+            if not os.path.exists(os.path.join(self.splits_dir, file)):
+                return False
+        return True
+    
+    def _has_trained_models(self) -> bool:
+        """Check if trained models are available."""
+        required_files = [
+            "resnet_item_embedder_best.pth",
+            "vit_outfit_model_best.pth"
+        ]
+        
+        for file in required_files:
+            if not os.path.exists(os.path.join(self.export_dir, file)):
+                return False
+        return True
+    
+    def _has_complete_metadata(self) -> bool:
+        """Check if complete metadata is available."""
+        required_files = [
+            "polyvore_item_metadata.json",
+            "polyvore_outfit_titles.json",
+            "categories.csv"
+        ]
+        
+        for file in required_files:
+            if not os.path.exists(os.path.join(self.data_dir, file)):
+                return False
+        return True
+    
+    def fetch_splits_from_hf(self, repo: str = None, token: str = None) -> bool:
+        """Fetch dataset splits from HF Hub."""
+        if repo is None:
+            repo = self.default_repos["splits"]
+        
+        try:
+            print(f"🔄 Fetching splits from {repo}...")
+            
+            # Create splits directory
+            os.makedirs(self.splits_dir, exist_ok=True)
+            
+            # Download splits files
+            split_files = [
+                "train.json", "valid.json", "test.json",
+                "outfits_train.json", "outfits_valid.json", "outfits_test.json",
+                "outfit_triplets_train.json", "outfit_triplets_valid.json", "outfit_triplets_test.json"
+            ]
+            
+            for file in split_files:
+                try:
+                    local_path = hf_hub_download(
+                        repo_id=repo,
+                        filename=f"splits/{file}",
+                        local_dir=self.splits_dir,
+                        token=token
+                    )
+                    print(f"✅ Downloaded: {file}")
+                except Exception as e:
+                    print(f"⚠️  Failed to download {file}: {e}")
+            
+            print(f"✅ Splits fetched successfully to {self.splits_dir}")
+            return True
+            
+        except Exception as e:
+            print(f"❌ Failed to fetch splits: {e}")
+            return False
+    
+    def fetch_models_from_hf(self, repo: str = None, token: str = None) -> bool:
+        """Fetch trained models from HF Hub."""
+        if repo is None:
+            repo = self.default_repos["models"]
+        
+        try:
+            print(f"🔄 Fetching models from {repo}...")
+            
+            # Create export directory
+            os.makedirs(self.export_dir, exist_ok=True)
+            
+            # Download model files
+            model_files = [
+                "resnet_item_embedder_best.pth",
+                "vit_outfit_model_best.pth",
+                "resnet_metrics.json",
+                "vit_metrics.json"
+            ]
+            
+            for file in model_files:
+                try:
+                    local_path = hf_hub_download(
+                        repo_id=repo,
+                        filename=file,
+                        local_dir=self.export_dir,
+                        token=token
+                    )
+                    print(f"✅ Downloaded: {file}")
+                except Exception as e:
+                    print(f"⚠️  Failed to download {file}: {e}")
+            
+            print(f"✅ Models fetched successfully to {self.export_dir}")
+            return True
+            
+        except Exception as e:
+            print(f"❌ Failed to fetch models: {e}")
+            return False
+    
+    def fetch_metadata_from_hf(self, repo: str = None, token: str = None) -> bool:
+        """Fetch metadata from HF Hub."""
+        if repo is None:
+            repo = self.default_repos["metadata"]
+        
+        try:
+            print(f"🔄 Fetching metadata from {repo}...")
+            
+            # Create data directory
+            os.makedirs(self.data_dir, exist_ok=True)
+            
+            # Download metadata files
+            metadata_files = [
+                "polyvore_item_metadata.json",
+                "polyvore_outfit_titles.json",
+                "categories.csv"
+            ]
+            
+            for file in metadata_files:
+                try:
+                    local_path = hf_hub_download(
+                        repo_id=repo,
+                        filename=f"metadata/{file}",
+                        local_dir=self.data_dir,
+                        token=token
+                    )
+                    print(f"✅ Downloaded: {file}")
+                except Exception as e:
+                    print(f"⚠️  Failed to download {file}: {e}")
+            
+            print(f"✅ Metadata fetched successfully to {self.data_dir}")
+            return True
+            
+        except Exception as e:
+            print(f"❌ Failed to fetch metadata: {e}")
+            return False
+    
+    def fetch_everything_from_hf(self, splits_repo: str = None, models_repo: str = None, 
+                                metadata_repo: str = None, token: str = None) -> Dict[str, bool]:
+        """Fetch all artifacts from HF Hub."""
+        results = {}
+        
+        print("🚀 Starting comprehensive artifact fetch from HF Hub...")
+        
+        # Fetch splits
+        results["splits"] = self.fetch_splits_from_hf(splits_repo, token)
+        
+        # Fetch models
+        results["models"] = self.fetch_models_from_hf(models_repo, token)
+        
+        # Fetch metadata
+        results["metadata"] = self.fetch_metadata_from_hf(metadata_repo, token)
+        
+        # Summary
+        success_count = sum(results.values())
+        total_count = len(results)
+        
+        print(f"\n📊 Fetch Summary: {success_count}/{total_count} successful")
+        for artifact, success in results.items():
+            status = "✅" if success else "❌"
+            print(f"  {status} {artifact}")
+        
+        return results
+    
+    def download_and_extract_package(self, package_path: str, extract_to: str = None) -> bool:
+        """Download and extract a package from HF Hub."""
+        try:
+            if extract_to is None:
+                extract_to = self.base_dir
+            
+            print(f"🔄 Downloading and extracting package: {package_path}")
+            
+            # Download the package
+            local_path = hf_hub_download(
+                repo_id="Stylique/Dressify-Helper",
+                filename=f"packages/{os.path.basename(package_path)}",
+                local_dir=extract_to,
+                token=None
+            )
+            
+            # Extract based on file type
+            if package_path.endswith(".tar.gz"):
+                with tarfile.open(local_path, 'r:gz') as tar:
+                    tar.extractall(extract_to)
+            elif package_path.endswith(".zip"):
+                with zipfile.ZipFile(local_path, 'r') as zipf:
+                    zipf.extractall(extract_to)
+            
+            print(f"✅ Package extracted to {extract_to}")
+            return True
+            
+        except Exception as e:
+            print(f"❌ Failed to download/extract package: {e}")
+            return False
+    
+    def get_fetch_status(self) -> Dict[str, Any]:
+        """Get current fetch status."""
+        return {
+            "splits_available": self._has_complete_splits(),
+            "models_available": self._has_trained_models(),
+            "metadata_available": self._has_complete_metadata(),
+            "artifacts_needed": self.check_artifacts_needed(),
+            "base_dir": self.base_dir,
+            "splits_dir": self.splits_dir,
+            "export_dir": self.export_dir,
+            "hf_repos": self.default_repos
+        }
+
+def create_runtime_fetcher() -> RuntimeArtifactFetcher:
+    """Create a runtime fetcher instance."""
+    return RuntimeArtifactFetcher()
+
+def auto_fetch_if_needed(token: str = None) -> Dict[str, bool]:
+    """Automatically fetch artifacts if they're needed."""
+    fetcher = create_runtime_fetcher()
+    
+    # Check what's needed
+    needs = fetcher.check_artifacts_needed()
+    
+    if not any([needs["splits"], needs["models"], needs["metadata"]]):
+        print("✅ All artifacts are already available - no fetching needed")
+        return {"splits": True, "models": True, "metadata": True}
+    
+    print(f"🔄 Auto-fetching needed artifacts (estimated size: {needs['total_size_mb']} MB)")
+    
+    # Fetch what's needed
+    results = {}
+    if needs["splits"]:
+        results["splits"] = fetcher.fetch_splits_from_hf(token=token)
+    
+    if needs["models"]:
+        results["models"] = fetcher.fetch_models_from_hf(token=token)
+    
+    if needs["metadata"]:
+        results["metadata"] = fetcher.fetch_metadata_from_hf(token=token)
+    
+    return results
+
+if __name__ == "__main__":
+    # Test the fetcher
+    fetcher = create_runtime_fetcher()
+    status = fetcher.get_fetch_status()
+    print("Current fetch status:", json.dumps(status, indent=2))