Update handler.py

handler.py

@@ -1,12 +1,10 @@
 # -*- coding: utf-8 -*-
-# handler.py — Rapid_ECG / PULSE-7B için HF Inference Endpoints custom handler
-# - LLAVA otomatik kurulum (requirements'a yazmak zorunda değilsin)
-# - EndpointHandler.load()/__call__(inputs) sözleşmesi
-# - {"inputs": {...}} ve düz payload formatlarını destekler
-# - URL / base64 / yerel yol görüntü girişi
-# - <image> sentineli (+ IM_START/END gerekiyorsa)
-# - attention_mask fix + echo-fix
-# - CUDA: bf16/fp16, CPU: fp32
+# handler.py — Rapid_ECG / PULSE-7B — DEBUG'li sürüm
+# - LLAVA otomatik kurulum (tag sabit)
+# - HF Endpoint sözleşmesi (EndpointHandler(model_dir).load().__call__(inputs))
+# - {"inputs": {...}} sarmalamasını da destekler
+# - Her kritik adımda kapsamlı print(DEBUG) ekli
+
 import os
 import io
 import sys
@@ -22,18 +20,19 @@ import requests
 def _ensure_llava(tag: str = "v1.2.0"):
     try:
         import llava  # noqa
+        print(f"[DEBUG] LLaVA already available.")
         return
     except ImportError:
-        print(f"⚡ LLaVA bulunamadı; kuruluyor (tag={tag})...")
+        print(f"[DEBUG] LLaVA not found; installing (tag={tag}) ...")
         subprocess.check_call([
             sys.executable, "-m", "pip", "install",
             f"git+https://github.com/haotian-liu/LLaVA@{tag}#egg=llava"
         ])
-        print("✅ LLaVA kuruldu.")
+        print("[DEBUG] LLaVA installed.")
 
 _ensure_llava("v1.2.0")
 
-# Artık llava import edebiliriz
+# LLaVA importları
 from llava.conversation import conv_templates
 from llava.constants import (
     DEFAULT_IMAGE_TOKEN,
@@ -46,9 +45,11 @@ from llava.mm_utils import process_images, tokenizer_image_token
 # (gerekirse fallback için)
 try:
     from transformers import AutoProcessor, CLIPImageProcessor  # type: ignore
-except Exception:
+    print("[DEBUG] transformers AutoProcessor/CLIPImageProcessor available.")
+except Exception as e:
     AutoProcessor = None
     CLIPImageProcessor = None
+    print(f"[DEBUG] transformers processors import failed: {e}")
 
 # ---------- yardımcılar ----------
 def _get_env(name: str, default: Optional[str] = None) -> Optional[str]:
@@ -56,16 +57,21 @@ def _get_env(name: str, default: Optional[str] = None) -> Optional[str]:
     return v if v not in (None, "") else default
 
 def _pick_device() -> torch.device:
+    dev = torch.device("cpu")
     if torch.cuda.is_available():
-        return torch.device("cuda")
-    if torch.backends.mps.is_available():
-        return torch.device("mps")
-    return torch.device("cpu")
+        dev = torch.device("cuda")
+    elif torch.backends.mps.is_available():
+        dev = torch.device("mps")
+    print(f"[DEBUG] pick_device -> {dev}")
+    return dev
 
 def _pick_dtype(device: torch.device):
     if device.type == "cuda":
-        return torch.bfloat16 if torch.cuda.is_bf16_supported() else torch.float16
-    return torch.float32
+        dt = torch.bfloat16 if torch.cuda.is_bf16_supported() else torch.float16
+    else:
+        dt = torch.float32
+    print(f"[DEBUG] pick_dtype({device}) -> {dt}")
+    return dt
 
 def _is_probably_base64(s: str) -> bool:
     s = s.strip()
@@ -75,33 +81,44 @@ def _is_probably_base64(s: str) -> bool:
     return len(s) % 4 == 0 and all(c in allowed for c in s)
 
 def _load_image_from_any(image_input: Any) -> Image.Image:
-    """PIL.Image | path | url | data-url | raw base64 | bytes | file-like"""
+    print(f"[DEBUG] _load_image_from_any type={type(image_input)}")
     if isinstance(image_input, Image.Image):
+        print("[DEBUG] image_input is PIL.Image")
         return image_input.convert("RGB")
     if isinstance(image_input, (bytes, bytearray)):
+        print("[DEBUG] image_input is raw bytes")
         return Image.open(io.BytesIO(image_input)).convert("RGB")
     if hasattr(image_input, "read"):
+        print("[DEBUG] image_input is file-like")
         return Image.open(image_input).convert("RGB")
     if isinstance(image_input, str):
         s = image_input.strip()
         # data URL
         if s.startswith("data:image"):
-            _, b64 = s.split(",", 1)
-            data = base64.b64decode(b64)
-            return Image.open(io.BytesIO(data)).convert("RGB")
-        # raw base64 (best-effort)
+            print("[DEBUG] image_input is data URL")
+            try:
+                _, b64 = s.split(",", 1)
+                data = base64.b64decode(b64)
+                return Image.open(io.BytesIO(data)).convert("RGB")
+            except Exception as e:
+                print(f"[DEBUG] data URL decode failed: {e}")
+                raise
+        # raw base64
         if _is_probably_base64(s) and not s.startswith(("http://", "https://")):
+            print("[DEBUG] image_input looks like raw base64")
             try:
                 data = base64.b64decode(s)
                 return Image.open(io.BytesIO(data)).convert("RGB")
-            except Exception:
-                pass
+            except Exception as e:
+                print(f"[DEBUG] raw base64 decode failed: {e} (fall through)")
         # URL
         if s.startswith(("http://", "https://")):
+            print(f"[DEBUG] image_input is URL: {s}")
             resp = requests.get(s, timeout=20)
             resp.raise_for_status()
             return Image.open(io.BytesIO(resp.content)).convert("RGB")
         # path
+        print(f"[DEBUG] image_input is path: {s}")
         return Image.open(s).convert("RGB")
     raise ValueError(f"Unsupported image input type: {type(image_input)}")
 
@@ -127,7 +144,6 @@ def _build_prompt_with_image(prompt: str, model_cfg) -> str:
         return f"{token}\n{prompt}"
     return f"{DEFAULT_IMAGE_TOKEN}\n{prompt}"
 
-# ---- image_processor yoksa oluşturmak için yardımcılar ----
 def _maybe_get_vision_tower_from_cfg(cfg) -> Optional[str]:
     vt = getattr(cfg, "vision_tower", None)
     if isinstance(vt, (list, tuple)) and vt:
@@ -142,61 +158,61 @@ class _ProcessorWrapper:
         self.proc = proc
     def preprocess(self, image, return_tensors="pt"):
         out = self.proc(image, return_tensors=return_tensors)
-        # AutoProcessor bazen dict döner, bazen tensor; normalize edelim
         if isinstance(out, dict):
             return out
         return {"pixel_values": out}
 
 def _ensure_image_processor(image_processor, model_cfg, model_path: str):
+    print(f"[DEBUG] _ensure_image_processor entry; got={type(image_processor)}")
     if image_processor is not None:
-        # bazı AutoProcessor'larda gerçek işleyici proc.image_processor altında
         if hasattr(image_processor, "preprocess"):
+            print("[DEBUG] existing image_processor has preprocess()")
             return image_processor
         if hasattr(image_processor, "image_processor"):
             ip = image_processor.image_processor
+            print(f"[DEBUG] using image_processor.image_processor -> {type(ip)}")
             if hasattr(ip, "preprocess"):
                 return ip
             return _ProcessorWrapper(ip)
         if callable(image_processor):
+            print("[DEBUG] wrapping callable image_processor")
             return _ProcessorWrapper(image_processor)
 
-    # 1) AutoProcessor (trust_remote_code ile) dene
     if AutoProcessor is not None:
         try:
+            print(f"[DEBUG] AutoProcessor.from_pretrained({model_path}) ...")
             proc = AutoProcessor.from_pretrained(model_path, trust_remote_code=True)
             if hasattr(proc, "preprocess"):
+                print("[DEBUG] AutoProcessor has preprocess()")
                 return proc
             if hasattr(proc, "image_processor"):
                 ip = proc.image_processor
+                print("[DEBUG] AutoProcessor.image_processor found")
                 if hasattr(ip, "preprocess"):
                     return ip
                 return _ProcessorWrapper(ip)
+            print("[DEBUG] wrapping AutoProcessor with _ProcessorWrapper")
             return _ProcessorWrapper(proc)
-        except Exception:
-            pass
+        except Exception as e:
+            print(f"[DEBUG] AutoProcessor failed: {e}")
 
-    # 2) Vision tower'dan CLIPImageProcessor üret
     vt = _maybe_get_vision_tower_from_cfg(model_cfg)
+    print(f"[DEBUG] vision_tower from cfg/env -> {vt}")
     if vt and CLIPImageProcessor is not None:
         try:
             ip = CLIPImageProcessor.from_pretrained(vt)
+            print("[DEBUG] CLIPImageProcessor created from vision_tower")
             return ip
-        except Exception:
-            pass
+        except Exception as e:
+            print(f"[DEBUG] CLIPImageProcessor failed: {e}")
 
-    # 3) en sonda None kalsın; çağrı tarafında fallback var
+    print("[DEBUG] image_processor could not be resolved -> None")
     return None
 
 # ---------- Endpoint Handler ----------
 class EndpointHandler:
-    """
-    HF Inference Toolkit çağrı akışı:
-      handler = EndpointHandler(model_dir)
-      handler.load()
-      handler(inputs_dict)
-    """
-
     def __init__(self, model_dir: Optional[str] = None):
+        print(f"[DEBUG] EndpointHandler.__init__ model_dir={model_dir}")
         self.model_dir = model_dir
         self.model = None
         self.tokenizer = None
@@ -209,10 +225,13 @@ class EndpointHandler:
     def load(self):
         model_path = _get_env("HF_MODEL_ID", "PULSE-ECG/PULSE-7B")
         model_base = _get_env("HF_MODEL_BASE", None)
+        print(f"[DEBUG] load(): HF_MODEL_ID={model_path}, HF_MODEL_BASE={model_base}")
 
         os.environ.setdefault("ATTN_IMPLEMENTATION", "flash_attention_2")
         os.environ.setdefault("FLASH_ATTENTION", "1")
+        print(f"[DEBUG] env ATTN_IMPLEMENTATION={os.getenv('ATTN_IMPLEMENTATION')} FLASH_ATTENTION={os.getenv('FLASH_ATTENTION')}")
 
+        print("[DEBUG] calling load_pretrained_model ...")
         self.tokenizer, self.model, self.image_processor, self.context_len = load_pretrained_model(
             model_path=model_path,
             model_base=model_base,
@@ -222,86 +241,130 @@ class EndpointHandler:
             device=self.device,
         )
         self.model_name = getattr(self.model.config, "name_or_path", str(model_path))
+        print(f"[DEBUG] model loaded: name={self.model_name}")
+        print(f"[DEBUG] tokenizer={type(self.tokenizer)}, model={type(self.model)}, image_processor={type(self.image_processor)}, context_len={self.context_len}")
 
-        # image_processor fallback (kritik!)
+        # image_processor fallback
         self.image_processor = _ensure_image_processor(self.image_processor, self.model.config, model_path)
+        print(f"[DEBUG] final image_processor -> {type(self.image_processor)}")
 
         # tokenizer güvenliği
         try:
             self.tokenizer.padding_side = "left"
             if self.tokenizer.pad_token_id is None:
                 self.tokenizer.pad_token_id = self.tokenizer.eos_token_id
-        except Exception:
-            pass
+            print(f"[DEBUG] tokenizer.padding_side={self.tokenizer.padding_side}, pad_token_id={self.tokenizer.pad_token_id}")
+        except Exception as e:
+            print(f"[DEBUG] tokenizer safety failed: {e}")
 
         self.model.eval()
+        print("[DEBUG] model.eval() done")
         return True
 
     @torch.inference_mode()
     def __call__(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
-        # HF bazen payload'ı {"inputs": {...}} diye sarar
+        print(f"[DEBUG] __call__ inputs type={type(inputs)} keys={list(inputs.keys()) if hasattr(inputs,'keys') else 'N/A'}")
+        # HF bazen {"inputs": {...}} sarmalar
         if "inputs" in inputs and isinstance(inputs["inputs"], dict):
+            print("[DEBUG] unwrapping inputs['inputs']")
             inputs = inputs["inputs"]
 
-        # ---- girişler
+        print(f"[DEBUG] after unwrap keys={list(inputs.keys()) if hasattr(inputs,'keys') else 'N/A'}")
         prompt = inputs.get("query") or inputs.get("prompt") or inputs.get("istem") or ""
         image_in = inputs.get("image") or inputs.get("image_url") or inputs.get("img")
+        print(f"[DEBUG] prompt exists={bool(prompt.strip())}, image_in is None={image_in is None}")
+
         if not image_in:
             return {"error": "Missing 'image' in payload"}
         if not isinstance(prompt, str) or not prompt.strip():
             return {"error": "Missing 'query'/'prompt' text"}
 
-        temperature = float(inputs.get("temperature", 0.0))  # 0 => deterministic
-        top_p = float(inputs.get("top_p", 0.9))
-        max_new = int(inputs.get("max_new_tokens", inputs.get("max_tokens", 512)))
-        repetition_penalty = float(inputs.get("repetition_penalty", 1.0))
-        conv_mode_override = inputs.get("conv_mode") or _get_env("CONV_MODE", None)
+        try:
+            temperature = float(inputs.get("temperature", 0.0))
+            top_p = float(inputs.get("top_p", 0.9))
+            max_new = int(inputs.get("max_new_tokens", inputs.get("max_tokens", 512)))
+            repetition_penalty = float(inputs.get("repetition_penalty", 1.0))
+            conv_mode_override = inputs.get("conv_mode") or _get_env("CONV_MODE", None)
+        except Exception as e:
+            print(f"[DEBUG] param parse failed: {e}")
+            return {"error": f"Bad parameters: {e}"}
 
         # ---- görüntü
         try:
             image = _load_image_from_any(image_in)
+            print(f"[DEBUG] loaded image size={image.size}")
         except Exception as e:
+            print(f"[DEBUG] image load failed: {e}")
             return {"error": f"Failed to load image: {e}"}
+
         images = [image]
         image_sizes = [image.size]
+        print(f"[DEBUG] image_sizes={image_sizes}; device={self.device}, dtype={self.dtype}")
 
-        # process_images -> tensör (image_processor None olabilir; o zaman plain preprocess)
+        # process_images -> tensör
         try:
             if self.image_processor is None:
-                # en kaba yedek: AutoProcessor başarısız olduysa
-                raise RuntimeError("image_processor is None")
+                raise RuntimeError("image_processor is None before process_images")
             images_tensor = process_images(images, self.image_processor, self.model.config)
-        except Exception:
-            # plain preprocess
-            if hasattr(self.image_processor, "preprocess"):
-                images_tensor = self.image_processor.preprocess(image, return_tensors="pt")["pixel_values"]
-            else:
-                # en son çare: AutoProcessor benzeri çağrı
-                images_tensor = _ProcessorWrapper(self.image_processor).preprocess(image, return_tensors="pt")["pixel_values"]
-        images_tensor = images_tensor.to(self.device, dtype=self.dtype)
+            print(f"[DEBUG] process_images OK; type={type(images_tensor)} shape={getattr(images_tensor,'shape',None)}")
+        except Exception as e:
+            print(f"[DEBUG] process_images failed: {e} -> fallback to preprocess()")
+            try:
+                if hasattr(self.image_processor, "preprocess"):
+                    out = self.image_processor.preprocess(image, return_tensors="pt")
+                    images_tensor = out["pixel_values"]
+                    print(f"[DEBUG] preprocess() OK; shape={getattr(images_tensor,'shape',None)}")
+                else:
+                    # en kaba yedek
+                    wrp = _ProcessorWrapper(self.image_processor)
+                    out = wrp.preprocess(image, return_tensors="pt")
+                    images_tensor = out["pixel_values"]
+                    print(f"[DEBUG] _ProcessorWrapper OK; shape={getattr(images_tensor,'shape',None)}")
+            except Exception as e2:
+                print(f"[DEBUG] preprocess fallback failed: {e2}")
+                return {"error": f"Image processing failed: {e} / {e2}"}
+
+        try:
+            images_tensor = images_tensor.to(self.device, dtype=self.dtype)
+            print(f"[DEBUG] images_tensor moved to {self.device} dtype={self.dtype}")
+        except Exception as e:
+            print(f"[DEBUG] images_tensor.to failed: {e}")
+            return {"error": f"Tensor move/cast failed: {e}"}
 
         # ---- konuşma şablonu + prompt
         mode = conv_mode_override or _get_conv_mode(self.model_name)
         conv = (conv_templates.get(mode) or conv_templates[list(conv_templates.keys())[0]]).copy()
+        print(f"[DEBUG] conv_mode={mode}; conv.roles={conv.roles}")
 
         formatted_prompt = _build_prompt_with_image(prompt.strip(), self.model.config)
+        print(f"[DEBUG] formatted_prompt startswith image token? {formatted_prompt.startswith(DEFAULT_IMAGE_TOKEN) or formatted_prompt.startswith(DEFAULT_IM_START_TOKEN)}")
         conv.append_message(conv.roles[0], formatted_prompt)
         conv.append_message(conv.roles[1], None)
         full_prompt = conv.get_prompt()
+        print(f"[DEBUG] full_prompt length={len(full_prompt)}")
 
-        # ---- tokenizasyon (image token aware) + attention_mask
+        # ---- tokenizasyon
         try:
             input_ids = tokenizer_image_token(
                 full_prompt, self.tokenizer, image_token_index=-200, return_tensors="pt"
             ).unsqueeze(0).to(self.device)
-        except Exception:
-            toks = self.tokenizer([full_prompt], return_tensors="pt", padding=True, truncation=True)
-            input_ids = toks["input_ids"].to(self.device)
+            print(f"[DEBUG] tokenizer_image_token OK; input_ids.shape={input_ids.shape}")
+        except Exception as e:
+            print(f"[DEBUG] tokenizer_image_token failed: {e}; fallback to plain tokenizer")
+            try:
+                toks = self.tokenizer([full_prompt], return_tensors="pt", padding=True, truncation=True)
+                input_ids = toks["input_ids"].to(self.device)
+                print(f"[DEBUG] plain tokenizer OK; input_ids.shape={input_ids.shape}")
+            except Exception as e2:
+                print(f"[DEBUG] plain tokenizer failed: {e2}")
+                return {"error": f"Tokenization failed: {e} / {e2}"}
 
         attention_mask = torch.ones_like(input_ids, device=self.device)
+        print(f"[DEBUG] attention_mask shape={attention_mask.shape}")
 
         # ---- generate
         try:
+            print(f"[DEBUG] calling model.generate(...) max_new_tokens={max_new} temp={temperature} top_p={top_p} rep={repetition_penalty}")
             gen_ids = self.model.generate(
                 input_ids=input_ids,
                 attention_mask=attention_mask,
@@ -314,12 +377,19 @@ class EndpointHandler:
                 repetition_penalty=repetition_penalty,
                 use_cache=True,
             )
+            print(f"[DEBUG] generate OK; gen_ids.shape={gen_ids.shape}")
         except Exception as e:
+            print(f"[DEBUG] generate failed: {e}")
             return {"error": f"Generation failed: {e}"}
 
-        # ---- sadece yeni tokenları decode et (echo yok)
-        new_tokens = gen_ids[0, input_ids.shape[1]:]
-        text = self.tokenizer.decode(new_tokens, skip_special_tokens=True).strip()
+        # ---- decode (echo-fix)
+        try:
+            new_tokens = gen_ids[0, input_ids.shape[1]:]
+            text = self.tokenizer.decode(new_tokens, skip_special_tokens=True).strip()
+            print(f"[DEBUG] decoded text length={len(text)}")
+        except Exception as e:
+            print(f"[DEBUG] decode failed: {e}")
+            return {"error": f"Decode failed: {e}"}
 
         return {
             "generated_text": text,