Update app.py

app.py

@@ -112,53 +112,62 @@ class ModelManager:
         return self._breed_model
 
     def _initialize_enhanced_system(self):
-        """Initialize enhanced multi-dimensional recommendation system (CPU-only load)"""
+        """Initialize enhanced multi-dimensional recommendation system"""
         if ModelManager._enhanced_system_initialized:
             return
-    
+
         try:
-            # Always load SBERT on CPU in the main process to avoid CUDA init
-            try:
-                model_options = [
-                    'sentence-transformers/all-MiniLM-L6-v2',
-                    'sentence-transformers/all-mpnet-base-v2',
-                    'sentence-transformers/all-MiniLM-L12-v2'
-                ]
-                self._sbert_model = None
-                for name in model_options:
-                    try:
-                        # CPU 載入，禁止在主行程碰 CUDA
-                        self._sbert_model = SentenceTransformer(name, device='cpu')
-                        print(f"Initialized SBERT model on CPU: {name}")
-                        break
-                    except Exception as e:
-                        print(f"Failed to load SBERT model {name}: {e}")
-                        continue
-    
-                if self._sbert_model is None:
-                    print("All SBERT models failed; fallback to keyword-only analysis")
-    
-            except Exception as e:
-                print(f"SBERT initialization failed: {e}")
-                self._sbert_model = None
-    
+            # Defer SBERT model loading until needed in GPU context
+            # This prevents CUDA initialization issues in ZeroGPU environment
+            self._sbert_model = None  # Will be loaded lazily
+            self._sbert_loading_attempted = False
+            
             ModelManager._enhanced_system_initialized = True
-            print("Enhanced recommendation system initialization completed (CPU)")
-    
+            print("Enhanced recommendation system initialized (SBERT loading deferred)")
+
         except ImportError as e:
-            print(f"Enhanced modules not available: {e}")
-            ModelManager._enhanced_system_initialized = True
+            print(f"Enhanced modules not available: {str(e)}")
+            ModelManager._enhanced_system_initialized = True  # Mark as attempted
         except Exception as e:
-            print(f"Enhanced system initialization failed: {e}")
+            print(f"Enhanced system initialization failed: {str(e)}")
             print(traceback.format_exc())
-            ModelManager._enhanced_system_initialized = True
+            ModelManager._enhanced_system_initialized = True  # Mark as attempted
+
+    def _load_sbert_model_if_needed(self):
+        """Load SBERT model in GPU context if not already loaded"""
+        if self._sbert_model is not None or self._sbert_loading_attempted:
+            return self._sbert_model
+            
+        try:
+            # Initialize SBERT model for semantic analysis
+            print("Loading SBERT model in GPU context...")
+            model_name = 'all-MiniLM-L6-v2'
+            fallback_models = ['all-mpnet-base-v2', 'all-MiniLM-L12-v2']
+
+            for model_name_attempt in [model_name] + fallback_models:
+                try:
+                    self._sbert_model = SentenceTransformer(model_name_attempt, device='cuda' if torch.cuda.is_available() else 'cpu')
+                    print(f"SBERT model {model_name_attempt} loaded successfully in GPU context")
+                    return self._sbert_model
+                except Exception as e:
+                    print(f"Failed to load SBERT model {model_name_attempt}: {str(e)}")
+                    continue
+
+            print("All SBERT models failed to load, enhanced system will use keyword-only analysis")
+            return None
+
+        except Exception as e:
+            print(f"SBERT initialization failed: {str(e)}")
+            return None
+        finally:
+            self._sbert_loading_attempted = True
 
     @property
     def sbert_model(self):
         """Get SBERT model for semantic analysis"""
         if not ModelManager._enhanced_system_initialized:
             self._initialize_enhanced_system()
-        return self._sbert_model
+        return self._load_sbert_model_if_needed()
 
     @property
     def config_manager(self):