Update handler.py

handler.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 """
-PULSE ECG Handler — Demo Parity + Style Hint + Robust Fallbacks + Debug
+PULSE ECG Handler — Demo Parity + Style Hint + Robust Fallbacks + Debug + Dynamic Vision Size
 - Demo app.py ile aynı üretim ayarları:
   do_sample=True, temperature=0.05, top_p=1.0, max_new_tokens=4096
 - Stopping: konuşma ayırıcıda (conv.sep/sep2) güvenli token-eşleşmeli kriter
@@ -11,6 +11,7 @@ PULSE ECG Handler — Demo Parity + Style Hint + Robust Fallbacks + Debug
 - Post-process: yalnızca whitespace/biçim temizliği
 - Ekler:
   * DEBUG yardımcıları (ENV: DEBUG=1)
+  * Dynamic vision size: vision tower -> processor + preprocess/fallback
   * image_processor fallback (AutoProcessor → CLIPImageProcessor)
   * process_images fallback (torchvision + CLIP norm)
   * FastAPI wrapper: /health, /info, /query, /debug
@@ -158,6 +159,53 @@ def _normalize_whitespace(text: str) -> str:
 def _postprocess_min(text: str) -> str:
     return _normalize_whitespace(text)
 
+# ====== Vision helpers (dynamic size) ======
+def get_vision_expected_size(m, default: int = 336) -> int:
+    """
+    Modelin vision tower'ının beklediği input boyutunu döndürür (örn. 336).
+    LLaVA/CLIP konfiglerinde genelde `image_size` bulunur.
+    """
+    try:
+        vt = m.get_vision_tower()
+        vt_cfg = getattr(getattr(vt, "vision_tower", vt), "config", None)
+        if vt_cfg is None:
+            return default
+        if getattr(vt_cfg, "image_size", None):
+            return int(vt_cfg.image_size)
+        vc = getattr(vt_cfg, "vision_config", None)
+        if vc and getattr(vc, "image_size", None):
+            return int(vc.image_size)
+    except Exception as e:
+        dbg(f"[get_vision_expected_size] fallback default={default} because: {e}")
+    return default
+
+def force_processor_size(proc, size: int):
+    """Processor'ın resize/crop alanlarını güvenle hedef boyuta zorlar."""
+    try:
+        # size
+        if hasattr(proc, "size"):
+            if isinstance(proc.size, dict):
+                proc.size["shortest_edge"] = size
+            else:
+                try:
+                    proc.size.shortest_edge = size  # type: ignore[attr-defined]
+                except Exception:
+                    proc.size = {"shortest_edge": size}
+        # crop_size
+        if hasattr(proc, "crop_size"):
+            if isinstance(proc.crop_size, dict):
+                proc.crop_size["height"] = size
+                proc.crop_size["width"]  = size
+            else:
+                try:
+                    proc.crop_size.height = size  # type: ignore[attr-defined]
+                    proc.crop_size.width  = size  # type: ignore[attr-defined]
+                except Exception:
+                    proc.crop_size = {"height": size, "width": size}
+        dbg(f"[processor] forced size={size}")
+    except Exception as e:
+        warn(f"[processor] force size failed: {e}")
+
 # ====== Güvenli Stop Kriteri (conv separator) ======
 class SafeKeywordsStoppingCriteria(StoppingCriteria):
     def __init__(self, keyword: str, tokenizer):
@@ -193,7 +241,7 @@ class ChatSessionManager:
     def __init__(self):
         self.chatbot = None
         self.args = None
-        self.model_path = None
+               self.model_path = None
     def init_if_needed(self, args, model_path, tokenizer, model, image_processor, context_len):
         if self.chatbot is None:
             self.args = args
@@ -263,31 +311,49 @@ def generate_response(
     device = next(chatbot.model.parameters()).device
     dtype = torch.float16
 
-    # Görüntü ön-işleme → tensör (fallback'lı)
+    # === Görüntü ön-işleme → tensör (dinamik boy) ===
+    expected_size = get_vision_expected_size(chatbot.model, default=336)
+    dbg(f"[pre] dynamic expected_size={expected_size} | processor={type(chatbot.image_processor)}")
+
+    # 3.1) Processor.preprocess varsa kullan (en stabil yol)
+    image_tensor = None
     try:
-        dbg(f"[pre] PIL image size={pil_img.size}, mode={pil_img.mode}, processor={type(chatbot.image_processor)}")
-        processed = process_images([pil_img], chatbot.image_processor, chatbot.model.config)
-        dbg("[pre] process_images ok")
-
-        if isinstance(processed, (list, tuple)) and len(processed) > 0:
-            image_tensor = processed[0]
-        elif isinstance(processed, torch.Tensor):
-            image_tensor = processed[0] if processed.ndim == 4 else processed
+        if hasattr(chatbot.image_processor, "preprocess"):
+            px = chatbot.image_processor.preprocess(pil_img, return_tensors="pt")
+            image_tensor = px.get("pixel_values", px)
+            if not isinstance(image_tensor, torch.Tensor):
+                # Bazı processor'lar nested dict döndürebilir
+                image_tensor = image_tensor["pixel_values"]
+            if image_tensor.ndim == 3:
+                image_tensor = image_tensor.unsqueeze(0)
+            image_tensor = image_tensor.to(device=device, dtype=dtype)
+            dbg(f"[pre] processor.preprocess ok → {tuple(image_tensor.shape)}")
         else:
-            raise ValueError("Image processing returned empty")
-
-        if image_tensor.ndim == 3:
-            image_tensor = image_tensor.unsqueeze(0)
-        image_tensor = image_tensor.to(device=device, dtype=dtype)
-        dbg(f"[pre] tensor shape={tuple(image_tensor.shape)} dtype={image_tensor.dtype} device={image_tensor.device}")
-    except Exception as e:
-        warn(f"[pre] process_images failed: {e} → manual CLIP preprocess fallback kullanılacak.")
+            raise AttributeError("processor has no preprocess")
+    except Exception as e_pre:
+        warn(f"[pre] processor.preprocess not used: {e_pre} → process_images denenecek…")
+        # 3.2) LLaVA'nın process_images yolu
         try:
+            processed = process_images([pil_img], chatbot.image_processor, chatbot.model.config)
+            if isinstance(processed, (list, tuple)) and len(processed) > 0:
+                image_tensor = processed[0]
+            elif isinstance(processed, torch.Tensor):
+                image_tensor = processed[0] if processed.ndim == 4 else processed
+            else:
+                raise ValueError("process_images returned empty")
+
+            if image_tensor.ndim == 3:
+                image_tensor = image_tensor.unsqueeze(0)
+            image_tensor = image_tensor.to(device=device, dtype=dtype)
+            dbg(f"[pre] process_images ok → {tuple(image_tensor.shape)}")
+        except Exception as e_proc:
+            warn(f"[pre] process_images failed: {e_proc} → manual CLIP fallback (dinamik size) kullanılacak.")
+            # 3.3) Manuel CLIP fallback (dinamik expected_size)
             from torchvision import transforms
             from torchvision.transforms import InterpolationMode
             preprocess = transforms.Compose([
-                transforms.Resize(224, interpolation=InterpolationMode.BICUBIC),
-                transforms.CenterCrop(224),
+                transforms.Resize(expected_size, interpolation=InterpolationMode.BICUBIC),
+                transforms.CenterCrop(expected_size),
                 transforms.ToTensor(),
                 transforms.Normalize(
                     mean=[0.48145466, 0.4578275, 0.40821073],
@@ -295,9 +361,10 @@ def generate_response(
                 ),
             ])
             image_tensor = preprocess(pil_img).unsqueeze(0).to(device=device, dtype=dtype)
-            dbg("[pre] manual CLIP preprocess fallback ok → tensor shape=" + str(tuple(image_tensor.shape)))
-        except Exception as ee:
-            return {"error": f"Image processing failed (and fallback failed): {ee}"}
+            dbg(f"[pre] manual fallback ok → {tuple(image_tensor.shape)}")
+
+    if image_tensor is None:
+        return {"error": "Image processing failed (no tensor produced)"}
 
     msg = (message_text or "").strip()
     msg = f"{msg}\n\n{STYLE_HINT}"
@@ -454,33 +521,51 @@ def initialize_model():
         model_.eval()
         dbg(f"[init] device={next(model_.parameters()).device}, cuda_available={torch.cuda.is_available()}")
 
-        # --- image_processor fallback zinciri ---
+        # --- vision tower beklenen image_size'ı al ---
+        expected_size = get_vision_expected_size(model_, default=336)
+        dbg(f"[init] vision expected image_size={expected_size}")
+
+        # --- image_processor fallback zinciri (model path > AutoProcessor > CLIP 224/336) ---
         try:
             if image_processor_ is None:
-                dbg("[init] image_processor None → AutoProcessor fallback deneniyor…")
+                dbg("[init] image_processor None → AutoProcessor(model_path) deneniyor…")
                 try:
                     from transformers import AutoProcessor
                     image_processor_ = AutoProcessor.from_pretrained(args.model_path)
-                    dbg("[init] image_processor: AutoProcessor.from_pretrained(model_path) ile yüklendi.")
+                    dbg("[init] image_processor: AutoProcessor.from_pretrained(model_path) yüklendi.")
                 except Exception as _e1:
-                    dbg(f"[init] AutoProcessor failed: {_e1} → CLIPImageProcessor fallback deneniyor…")
-                    from transformers import CLIPImageProcessor
-                    image_processor_ = CLIPImageProcessor.from_pretrained("openai/clip-vit-large-patch14")
-                    warn("[init] image_processor: CLIPImageProcessor(openai/clip-vit-large-patch14) fallback kullanılıyor.")
+                    dbg(f"[init] AutoProcessor(model_path) failed: {_e1}")
+                    try:
+                        from transformers import AutoProcessor
+                        clip_id = "openai/clip-vit-large-patch14-336" if expected_size >= 336 else "openai/clip-vit-large-patch14"
+                        image_processor_ = AutoProcessor.from_pretrained(clip_id)
+                        dbg(f"[init] AutoProcessor({clip_id}) yüklendi.")
+                    except Exception as _e2:
+                        from transformers import CLIPImageProcessor
+                        clip_id = "openai/clip-vit-large-patch14-336" if expected_size >= 336 else "openai/clip-vit-large-patch14"
+                        image_processor_ = CLIPImageProcessor.from_pretrained(clip_id)
+                        warn(f"[init] CLIPImageProcessor({clip_id}) fallback kullanılıyor.")
         except Exception as _e:
-            warn(f"[init] image_processor fallback failed: {_e}")
+            warn(f"[init] image_processor fallback chain failed: {_e}")
+
+        # --- processor'ın boyutlarını vision tower'a uydur ---
+        try:
+            if image_processor_ is not None:
+                force_processor_size(image_processor_, expected_size)
+        except Exception as e_ip:
+            warn(f"[init] processor size set error: {e_ip}")
 
         # --- image_processor introspection ---
         try:
             ip = image_processor_
             if ip is not None:
                 crop_sz = getattr(getattr(ip, "crop_size", None), "height", None) or getattr(ip, "crop_size", None)
-                size_sz = getattr(getattr(ip, "size", None), "height", None) or getattr(ip, "size", None)
+                size_sz = getattr(getattr(ip, "size", None), "shortest_edge", None) or getattr(ip, "size", None)
                 dbg(f"[init] image_processor crop_size={crop_sz} size={size_sz} class={ip.__class__.__name__}")
             else:
                 warn("[init] image_processor yine None (fallback da başarısız).")
-        except Exception as e_ip:
-            warn(f"[init] image_processor inspect error: {e_ip}")
+        except Exception as e_ip2:
+            warn(f"[init] image_processor inspect error: {e_ip2}")
 
         globals()["tokenizer"] = tokenizer_
         globals()["model"] = model_
@@ -510,7 +595,7 @@ class EndpointHandler:
         return get_model_info()
 
 if __name__ == "__main__":
-    print("Handler ready (Demo Parity + Style Hint + whitespace post-process + fallbacks + debug). Use `EndpointHandler` or `query`.")
+    print("Handler ready (Demo Parity + Style Hint + whitespace post-process + dynamic size + fallbacks + debug). Use `EndpointHandler` or `query`.")
 
 # ===================== Minimal FastAPI Wrapper =====================
 try:
@@ -567,9 +652,14 @@ if FASTAPI_AVAILABLE:
             ip = image_processor
             ip_cls = ip.__class__.__name__ if ip else None
             crop_sz = getattr(getattr(ip, "crop_size", None), "height", None) or getattr(ip, "crop_size", None)
-            size_sz = getattr(getattr(ip, "size", None), "height", None) or getattr(ip, "size", None)
+            size_short = getattr(getattr(ip, "size", None), "shortest_edge", None) or getattr(ip, "size", None)
+        except Exception:
+            ip_cls, crop_sz, size_short = None, None, None
+
+        try:
+            ve = get_vision_expected_size(model, default=None) if model else None
         except Exception:
-            ip_cls, crop_sz, size_sz = None, None, None
+            ve = None
 
         return {
             "debug": bool(DEBUG),
@@ -579,7 +669,8 @@ if FASTAPI_AVAILABLE:
             "context_len": context_len,
             "image_processor_class": ip_cls,
             "image_processor_crop_size": crop_sz,
-            "image_processor_size": size_sz,
+            "image_processor_size": {"shortest_edge": size_short},
+            "vision_expected_image_size": ve,
             "model_path": args.model_path if args else None,
         }