Fixed 1 million more errors

app.py

@@ -272,15 +272,15 @@ def _background_bootstrap():
             BOOT_STATUS = "training-resnet"
             subprocess.run([
                 "python", "train_resnet.py", "--data_root", ds_root, "--epochs", "3",
-                "--batch_size", "8", "--lr", "1e-3", "--early_stopping_patience", "3",
+                "--batch_size", "4", "--lr", "1e-3", "--early_stopping_patience", "3",
                 "--out", os.path.join(export_dir, "resnet_item_embedder.pth")
             ], check=False)
         if not os.path.exists(vit_ckpt):
             BOOT_STATUS = "training-vit"
             subprocess.run([
                 "python", "train_vit_triplet.py", "--data_root", ds_root, "--epochs", "3",
-                "--batch_size", "8", "--lr", "5e-4", "--early_stopping_patience", "3",
-                "--export", os.path.join(export_dir, "vit_outfit_model.pth")
+                "--batch_size", "4", "--lr", "5e-4", "--early_stopping_patience", "3",
+                "--skip_validation", "--max_samples", "200", "--export", os.path.join(export_dir, "vit_outfit_model.pth")
             ], check=False)
         service.reload_models()
         BOOT_STATUS = "ready"
@@ -445,7 +445,7 @@ def start_training_advanced(
     resnet_backbone: str, resnet_use_pretrained: bool, resnet_dropout: float,
     
     # ViT parameters
-    vit_epochs: int, vit_batch_size: int, vit_lr: float, vit_optimizer: str,
+    vit_epochs: int, vit_batch_size: int, vit_max_samples: int, vit_lr: float, vit_optimizer: str,
     vit_weight_decay: float, vit_triplet_margin: float, vit_embedding_dim: int,
     vit_num_layers: int, vit_num_heads: int, vit_ff_multiplier: int, vit_dropout: float,
     
@@ -599,6 +599,7 @@ def start_training_advanced(
                 "--data_root", DATASET_ROOT,
                 "--epochs", str(vit_epochs),
                 "--batch_size", str(vit_batch_size),
+                "--max_samples", str(vit_max_samples),
                 "--lr", str(vit_lr),
                 "--weight_decay", str(vit_weight_decay),
                 "--triplet_margin", str(vit_triplet_margin),
@@ -682,7 +683,7 @@ def start_training_simple(dataset_size: str, res_epochs: int, vit_epochs: int):
             log_message += f"\n🚀 Starting ResNet training on {dataset_size} samples...\n"
             resnet_result = subprocess.run([
                 "python", "train_resnet.py", "--data_root", DATASET_ROOT, "--epochs", str(res_epochs),
-                "--batch_size", "8", "--lr", "1e-3", "--early_stopping_patience", "3",
+                "--batch_size", "4", "--lr", "1e-3", "--early_stopping_patience", "3",
                 "--out", os.path.join(export_dir, "resnet_item_embedder.pth")
             ] + dataset_args, capture_output=True, text=True, check=False)
             
@@ -709,8 +710,8 @@ def start_training_simple(dataset_size: str, res_epochs: int, vit_epochs: int):
             log_message += f"\n🚀 Starting ViT training on {dataset_size} samples...\n"
             vit_result = subprocess.run([
                 "python", "train_vit_triplet.py", "--data_root", DATASET_ROOT, "--epochs", str(vit_epochs),
-                "--batch_size", "8", "--lr", "5e-4", "--early_stopping_patience", "3",
-                "--export", os.path.join(export_dir, "vit_outfit_model.pth")
+                "--batch_size", "4", "--lr", "5e-4", "--early_stopping_patience", "3",
+                "--skip_validation", "--max_samples", "200", "--export", os.path.join(export_dir, "vit_outfit_model.pth")
             ] + dataset_args, capture_output=True, text=True, check=False)
             
             if vit_result.returncode == 0:
@@ -876,7 +877,7 @@ with gr.Blocks(fill_height=True, title="Dressify - Advanced Outfit Recommendatio
                 
                 # Training parameters
                 resnet_epochs = gr.Slider(1, 100, value=20, step=1, label="Epochs")
-                resnet_batch_size = gr.Slider(8, 128, value=8, step=8, label="Batch Size")
+                resnet_batch_size = gr.Slider(4, 128, value=4, step=4, label="Batch Size")
                 resnet_lr = gr.Slider(1e-5, 1e-2, value=1e-3, step=1e-5, label="Learning Rate")
                 resnet_optimizer = gr.Dropdown(
                     choices=["adamw", "adam", "sgd", "rmsprop"], 
@@ -898,7 +899,8 @@ with gr.Blocks(fill_height=True, title="Dressify - Advanced Outfit Recommendatio
                 
                 # Training parameters
                 vit_epochs = gr.Slider(1, 100, value=30, step=1, label="Epochs")
-                vit_batch_size = gr.Slider(4, 64, value=8, step=4, label="Batch Size")
+                vit_batch_size = gr.Slider(2, 64, value=4, step=2, label="Batch Size")
+                vit_max_samples = gr.Slider(100, 5000, value=500, step=100, label="Max Training Samples")
                 vit_lr = gr.Slider(1e-5, 1e-2, value=5e-4, step=1e-5, label="Learning Rate")
                 vit_optimizer = gr.Dropdown(
                     choices=["adamw", "adam", "sgd", "rmsprop"], 
@@ -978,7 +980,7 @@ with gr.Blocks(fill_height=True, title="Dressify - Advanced Outfit Recommendatio
                 resnet_backbone, resnet_use_pretrained, resnet_dropout,
                 
                 # ViT parameters
-                vit_epochs, vit_batch_size, vit_lr, vit_optimizer,
+                vit_epochs, vit_batch_size, vit_max_samples, vit_lr, vit_optimizer,
                 vit_weight_decay, vit_triplet_margin, vit_embedding_dim,
                 vit_num_layers, vit_num_heads, vit_ff_multiplier, vit_dropout,
                 

train_vit_triplet.py

@@ -23,12 +23,14 @@ def parse_args() -> argparse.Namespace:
     p = argparse.ArgumentParser()
     p.add_argument("--data_root", type=str, default=os.getenv("POLYVORE_ROOT", "/home/user/app/data/Polyvore"))
     p.add_argument("--epochs", type=int, default=50)
-    p.add_argument("--batch_size", type=int, default=16)
+    p.add_argument("--batch_size", type=int, default=4)
     p.add_argument("--lr", type=float, default=5e-4)
     p.add_argument("--embedding_dim", type=int, default=512)
     p.add_argument("--triplet_margin", type=float, default=0.3)
     p.add_argument("--export", type=str, default="models/exports/vit_outfit_model.pth")
     p.add_argument("--eval_every", type=int, default=1)
+    p.add_argument("--skip_validation", action="store_true", help="Skip validation for faster training")
+    p.add_argument("--max_samples", type=int, default=500, help="Maximum number of training samples (for faster testing)")
     p.add_argument("--early_stopping_patience", type=int, default=10, help="Early stopping patience")
     p.add_argument("--min_delta", type=float, default=1e-4, help="Minimum change to qualify as improvement")
     return p.parse_args()
@@ -82,7 +84,14 @@ def main() -> None:
 
     try:
         dataset = PolyvoreOutfitTripletDataset(args.data_root, split="train")
-        print(f"📊 Dataset loaded: {len(dataset)} samples")
+        # Limit dataset size for faster training/testing
+        max_samples = min(len(dataset), args.max_samples)
+        print(f"🔍 Debug: Original dataset size: {len(dataset)}, max_samples: {args.max_samples}")
+        if len(dataset) > max_samples:
+            dataset.samples = dataset.samples[:max_samples]
+            print(f"📊 Dataset limited to {max_samples} samples for faster training")
+        else:
+            print(f"📊 Dataset loaded: {len(dataset)} samples (no limiting needed)")
     except Exception as e:
         print(f"❌ Failed to load dataset: {e}")
         return
@@ -172,20 +181,25 @@ def main() -> None:
 
         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
+        # Fast validation with limited samples to prevent hanging
         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:
+        if not args.skip_validation and os.path.exists(val_path) and (epoch + 1) % args.eval_every == 0:
             try:
+                print(f"  🔍 Starting validation (limited to 50 samples for speed)...")
                 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)
+                # Limit validation to first 50 samples to prevent hanging
+                val_samples = val_ds.samples[:50]
+                val_ds.samples = val_samples
+                val_loader = DataLoader(val_ds, batch_size=min(args.batch_size, 8), shuffle=False, num_workers=0, collate_fn=lambda x: x)
                 model.eval()
                 losses = []
                 
                 with torch.no_grad():
-                    for vbatch in val_loader:
+                    for i, vbatch in enumerate(val_loader):
+                        if i >= 10:  # Limit to 10 batches max for speed
+                            break
                         anchor_tokens = []
                         positive_tokens = []
                         negative_tokens = []
@@ -206,10 +220,11 @@ def main() -> None:
                         losses.append(l)
                 
                 val_loss = sum(losses) / max(1, len(losses))
-                print(f"  📊 Validation loss: {val_loss:.4f}")
+                print(f"  📊 Validation loss: {val_loss:.4f} (from {len(losses)} batches)")
                 
             except Exception as e:
                 print(f"  ⚠️  Validation failed: {e}")
+                val_loss = None
 
         out_path = args.export
         if not out_path.startswith("models/"):

utils/hf_utils.py

@@ -10,10 +10,24 @@ class HFModelManager:
     """Utility class for managing model checkpoints on Hugging Face Hub."""
     
     def __init__(self, token: Optional[str] = None, username: Optional[str] = None):
-        self.api = HfApi(token=token or os.getenv("HF_TOKEN"))
+        self.token = token or os.getenv("HF_TOKEN")
         self.username = username or os.getenv("HF_USERNAME")
+        
+        if not self.token:
+            raise ValueError("HF_TOKEN environment variable must be set")
         if not self.username:
             raise ValueError("HF_USERNAME environment variable must be set")
+            
+        # Set up authentication
+        try:
+            from huggingface_hub import login
+            login(token=self.token, write_permission=True)
+            print("✅ Hugging Face authentication successful")
+        except Exception as e:
+            print(f"⚠️ Hugging Face authentication failed: {e}")
+            raise
+            
+        self.api = HfApi(token=self.token)
     
     def create_model_repo(self, model_name: str, private: bool = False) -> str:
         """Create a new model repository."""