Upload 2 files

generator.py

@@ -149,20 +149,29 @@ class RetroArtConverter:
         """Generate depth map using Zoe Depth"""
         if self.zoe_depth is not None:
             try:
-                # Ensure clean PIL Image
+                # Ensure clean PIL Image with proper dimensions
                 if image.mode != 'RGB':
                     image = image.convert('RGB')
                 
-                # Get dimensions and ensure they're Python ints
+                # Get dimensions and ensure they're Python ints (not numpy ints)
                 width, height = image.size
                 width, height = int(width), int(height)
                 
-                # Create a fresh image to avoid numpy type issues
-                image_array = np.array(image)
-                clean_image = Image.fromarray(image_array.astype(np.uint8))
+                # Resize to dimensions ZoeDetector expects (multiples of 32 work best)
+                # This avoids numpy type issues in the detector
+                target_width = (width // 32) * 32
+                target_height = (height // 32) * 32
+                
+                if target_width != width or target_height != height:
+                    image = image.resize((target_width, target_height), Image.LANCZOS)
+                
+                # Use Zoe detector - now with safe dimensions
+                depth_image = self.zoe_depth(image)
+                
+                # Resize back to original if needed
+                if depth_image.size != (width, height):
+                    depth_image = depth_image.resize((width, height), Image.LANCZOS)
                 
-                # Use Zoe detector
-                depth_image = self.zoe_depth(clean_image)
                 return depth_image
             except Exception as e:
                 print(f"Warning: ZoeDetector failed ({e}), falling back to grayscale depth")
@@ -563,14 +572,50 @@ class RetroArtConverter:
                 conditioning = self.compel(prompt)
                 negative_conditioning = self.compel(negative_prompt)
                 
-                pipe_kwargs["prompt_embeds"] = conditioning[0]
-                pipe_kwargs["pooled_prompt_embeds"] = conditioning[1]
-                pipe_kwargs["negative_prompt_embeds"] = negative_conditioning[0]
-                pipe_kwargs["negative_pooled_prompt_embeds"] = negative_conditioning[1]
+                prompt_embeds = conditioning[0]
+                pooled_prompt_embeds = conditioning[1]
+                negative_prompt_embeds = negative_conditioning[0]
+                negative_pooled_prompt_embeds = negative_conditioning[1]
+                
+                # Handle token length mismatch by padding/truncating to 77 tokens (SDXL standard)
+                target_length = 77
+                
+                if prompt_embeds.shape[1] != target_length or negative_prompt_embeds.shape[1] != target_length:
+                    print(f"Adjusting token lengths: pos={prompt_embeds.shape[1]}, neg={negative_prompt_embeds.shape[1]} -> {target_length}")
+                    
+                    # Truncate or pad to target length
+                    if prompt_embeds.shape[1] > target_length:
+                        prompt_embeds = prompt_embeds[:, :target_length, :]
+                    elif prompt_embeds.shape[1] < target_length:
+                        padding = torch.zeros(
+                            prompt_embeds.shape[0], 
+                            target_length - prompt_embeds.shape[1], 
+                            prompt_embeds.shape[2],
+                            dtype=prompt_embeds.dtype,
+                            device=prompt_embeds.device
+                        )
+                        prompt_embeds = torch.cat([prompt_embeds, padding], dim=1)
+                    
+                    if negative_prompt_embeds.shape[1] > target_length:
+                        negative_prompt_embeds = negative_prompt_embeds[:, :target_length, :]
+                    elif negative_prompt_embeds.shape[1] < target_length:
+                        padding = torch.zeros(
+                            negative_prompt_embeds.shape[0],
+                            target_length - negative_prompt_embeds.shape[1],
+                            negative_prompt_embeds.shape[2],
+                            dtype=negative_prompt_embeds.dtype,
+                            device=negative_prompt_embeds.device
+                        )
+                        negative_prompt_embeds = torch.cat([negative_prompt_embeds, padding], dim=1)
+                
+                pipe_kwargs["prompt_embeds"] = prompt_embeds
+                pipe_kwargs["pooled_prompt_embeds"] = pooled_prompt_embeds
+                pipe_kwargs["negative_prompt_embeds"] = negative_prompt_embeds
+                pipe_kwargs["negative_pooled_prompt_embeds"] = negative_pooled_prompt_embeds
                 
                 print("[OK] Using Compel-encoded prompts")
             except Exception as e:
-                print(f"Compel encoding failed, using standard prompts: {e}")
+                print(f"Compel encoding failed: {e}, using standard prompts")
                 pipe_kwargs["prompt"] = prompt
                 pipe_kwargs["negative_prompt"] = negative_prompt
         else:

models.py

@@ -160,12 +160,12 @@ def load_sdxl_pipeline(controlnets):
 
 
 def load_lora(pipe):
-    """Load LORA from HuggingFace Hub."""
+    """Load LORA from HuggingFace Hub with specific adapter name."""
     print("Loading LORA (retroart) from HuggingFace Hub...")
     try:
         lora_path = download_model_with_retry(MODEL_REPO, MODEL_FILES['lora'])
-        pipe.load_lora_weights(lora_path)
-        print(f"  [OK] LORA loaded successfully")
+        pipe.load_lora_weights(lora_path, adapter_name="retroart")
+        print(f"  [OK] LORA loaded successfully as 'retroart' adapter")
         return True
     except Exception as e:
         print(f"  [WARNING] Could not load LORA: {e}")