added logs

app.py

@@ -7,6 +7,9 @@ import gc
 from datetime import datetime
 from pathlib import Path
 
+# Disable torch dynamo globally to avoid ConstantVariable errors
+torch._dynamo.config.suppress_errors = True
+
 # Initialize directories
 DATA_DIR = Path("/data") if os.path.exists("/data") else Path("./data")
 DATA_DIR.mkdir(exist_ok=True)

models/image_generator.py

@@ -5,6 +5,9 @@ import numpy as np
 from typing import Optional, List, Union
 import gc
 
+# Disable torch dynamo to avoid ConstantVariable errors
+torch._dynamo.config.suppress_errors = True
+
 class OmniGenImageGenerator:
     """Image generation using OmniGen2 model"""
     
@@ -64,12 +67,8 @@ class OmniGenImageGenerator:
                 else:
                     self.pipeline = self.pipeline.to(self.device)
                 
-                # Compile for faster inference (if available)
-                if hasattr(torch, 'compile') and self.device == "cuda":
-                    try:
-                        self.pipeline.unet = torch.compile(self.pipeline.unet, mode="reduce-overhead")
-                    except:
-                        pass  # Compilation is optional
+                # Disable torch.compile to avoid dynamo issues that cause ConstantVariable errors
+                print("Skipping torch.compile to avoid dynamo compatibility issues")
                 
             except Exception as e:
                 print(f"Failed to load image generation model: {e}")

models/model_3d_generator.py

@@ -6,12 +6,21 @@ import tempfile
 from typing import Union, Optional, Dict, Any
 from pathlib import Path
 import os
+import logging
+
+# Set up detailed logging for 3D generation
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
 class Hunyuan3DGenerator:
     """3D model generation using Hunyuan3D-2.1"""
     
     def __init__(self, device: str = "cuda"):
+        logger.info(f"🔧 Initializing Hunyuan3DGenerator with device: {device}")
+        
         self.device = device if torch.cuda.is_available() else "cpu"
+        logger.info(f"🔧 Final device selection: {self.device}")
+        
         self.model = None
         self.preprocessor = None
         
@@ -25,52 +34,106 @@ class Hunyuan3DGenerator:
         self.resolution = 256  # 3D resolution
         
         # Use lite model for low VRAM
-        self.use_lite = self.device == "cpu" or not self._check_vram()
+        vram_check = self._check_vram()
+        self.use_lite = self.device == "cpu" or not vram_check
+        
+        logger.info(f"🔧 VRAM check result: {vram_check}, using lite model: {self.use_lite}")
+        logger.info(f"🔧 Model ID to use: {self.lite_model_id if self.use_lite else self.model_id}")
     
     def _check_vram(self) -> bool:
         """Check if we have enough VRAM for full model"""
+        logger.info("🔍 Checking VRAM availability...")
+        
         if not torch.cuda.is_available():
+            logger.info("❌ CUDA not available")
             return False
         
         try:
             vram = torch.cuda.get_device_properties(0).total_memory
+            vram_gb = vram / (1024 * 1024 * 1024)
+            logger.info(f"🔍 Available VRAM: {vram_gb:.2f} GB")
+            
             # Need at least 12GB for full model
-            return vram > 12 * 1024 * 1024 * 1024
-        except:
+            has_enough = vram > 12 * 1024 * 1024 * 1024
+            logger.info(f"🔍 Has enough VRAM (>12GB): {has_enough}")
+            return has_enough
+        except Exception as e:
+            logger.error(f"❌ Error checking VRAM: {e}")
             return False
     
     def load_model(self):
         """Lazy load the 3D generation model"""
         if self.model is None:
+            logger.info("🚀 Starting 3D model loading process...")
+            
             try:
                 # Import Hunyuan3D components
+                logger.info("📦 Importing transformers components...")
                 from transformers import AutoModel, AutoProcessor
                 
                 model_id = self.lite_model_id if self.use_lite else self.model_id
+                logger.info(f"📦 Loading model: {model_id}")
                 
                 # Load preprocessor
+                logger.info("📦 Loading preprocessor...")
                 self.preprocessor = AutoProcessor.from_pretrained(model_id)
+                logger.info("✅ Preprocessor loaded successfully")
                 
                 # Load model with optimizations
                 torch_dtype = torch.float16 if self.device == "cuda" else torch.float32
+                logger.info(f"📦 Using torch dtype: {torch_dtype}")
                 
+                # Disable torch.compile to avoid dynamo issues
+                logger.info("📦 Disabling torch compile to avoid dynamo issues...")
+                torch._dynamo.config.suppress_errors = True
+                
+                logger.info("📦 Loading 3D model with safe device handling...")
                 self.model = AutoModel.from_pretrained(
                     model_id,
                     torch_dtype=torch_dtype,
                     low_cpu_mem_usage=True,
-                    device_map="auto" if self.device == "cuda" else None,
+                    device_map=None,  # Avoid auto device mapping to prevent meta tensor issues
                     trust_remote_code=True
                 )
+                logger.info("✅ 3D model loaded from pretrained")
                 
-                if self.device == "cpu":
-                    self.model = self.model.to(self.device)
+                # Safe device movement
+                logger.info(f"📦 Moving model to device: {self.device}")
+                try:
+                    if hasattr(self.model, 'to_empty'):
+                        # Use to_empty for meta tensors
+                        logger.info("📦 Using to_empty() for safe device movement...")
+                        self.model = self.model.to_empty(device=self.device, dtype=torch_dtype)
+                    else:
+                        # Standard device movement
+                        logger.info("📦 Using standard to() for device movement...")
+                        self.model = self.model.to(self.device, dtype=torch_dtype)
+                    logger.info("✅ Model successfully moved to device")
+                    
+                except RuntimeError as device_error:
+                    logger.error(f"❌ Device movement failed: {device_error}")
+                    if "meta tensor" in str(device_error):
+                        logger.info("🔄 Attempting CPU fallback for meta tensor issue...")
+                        self.device = "cpu"
+                        self.model = self.model.to("cpu")
+                        logger.info("✅ Fallback to CPU successful")
+                    else:
+                        raise device_error
                 
-                # Enable optimizations
+                # Enable optimizations safely
+                logger.info("📦 Applying model optimizations...")
                 if hasattr(self.model, 'enable_attention_slicing'):
                     self.model.enable_attention_slicing()
+                    logger.info("✅ Attention slicing enabled")
+                else:
+                    logger.info("⚠️ Attention slicing not available")
+                
+                logger.info("🎉 3D model loading completed successfully!")
                 
             except Exception as e:
-                print(f"Failed to load Hunyuan3D model: {e}")
+                logger.error(f"❌ Failed to load Hunyuan3D model: {e}")
+                logger.error(f"❌ Error type: {type(e).__name__}")
+                logger.info("🔄 Falling back to simple 3D generation...")
                 # Model loading failed, will use fallback
                 self.model = "fallback"
     
@@ -80,55 +143,113 @@ class Hunyuan3DGenerator:
                    texture_resolution: int = 1024) -> Union[str, trimesh.Trimesh]:
         """Convert 2D image to 3D model"""
         
+        logger.info("🎯 Starting image-to-3D conversion process...")
+        logger.info(f"🎯 Input type: {type(image)}")
+        logger.info(f"🎯 Remove background: {remove_background}")
+        logger.info(f"🎯 Texture resolution: {texture_resolution}")
+        
         try:
             # Load model if needed
+            logger.info("🔍 Checking if model needs loading...")
             if self.model is None:
+                logger.info("📦 Model not loaded, initiating loading...")
                 self.load_model()
+            else:
+                logger.info("✅ Model already loaded")
             
             # If model loading failed, use fallback
             if self.model == "fallback":
+                logger.info("🔄 Using fallback 3D generation...")
                 return self._generate_fallback_3d(image)
             
             # Prepare image
+            logger.info("🖼️ Preparing input image...")
             if isinstance(image, str):
+                logger.info(f"🖼️ Loading image from path: {image}")
                 image = Image.open(image)
             elif isinstance(image, np.ndarray):
+                logger.info("🖼️ Converting numpy array to PIL Image")
                 image = Image.fromarray(image)
+            else:
+                logger.info("🖼️ Input is already PIL Image")
             
             # Ensure RGB
+            logger.info(f"🖼️ Image mode: {image.mode}")
             if image.mode != 'RGB':
+                logger.info("🖼️ Converting image to RGB mode")
                 image = image.convert('RGB')
             
+            logger.info(f"🖼️ Final image size: {image.size}")
+            
             # Resize for processing
+            logger.info("🖼️ Resizing image for processing (512x512)...")
             image = image.resize((512, 512), Image.Resampling.LANCZOS)
+            logger.info("✅ Image resized successfully")
             
             # Remove background if requested
             if remove_background:
-                image = self._remove_background(image)
+                logger.info("🎭 Removing background from image...")
+                try:
+                    image = self._remove_background(image)
+                    logger.info("✅ Background removal completed")
+                except Exception as bg_error:
+                    logger.error(f"❌ Background removal failed: {bg_error}")
+                    logger.info("🔄 Continuing with original image...")
             
             # Process with model
+            logger.info("🧠 Starting model inference...")
             with torch.no_grad():
-                # Preprocess image
-                inputs = self.preprocessor(images=image, return_tensors="pt").to(self.device)
-                
-                # Generate 3D
-                outputs = self.model.generate(
-                    **inputs,
-                    num_inference_steps=self.num_inference_steps,
-                    guidance_scale=self.guidance_scale,
-                    texture_resolution=texture_resolution
-                )
-                
-                # Extract mesh
-                mesh = self._extract_mesh(outputs)
+                try:
+                    # Preprocess image
+                    logger.info("🔄 Preprocessing image for model...")
+                    inputs = self.preprocessor(images=image, return_tensors="pt")
+                    logger.info(f"🔄 Input tensor shape: {inputs['pixel_values'].shape if 'pixel_values' in inputs else 'unknown'}")
+                    
+                    # Move inputs to device safely
+                    logger.info(f"🔄 Moving inputs to device: {self.device}")
+                    try:
+                        # Avoid device-related dynamo issues
+                        device_str = str(self.device)  # Convert to string to avoid torch.device in dynamo
+                        inputs = {k: v.to(device_str) for k, v in inputs.items() if hasattr(v, 'to')}
+                        logger.info("✅ Inputs moved to device successfully")
+                    except Exception as device_error:
+                        logger.error(f"❌ Failed to move inputs to device: {device_error}")
+                        raise device_error
+                    
+                    # Generate 3D
+                    logger.info("🚀 Starting 3D generation inference...")
+                    logger.info(f"🚀 Parameters: steps={self.num_inference_steps}, guidance={self.guidance_scale}")
+                    
+                    outputs = self.model.generate(
+                        **inputs,
+                        num_inference_steps=self.num_inference_steps,
+                        guidance_scale=self.guidance_scale,
+                        texture_resolution=texture_resolution
+                    )
+                    logger.info("✅ 3D generation completed successfully")
+                    
+                    # Extract mesh
+                    logger.info("🔧 Extracting mesh from model outputs...")
+                    mesh = self._extract_mesh(outputs)
+                    logger.info("✅ Mesh extraction completed")
+                    
+                except Exception as inference_error:
+                    logger.error(f"❌ Model inference failed: {inference_error}")
+                    logger.error(f"❌ Inference error type: {type(inference_error).__name__}")
+                    raise inference_error
             
             # Save mesh
+            logger.info("💾 Saving generated mesh...")
             mesh_path = self._save_mesh(mesh)
+            logger.info(f"✅ Mesh saved to: {mesh_path}")
             
+            logger.info("🎉 3D generation process completed successfully!")
             return mesh_path
             
         except Exception as e:
-            print(f"3D generation error: {e}")
+            logger.error(f"❌ 3D generation error: {e}")
+            logger.error(f"❌ Error type: {type(e).__name__}")
+            logger.info("🔄 Falling back to simple 3D generation...")
             return self._generate_fallback_3d(image)
     
     def _remove_background(self, image: Image.Image) -> Image.Image: