Update handler.py

handler.py

@@ -1,49 +1,59 @@
-# /repository/handler.py
-import base64, io, os, json
+# handler.py (örnek iskelet)
+import base64, io, os
 from typing import Any, Dict, List
+import torch
 from PIL import Image
+from transformers import AutoTokenizer, AutoProcessor, AutoModelForVision2Seq  # model tipinize göre
 
-# (Gerekiyorsa: from transformers import ...  # model yükleme burada olur)
+HF_MODEL_ID = os.getenv("HF_MODEL_ID", "PULSE-ECG/PULSE-7B")  # ağırlıkların olduğu repo id
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+DT = torch.bfloat16 if torch.cuda.is_available() else torch.float32  # bfloat16 GPU varsa
 
 class EndpointHandler:
     def __init__(self, path: str = "") -> None:
-        # Burada model/processor/tokenizer'ı yükleyin
-        # ör: self.model = ...
-        #      self.processor = ...
-        pass
+        # path: /repository (bu repo klasörü)
+        # NOT: Ağırlıkları bu repodan değil, HF Hub’dan alıyoruz
+        self.tokenizer = AutoTokenizer.from_pretrained(HF_MODEL_ID, use_fast=True, trust_remote_code=True)
+        self.processor = AutoProcessor.from_pretrained(HF_MODEL_ID, trust_remote_code=True)
+        self.model = AutoModelForVision2Seq.from_pretrained(
+            HF_MODEL_ID,
+            torch_dtype=DT,
+            device_map="auto",              # GPU varsa otomatik yerleşim
+            trust_remote_code=True,
+            low_cpu_mem_usage=True,
+            # attn_implementation="sdpa",   # flash-attn yoksa güvenlisi SDPA
+        )
 
     def _load_image(self, img_field: str) -> Image.Image:
         if img_field.startswith("data:image"):
-            # data URL -> bytes
-            header, b64data = img_field.split(",", 1)
-            img_bytes = base64.b64decode(b64data)
-            return Image.open(io.BytesIO(img_bytes)).convert("RGB")
+            head, b64 = img_field.split(",", 1)
+            return Image.open(io.BytesIO(base64.b64decode(b64))).convert("RGB")
         elif img_field.startswith("http://") or img_field.startswith("https://"):
             import requests
-            resp = requests.get(img_field, timeout=20)
-            resp.raise_for_status()
-            return Image.open(io.BytesIO(resp.content)).convert("RGB")
+            r = requests.get(img_field, timeout=20)
+            r.raise_for_status()
+            return Image.open(io.BytesIO(r.content)).convert("RGB")
         else:
-            # Yerel yol (container içinden)
             return Image.open(img_field).convert("RGB")
 
     def __call__(self, data: Dict[str, Any]) -> List[Dict[str, Any]]:
-        """
-        Hugging Face Inference Toolkit burayı çağırır.
-        Beklenen dönüş genelde: [{"generated_text": "..."}]
-        """
         inputs = data.get("inputs") or {}
         params = data.get("parameters") or {}
         query = inputs.get("query", "")
-        img_field = inputs.get("image", "")
+        img_f = inputs.get("image", "")
+        image = self._load_image(img_f) if img_f else None
 
-        # Görseli hazırla (opsiyonel — modeliniz görsel kullanıyorsa)
-        image = None
-        if img_field:
-            image = self._load_image(img_field)
+        # Model türüne göre preprocessing (örnek akış)
+        model_inputs = self.processor(images=image, text=query, return_tensors="pt").to(self.model.device)
+        gen_kwargs = {
+            "max_new_tokens": int(params.get("max_new_tokens", 256)),
+            "temperature": float(params.get("temperature", 0.0)),
+            "do_sample": bool(params.get("do_sample", params.get("temperature", 0.0) > 0)),
+            "top_p": float(params.get("top_p", 1.0)),
+            "repetition_penalty": float(params.get("repetition_penalty", 1.0)),
+        }
 
-        # Burada kendi inference kodunuzu çağırın:
-        # out_text = run_model(self.model, self.processor, query, image, **params)
-        out_text = f"(demo) prompt='{query[:50]}...' image={'yes' if image else 'no'}"
-
-        return [{"generated_text": out_text}]
+        with torch.no_grad():
+            out_ids = self.model.generate(**model_inputs, **gen_kwargs)
+        text = self.tokenizer.decode(out_ids[0], skip_special_tokens=True)
+        return [{"generated_text": text}]