Removed lock

inference_utils.py

@@ -2,7 +2,6 @@
 Three-View-Style-Embedder - Inference Utilities
 Lazy loading for Hugging Face Spaces compatibility
 """
-import threading
 from pathlib import Path
 from typing import List, Optional, Tuple
 import numpy as np
@@ -66,7 +65,7 @@ class FaceEyeExtractor:
         self.neighbors = neighbors
         self.eye_fallback_to_face = eye_fallback_to_face
 
-        self._lock = threading.RLock()
+        # No lock needed - Gradio runs synchronously
         self._yolo_model = None
         self._yolo_device = None
         self._stride = 32
@@ -88,9 +87,9 @@ class FaceEyeExtractor:
         if self._yolo_model is not None and self._cascade is not None:
             return
 
-        with self._lock:
-            if self._yolo_model is not None and self._cascade is not None:
-                return
+        # Double-check pattern (Gradio runs synchronously)
+        if self._yolo_model is not None and self._cascade is not None:
+            return
 
             # Lazy import so app can still run if OpenCV/YOLO deps are missing.
             import sys
@@ -315,8 +314,7 @@ class FaceEyeExtractor:
 
     def extract_face(self, full_image: Image.Image) -> Optional[Image.Image]:
         rgb = np.array(full_image.convert('RGB'))
-        with self._lock:
-            boxes = self._detect_faces(rgb)
+        boxes = self._detect_faces(rgb)
         if not boxes:
             return None
 
@@ -337,9 +335,8 @@ class FaceEyeExtractor:
         return Image.fromarray(face)
 
     def extract_eye_region(self, face_image: Image.Image) -> Optional[Image.Image]:
-        # CascadeClassifier is not guaranteed to be thread-safe.
-        with self._lock:
-            self._ensure_ready()
+        # Ensure ready (Gradio runs synchronously, so thread-safety not critical)
+        self._ensure_ready()
 
         rgb_face = np.array(face_image.convert('RGB'))
         H, W = rgb_face.shape[:2]
@@ -445,7 +442,7 @@ class StyleEmbedderApp:
         
         # Model will be loaded lazily in @spaces.GPU decorated function
         self._model = None
-        self._model_lock = threading.RLock()
+        self._model_loading = False  # Flag to prevent concurrent loading
         self._embeddings_loaded = False
         self._artist_names = None
         self._embeddings = None
@@ -470,10 +467,19 @@ class StyleEmbedderApp:
         if self._model is not None:
             return
         
-        with self._model_lock:
-            if self._model is not None:
-                return
-            
+        # Simple double-check pattern (Gradio runs synchronously, so race condition unlikely)
+        if self._model_loading:
+            # Wait for loading to complete
+            import time
+            while self._model_loading and self._model is None:
+                time.sleep(0.01)
+            return
+        
+        if self._model is not None:
+            return
+        
+        self._model_loading = True
+        try:
             print("Loading model (lazy)...")
             # Load checkpoint on CPU first
             checkpoint = torch.load(self.checkpoint_path, map_location='cpu')
@@ -500,22 +506,24 @@ class StyleEmbedderApp:
             self.embedding_dim = config.model.embedding_dim
             
             print("Model loaded successfully")
+        finally:
+            self._model_loading = False
     
     def _ensure_embeddings_loaded(self):
         """Lazy load embeddings - no CUDA needed"""
         if self._embeddings_loaded:
             return
         
-        with self._model_lock:
-            if self._embeddings_loaded:
-                return
-            
-            print("Loading embeddings...")
-            data = np.load(self.embeddings_path)
-            self._artist_names = data['artist_names'].tolist()
-            self._embeddings = data['embeddings']
-            self._embeddings_loaded = True
-            print(f"Loaded {len(self._artist_names)} artist embeddings")
+        # Simple check (Gradio runs synchronously)
+        if self._embeddings_loaded:
+            return
+        
+        print("Loading embeddings...")
+        data = np.load(self.embeddings_path)
+        self._artist_names = data['artist_names'].tolist()
+        self._embeddings = data['embeddings']
+        self._embeddings_loaded = True
+        print(f"Loaded {len(self._artist_names)} artist embeddings")
     
     def preprocess_image(self, image: Optional[Image.Image]) -> Optional[torch.Tensor]:
         """이미지 전처리"""