Update handler.py

handler.py

@@ -1,41 +1,33 @@
 # -*- coding: utf-8 -*-
 """
-PULSE ECG Handler - Deterministic ECG Analysis Model (app.py uyumlu)
-- Deterministic (do_sample=False, sabit seed)
-- Tek görüntü, LLaVA conv_template + <image> token akışı
-- Model dtype/device ile uyumlu görüntü tensörü (3D/4D/5D destekli)
-- Sağlam URL/base64 işleme, güvenli logging, opsiyonel HF upload
-- Zorunlu başlık şablonu + min_new_tokens ile tam Step 1–9 çıktısı
-- Tekrarları engelleme (no_repeat_ngram_size) + post-format dedup
+PULSE ECG Handler - Demo-like (sampling) LLaVA endpoint
+- Demo davranışı: do_sample=True, temperature/top_p payload'dan alınır
+- max_new_tokens: payload/slider değeri; bağlam limitine göre güvenli kırpma
+- Tek görsel işleme; IM_START/END otomatik; 3D/4D/5D tensör uyumlu
+- Çıktıya post-format/deduplicate UYGULANMAZ (demo ile bire bir)
 """
 
 import os
-import re
-import datetime
-import torch
-import hashlib
 import json
 import base64
-import requests
-from PIL import Image
+import hashlib
+import datetime
 from io import BytesIO
 
-# --- Opsiyonel bağımlılıklar ---
-try:
-    import numpy as np  # isteğe bağlı
-except Exception:
-    np = None
+import torch
+from PIL import Image
+import requests
 
+# --- Opsiyonel bağımlılıklar ---
 try:
     import cv2
     CV2_AVAILABLE = True
 except Exception:
     CV2_AVAILABLE = False
-    print("Warning: cv2 (OpenCV) not available. Video processing will be disabled.")
+    print("Warning: OpenCV (cv2) not available; video is disabled.")
 
-# LLaVA
+# --- LLaVA / Transformers ---
 try:
-    from llava import conversation as conversation_lib
     from llava.constants import (
         IMAGE_TOKEN_INDEX,
         DEFAULT_IMAGE_TOKEN,
@@ -44,55 +36,45 @@ try:
     )
     from llava.conversation import conv_templates, SeparatorStyle
     from llava.model.builder import load_pretrained_model
-    from llava.utils import disable_torch_init
     from llava.mm_utils import (
         tokenizer_image_token,
         process_images,
         get_model_name_from_path,
         KeywordsStoppingCriteria,
     )
+    from llava.utils import disable_torch_init
     LLAVA_AVAILABLE = True
 except Exception as e:
     LLAVA_AVAILABLE = False
     print(f"Warning: LLaVA modules not available: {e}")
 
-# Transformers
-try:
-    from transformers import TextIteratorStreamer  # mevcutsa sorun değil
-    TRANSFORMERS_AVAILABLE = True
-except Exception:
-    TRANSFORMERS_AVAILABLE = False
-    print("Warning: Transformers not available")
-
-# HF Hub (opsiyonel)
+# --- HF Hub (opsiyonel logging) ---
 try:
     from huggingface_hub import HfApi, login
     HF_HUB_AVAILABLE = True
 except Exception:
     HF_HUB_AVAILABLE = False
-    print("Warning: Hugging Face Hub not available")
 
-# --- HF Hub init (opsiyonel) ---
+# ------------- HF Hub init (opsiyonel) -------------
+api = None
+repo_name = ""
 if HF_HUB_AVAILABLE and "HF_TOKEN" in os.environ:
     try:
         login(token=os.environ["HF_TOKEN"], write_permission=True)
         api = HfApi()
         repo_name = os.environ.get("LOG_REPO", "")
     except Exception as e:
-        print(f"Failed to initialize HF API: {e}")
+        print(f"[HF Hub] init failed: {e}")
         api = None
         repo_name = ""
-else:
-    api = None
-    repo_name = ""
 
-# --- Sabitler / Dizinyapısı ---
+# ------------- Klasörler -------------
 LOGDIR = "./logs"
 VOTEDIR = "./votes"
 os.makedirs(LOGDIR, exist_ok=True)
 os.makedirs(VOTEDIR, exist_ok=True)
 
-# --- Global model durumları ---
+# ------------- Global durum -------------
 tokenizer = None
 model = None
 image_processor = None
@@ -100,30 +82,9 @@ context_len = None
 args = None
 model_initialized = False
 
-# --- Tutarlılık ayarları ---
-PROMPT_NORMALIZATION = True
-DEFAULT_ECG_PROMPT = (
-    "Perform a detailed ECG interpretation of the provided image. Analyze step by step the rhythm, heart rate, "
-    "cardiac axis, P waves, PR interval, QRS complex morphology and duration, ST segments, T waves, and QT/QTc interval. "
-    "OUTPUT FORMAT (use these exact headings, and include every section even if normal):\n"
-    "Step 1: Rhythm Analysis\n"
-    "Step 2: Heart Rate Analysis\n"
-    "Step 3: Cardiac Axis Analysis\n"
-    "Step 4: P Wave Analysis\n"
-    "Step 5: PR Interval Analysis\n"
-    "Step 6: QRS Complex Analysis\n"
-    "Step 7: ST Segment Analysis\n"
-    "Step 8: T Wave Analysis\n"
-    "Step 9: QT/QTc Interval Analysis\n"
-    "Structured Clinical Impression:\n"
-    "If a section is normal, write 'Normal' and give a brief justification. "
-    "Each section must be 1–3 concise sentences. Do not repeat identical statements. "
-    "Write the final diagnostic impression only once in 'Structured Clinical Impression' and do not restate it elsewhere."
-)
-
-# ---------- Yardımcılar ----------
-
-def _safe_upload(path):
+# ------------- Yardımcılar -------------
+
+def _safe_upload(path: str):
     if api and repo_name and os.path.isfile(path):
         try:
             api.upload_file(
@@ -135,290 +96,62 @@ def _safe_upload(path):
         except Exception as e:
             print(f"[upload] failed for {path}: {e}")
 
-def get_conv_log_filename():
+def _conv_log_path():
     t = datetime.datetime.now()
-    name = os.path.join(LOGDIR, f"{t.year}-{t.month:02d}-{t.day:02d}-user_conv.json")
-    os.makedirs(os.path.dirname(name), exist_ok=True
-    )
-    return name
-
-def get_conv_vote_filename():
-    t = datetime.datetime.now()
-    name = os.path.join(VOTEDIR, f"{t.year}-{t.month:02d}-{t.day:02d}-user_vote.json")
-    os.makedirs(os.path.dirname(name), exist_ok=True)
-    return name
-
-def vote_last_response(state, vote_type, model_selector):
-    try:
-        with open(get_conv_vote_filename(), "a") as fout:
-            data = {"type": vote_type, "model": model_selector, "state": state}
-            fout.write(json.dumps(data) + "\n")
-        _safe_upload(get_conv_vote_filename())
-    except Exception as e:
-        print(f"Failed to record vote: {e}")
-
-# Yalın uzantı listeleri
-IMAGE_EXTS = {"jpg", "jpeg", "png", "bmp", "gif", "tiff", "webp", "jfif"}
-try:
-    import pillow_heif  # noqa: F401
-    IMAGE_EXTS.update({"heic", "heif"})
-except Exception:
-    pass
-
-VIDEO_EXTS = {"avi", "mp4", "mov", "mkv", "flv", "wmv", "mjpeg"}
-
-def is_valid_video_filename(name: str) -> bool:
-    if not CV2_AVAILABLE or not name:
-        return False
-    ext = name.split(".")[-1].lower()
-    return ext in VIDEO_EXTS
-
-def is_valid_image_filename(name: str) -> bool:
-    if not name:
-        return False
-    ext = name.split(".")[-1].lower()
-    return ext in IMAGE_EXTS
-
-def sample_frames(video_file, num_frames):
-    if not CV2_AVAILABLE:
-        raise ImportError("cv2 (OpenCV) not available. Video processing is disabled.")
-    cap = cv2.VideoCapture(video_file)
-    total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-    if total <= 0 or num_frames <= 0:
-        cap.release()
-        return []
-    step = max(1, total // num_frames)
-    idxs = list(range(0, total, step))[:num_frames]
-    frames = []
-    for i in idxs:
-        cap.set(cv2.CAP_PROP_POS_FRAMES, i)
-        ret, frame = cap.read()
-        if not ret or frame is None:
-            continue
-        pil_img = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
-        frames.append(pil_img)
-    cap.release()
-    return frames
-
-def load_image(image_file):
-    if image_file.startswith(("http://", "https://")):
-        try:
-            r = requests.get(image_file, timeout=(5, 15))
-            r.raise_for_status()
-            return Image.open(BytesIO(r.content)).convert("RGB")
-        except Exception as e:
-            raise ValueError(f"Failed to load image URL: {e}")
-    else:
-        return Image.open(image_file).convert("RGB")
-
-def process_base64_image(base64_string: str) -> Image.Image:
-    try:
-        if base64_string.startswith("data:image"):
-            base64_string = base64_string.split(",", 1)[1]
-        image_data = base64.b64decode(base64_string)
-        image = Image.open(BytesIO(image_data)).convert("RGB")
-        return image
-    except Exception as e:
-        raise ValueError(f"Failed to process base64 image: {e}")
+    p = os.path.join(LOGDIR, f"{t.year:04d}-{t.month:02d}-{t.day:02d}-user_conv.json")
+    os.makedirs(os.path.dirname(p), exist_ok=True)
+    return p
 
-def process_image_input(image_input):
-    """Desteklenen formatlar: yerel yol, URL, base64 string veya {'image': base64} sözlüğü."""
-    if isinstance(image_input, str):
-        if image_input.startswith(("http://", "https://")):
-            return load_image(image_input)
-        if os.path.exists(image_input):
-            return load_image(image_input)
-        return process_base64_image(image_input)
-    if isinstance(image_input, dict) and "image" in image_input:
-        return process_base64_image(image_input["image"])
-    raise ValueError("Unsupported image input format")
-
-# ---------- Şablon dayatma (post-format) ----------
-
-SECTION_ORDER = [
-    "Step 1: Rhythm Analysis",
-    "Step 2: Heart Rate Analysis",
-    "Step 3: Cardiac Axis Analysis",
-    "Step 4: P Wave Analysis",
-    "Step 5: PR Interval Analysis",
-    "Step 6: QRS Complex Analysis",
-    "Step 7: ST Segment Analysis",
-    "Step 8: T Wave Analysis",
-    "Step 9: QT/QTc Interval Analysis",
-    "Structured Clinical Impression:",
-]
-
-_SECTION_RE = re.compile(
-    r"(Step\s*1:\s*Rhythm Analysis|"
-    r"Step\s*2:\s*Heart Rate Analysis|"
-    r"Step\s*3:\s*Cardiac Axis Analysis|"
-    r"Step\s*4:\s*P Wave Analysis|"
-    r"Step\s*5:\s*PR Interval Analysis|"
-    r"Step\s*6:\s*QRS Complex Analysis|"
-    r"Step\s*7:\s*ST Segment Analysis|"
-    r"Step\s*8:\s*T Wave Analysis|"
-    r"Step\s*9:\s*QT/QTc Interval Analysis|"
-    r"Structured Clinical Impression:)",
-    flags=re.IGNORECASE
-)
-
-def _enforce_section_template(text: str) -> str:
+def load_image_any(image_input):
     """
-    Model çıktısını yakalayıp Step 1–9 + Structured başlıklarını sırayla ve eksiksiz
-    döndürecek şekilde biçimler. Eksik bölümler 'Normal...' notuyla doldurulur.
+    Desteklenen formatlar:
+      - URL (http/https)
+      - Yerel dosya yolu
+      - base64 (opsiyonel data URL prefix ile)
     """
-    pieces = _SECTION_RE.split(text)
-    found = {}
-    prefix = None
-
-    if pieces:
-        if not _SECTION_RE.match(pieces[0] or ""):
-            prefix = (pieces[0] or "").strip()
-
-        i = 1
-        while i + 1 < len(pieces):
-            heading = pieces[i].strip()
-            content = pieces[i + 1].strip()
-            for canonical in SECTION_ORDER:
-                if heading.lower().startswith(canonical.lower().rstrip(":")):
-                    found[canonical] = content
-                    break
-            i += 2
-
-    filled = []
-    for sec in SECTION_ORDER:
-        val = (found.get(sec, "") or "").strip()
-        if not val:
-            if sec.startswith("Step"):
-                val = "Normal. No definite abnormality detected in this section based on the provided ECG image."
-            else:
-                val = "Overall impression: No acute life-threatening abnormality identified. Correlate clinically."
-        filled.append(f"{sec}\n{val}")
-
-    if prefix:
-        filled[0] = filled[0] + f"\n\n(Additional notes captured before Step 1): {prefix}"
-
-    return "\n\n".join(filled)
-
-def _sent_split(s: str):
-    return [x.strip() for x in re.split(r'(?<=[.!?])\s+', s.strip()) if x.strip()]
-
-def _norm_key(s: str):
-    return re.sub(r'\W+', ' ', s.lower()).strip()
-
-def _dedupe_and_clip_sections(text: str) -> str:
-    """
-    Şablon oluşmuş metni alır, her bölümde tekrar eden cümleleri siler,
-    uzunluğu kısaltır (Steps: ≤3 cümle, Impression: ≤6 cümle) ve birleştirir.
-    """
-    pieces = _SECTION_RE.split(text)
-    found = {}
-    i = 1
-    while i + 1 < len(pieces):
-        heading = pieces[i].strip()
-        content = pieces[i + 1].strip()
-        for canonical in SECTION_ORDER:
-            if heading.lower().startswith(canonical.lower().rstrip(":")):
-                found[canonical] = content
-                break
-        i += 2
-
-    out_sections = []
-    for sec in SECTION_ORDER:
-        body = (found.get(sec, "") or "").strip()
-        sents = _sent_split(body)
-
-        seen = set()
-        deduped = []
-        for s in sents:
-            k = _norm_key(s)
-            if k not in seen:
-                seen.add(k)
-                deduped.append(s)
-
-        limit = 3 if sec.startswith("Step") else 6
-        limited = deduped[:limit] if deduped else []
-        out_body = " ".join(limited) if limited else body
-        out_sections.append(f"{sec}\n{out_body}" if out_body else f"{sec}\n")
-
-    return "\n\n".join(out_sections)
-
-# ---------- Oturum / Konuşma ----------
-
-class InferenceDemo(object):
-    def __init__(self, args, model_path, tokenizer, model, image_processor, context_len) -> None:
-        if not LLAVA_AVAILABLE:
-            raise ImportError("LLaVA modules not available")
-        disable_torch_init()
-        self.tokenizer, self.model, self.image_processor, self.context_len = (
-            tokenizer, model, image_processor, context_len
-        )
-        model_name = get_model_name_from_path(model_path)
-        low = model_name.lower()
-        if "llama-2" in low:
-            conv_mode = "llava_llama_2"
-        elif "v1" in low or "pulse" in low:
-            conv_mode = "llava_v1"
-        elif "mpt" in low:
-            conv_mode = "mpt"
-        elif "qwen" in low:
-            conv_mode = "qwen_1_5"
-        else:
-            conv_mode = "llava_v0"
-
-        if args.conv_mode is not None and conv_mode != args.conv_mode:
-            print(f"[WARNING] auto conv={conv_mode}, using --conv-mode={args.conv_mode}")
-        else:
-            args.conv_mode = conv_mode
-        self.conv_mode = args.conv_mode
-        self.conversation = conv_templates[self.conv_mode].copy()
-        self.num_frames = args.num_frames
-
-class ChatSessionManager:
-    def __init__(self):
-        self.chatbot_instance = None
-        self.args = None
-        self.model_path = None
-
-    def initialize_chatbot(self, args, model_path, tokenizer, model, image_processor, context_len):
-        self.args = args
-        self.model_path = model_path
-        self.chatbot_instance = InferenceDemo(args, model_path, tokenizer, model, image_processor, context_len)
-        print(f"Initialized Chatbot instance with ID: {id(self.chatbot_instance)}")
-
-    def reset_chatbot(self):
-        self.chatbot_instance = None
-
-    def get_chatbot(self, args, model_path, tokenizer, model, image_processor, context_len):
-        if self.chatbot_instance is None:
-            self.initialize_chatbot(args, model_path, tokenizer, model, image_processor, context_len)
-        return self.chatbot_instance
-
-chat_manager = ChatSessionManager()
-
-def clear_history():
-    if not LLAVA_AVAILABLE:
-        return {"error": "LLaVA modules not available"}
-    try:
-        chatbot = chat_manager.get_chatbot(args, args.model_path if args else "PULSE-ECG/PULSE-7B",
-                                           tokenizer, model, image_processor, context_len)
+    if isinstance(image_input, str):
+        s = image_input.strip()
+        if s.startswith(("http://", "https://")):
+            r = requests.get(s, timeout=(5, 15))
+            r.raise_for_status()
+            return Image.open(BytesIO(r.content)).convert("RGB")
+        if os.path.exists(s):
+            return Image.open(s).convert("RGB")
+        # base64
+        if s.startswith("data:image"):
+            s = s.split(",", 1)[1]
         try:
-            chatbot.conversation = conv_templates[chatbot.conv_mode].copy()
+            raw = base64.b64decode(s)
+            return Image.open(BytesIO(raw)).convert("RGB")
         except Exception as e:
-            print(f"[DEBUG] Failed to reset conversation: {e}")
-        return {"status": "success", "message": "Conversation history cleared"}
-    except Exception as e:
-        return {"error": f"Failed to clear history: {str(e)}"}
-
-# ---------- Prompt inşası ----------
-
-def _build_prompt(chatbot, user_text: str) -> str:
-    # mm_use_im_start_end konfigürasyonuna göre <image> tokenını sarmala
+            raise ValueError(f"Invalid image string (not URL/path/base64): {e}")
+    elif isinstance(image_input, dict) and "image" in image_input:
+        return load_image_any(image_input["image"])
+    else:
+        raise ValueError("Unsupported image input format")
+
+def _guess_conv_mode(model_path: str) -> str:
+    name = get_model_name_from_path(model_path).lower()
+    if "llama-2" in name:
+        return "llava_llama_2"
+    if "v1" in name or "pulse" in name:
+        return "llava_v1"
+    if "mpt" in name:
+        return "mpt"
+    if "qwen" in name:
+        return "qwen_1_5"
+    return "llava_v0"
+
+def _wrap_image_token_if_needed(model_cfg) -> bool:
     try:
-        use_wrap = bool(getattr(chatbot.model.config, "mm_use_im_start_end", False))
+        return bool(getattr(model_cfg, "mm_use_im_start_end", False))
     except Exception:
-        use_wrap = False
+        return False
+
+# ------------- Çekirdek üretim -------------
 
+def _build_prompt_and_ids(chatbot, user_text: str, device: torch.device):
+    use_wrap = _wrap_image_token_if_needed(chatbot.model.config)
     if use_wrap:
         inp = f"{DEFAULT_IM_START_TOKEN}{DEFAULT_IMAGE_TOKEN}{DEFAULT_IM_END_TOKEN}\n{user_text}"
     else:
@@ -426,233 +159,207 @@ def _build_prompt(chatbot, user_text: str) -> str:
 
     chatbot.conversation.append_message(chatbot.conversation.roles[0], inp)
     chatbot.conversation.append_message(chatbot.conversation.roles[1], None)
-    return chatbot.conversation.get_prompt()
+    prompt = chatbot.conversation.get_prompt()
+
+    input_ids = tokenizer_image_token(
+        prompt, chatbot.tokenizer, IMAGE_TOKEN_INDEX, return_tensors="pt"
+    ).unsqueeze(0).to(device)
+    return prompt, input_ids
 
-def _stop_criteria_from_conv(chatbot, input_ids):
+def _stopping(chatbot, input_ids):
     conv = chatbot.conversation
     stop_str = conv.sep if conv.sep_style != SeparatorStyle.TWO else conv.sep2
     return KeywordsStoppingCriteria([stop_str], chatbot.tokenizer, input_ids)
 
-# ---------- Cevap üretimi ----------
-
-def generate_response(message_text,
-                      image_input,
-                      max_output_tokens=4096,
-                      repetition_penalty=1.0,
-                      conv_mode_override=None):
+def _safe_max_new_tokens(requested: int, input_len: int, ctx_limit: int) -> int:
+    """
+    Demo'da slider değeri doğrudan kullanılıyor; burada ek güvenlik:
+    toplam (input + new + rezerv) <= ctx_limit olacak şekilde kırp.
+    """
+    requested = max(1, min(int(requested), 8192))
+    reserve = 16
+    available = max(32, ctx_limit - input_len - reserve)
+    return max(1, min(requested, available))
+
+def generate_response(
+    message_text: str,
+    image_input,
+    *,
+    max_new_tokens: int = 4096,
+    temperature: float = 0.05,
+    top_p: float = 1.0,
+    repetition_penalty: float = 1.0,
+    conv_mode_override: str | None = None,
+    det_seed: int | None = None,
+):
     if not LLAVA_AVAILABLE:
         return {"error": "LLaVA modules not available"}
 
-    if not message_text or not image_input:
-        return {"error": "Both message text and image are required"}
-
-    chatbot = chat_manager.get_chatbot(
-        args, args.model_path if args else "PULSE-ECG/PULSE-7B",
-        tokenizer, model, image_processor, context_len
-    )
+    if not message_text or image_input is None:
+        return {"error": "Both 'message' and 'image' are required"}
 
+    # Chatbot/konuşma hazırla (her çağrıda sıfırdan, demo gibi)
+    chatbot = chat_manager.get_chatbot(args, args.model_path, tokenizer, model, image_processor, context_len)
     if conv_mode_override and conv_mode_override in conv_templates:
         chatbot.conversation = conv_templates[conv_mode_override].copy()
     else:
         chatbot.conversation = conv_templates[chatbot.conv_mode].copy()
 
-    # Görüntüyü al/işle
+    # Görüntüyü yükle
     try:
-        image = process_image_input(image_input)
+        pil_img = load_image_any(image_input)
     except Exception as e:
-        return {"error": f"Failed to process image: {str(e)}"}
+        return {"error": f"Failed to load image: {e}"}
 
     # Log için kaydet
+    img_hash = "NA"
+    img_path = None
     try:
-        img_byte_arr = BytesIO()
-        image.save(img_byte_arr, format="JPEG")
-        image_hash = hashlib.md5(img_byte_arr.getvalue()).hexdigest()
+        buf = BytesIO()
+        pil_img.save(buf, format="JPEG")
+        img_bytes = buf.getvalue()
+        img_hash = hashlib.md5(img_bytes).hexdigest()
         t = datetime.datetime.now()
-        out_path = os.path.join(LOGDIR, "serve_images", f"{t.year}-{t.month:02d}-{t.day:02d}", f"{image_hash}.jpg")
-        os.makedirs(os.path.dirname(out_path), exist_ok=True)
-        if not os.path.isfile(out_path):
-            image.save(out_path)
+        img_path = os.path.join(LOGDIR, "serve_images", f"{t.year:04d}-{t.month:02d}-{t.day:02d}", f"{img_hash}.jpg")
+        os.makedirs(os.path.dirname(img_path), exist_ok=True)
+        if not os.path.isfile(img_path):
+            pil_img.save(img_path)
     except Exception as e:
-        print(f"[WARN] Failed to save image: {e}")
-        out_path = None
-        image_hash = "NA"
-
-    # Model dtype/device
-    model_device = next(chatbot.model.parameters()).device
-    model_dtype  = next(chatbot.model.parameters()).dtype
+        print(f"[log] saving image failed: {e}")
 
-    # Görüntü tensörü (Tensor/list/tuple + 3D/4D/5D destekli)
+    # Görüntüyü tensöre çevir
+    device = next(chatbot.model.parameters()).device
+    dtype  = next(chatbot.model.parameters()).dtype
     try:
-        processed = process_images([image], chatbot.image_processor, chatbot.model.config)
-
+        processed = process_images([pil_img], chatbot.image_processor, chatbot.model.config)
         if isinstance(processed, torch.Tensor):
-            if processed.ndim == 3:
-                image_tensor = processed.unsqueeze(0)  # (1,C,H,W)
-            elif processed.ndim == 4:
-                image_tensor = processed              # (B,C,H,W)
-            elif processed.ndim == 5:
-                b, t, c, h, w = processed.shape
-                image_tensor = processed.reshape(b * t, c, h, w)  # (B*T,C,H,W)
+            if processed.ndim == 3:   # (C,H,W)
+                image_tensor = processed.unsqueeze(0)
+            elif processed.ndim == 4: # (B,C,H,W)
+                image_tensor = processed
+            elif processed.ndim == 5: # (B,T,C,H,W) -> (B*T,C,H,W)
+                b,t,c,h,w = processed.shape
+                image_tensor = processed.reshape(b*t, c, h, w)
             else:
                 return {"error": f"Unexpected image tensor shape: {tuple(processed.shape)}"}
-        elif isinstance(processed, (list, tuple)):
-            if len(processed) == 0:
-                return {"error": "Image processing returned empty list"}
+        elif isinstance(processed, (list, tuple)) and len(processed) > 0:
             first = processed[0]
-            if not isinstance(first, torch.Tensor):
-                return {"error": f"Processed image type not tensor: {type(first)}"}
-            image_tensor = first.unsqueeze(0) if first.ndim == 3 else first
+            image_tensor = first.unsqueeze(0) if isinstance(first, torch.Tensor) and first.ndim == 3 else first
         else:
-            return {"error": f"Unsupported processed type: {type(processed)}"}
-
-        image_tensor = image_tensor.to(device=model_device, dtype=model_dtype)
+            return {"error": "Image processing returned empty"}
 
+        # Demo'da çoğunlukla half + to(device) kullanılıyor
+        image_tensor = image_tensor.to(device=device, dtype=getattr(torch, "float16", torch.float16))
     except Exception as e:
-        return {"error": f"Image processing failed: {str(e)}"}
+        return {"error": f"Image processing failed: {e}"}
 
     # Prompt & tokenizasyon
-    prompt = _build_prompt(chatbot, message_text)
-    input_ids = tokenizer_image_token(
-        prompt, chatbot.tokenizer, IMAGE_TOKEN_INDEX, return_tensors="pt"
-    ).unsqueeze(0).to(model_device)
-
-    # Stop kriteri
-    stopping_criteria = _stop_criteria_from_conv(chatbot, input_ids)
+    prompt, input_ids = _build_prompt_and_ids(chatbot, message_text, device)
+    stopping = _stopping(chatbot, input_ids)
 
-    # Deterministik üretim
-    torch.manual_seed(42)
-    if torch.cuda.is_available():
-        torch.cuda.manual_seed(42)
-        torch.cuda.manual_seed_all(42)
+    # max_new_tokens'ı güvenle kırp (demo slider + bağlam tavanı)
+    ctx_limit = context_len or getattr(chatbot.model.config, "max_position_embeddings", 8192)
+    max_new_tokens = _safe_max_new_tokens(max_new_tokens, input_ids.shape[1], ctx_limit)
 
-    # EOS/PAD güvenli al
-    eos_id = chatbot.tokenizer.eos_token_id
-    if eos_id is None:
-        try:
-            eos_id = chatbot.tokenizer.convert_tokens_to_ids("</s>")
-        except Exception:
-            eos_id = 0  # son çare
+    # Demo: sampling açık; istenirse deterministik sample için seed verilebilir
+    if det_seed is not None:
+        torch.manual_seed(det_seed)
+        if torch.cuda.is_available():
+            torch.cuda.manual_seed(det_seed)
+            torch.cuda.manual_seed_all(det_seed)
 
     try:
         with torch.no_grad():
             outputs = chatbot.model.generate(
                 inputs=input_ids,
                 images=image_tensor,
-                do_sample=False,                  # deterministik
-                max_new_tokens=int(max_output_tokens),
-                min_new_tokens=350,               # 800 -> 350 (tekrar riskini azalt)
-                no_repeat_ngram_size=5,           # tekrar bloklarını engelle
+                do_sample=True,
+                temperature=float(temperature),
+                top_p=float(top_p),
                 repetition_penalty=float(repetition_penalty),
+                max_new_tokens=int(max_new_tokens),
                 use_cache=False,
-                pad_token_id=eos_id,
-                eos_token_id=eos_id,
+                pad_token_id=chatbot.tokenizer.eos_token_id,
+                eos_token_id=chatbot.tokenizer.eos_token_id,
                 length_penalty=1.0,
                 early_stopping=False,
-                stopping_criteria=[stopping_criteria],
+                stopping_criteria=[stopping],
             )
-        # Sadece yeni üretilen kısmı çöz
         gen = outputs[0][input_ids.shape[1]:]
-        response = chatbot.tokenizer.decode(gen, skip_special_tokens=True)
-
-        # ŞABLON ZORLAMA + tekrar kırpma
-        response = _enforce_section_template(response)
-        response = _dedupe_and_clip_sections(response)
-
-        # Konuşmaya yerleştir
-        if chatbot.conversation.messages and isinstance(chatbot.conversation.messages[-1], list):
-            chatbot.conversation.messages[-1][-1] = response
-        else:
-            chatbot.conversation.append_message(chatbot.conversation.roles[1], response)
+        text = chatbot.tokenizer.decode(gen, skip_special_tokens=True)
 
+        # Konuşmaya yerleştir (demo gibi)
+        chatbot.conversation.messages[-1][-1] = text
     except Exception as e:
-        return {"error": f"Generation failed: {str(e)}"}
+        return {"error": f"Generation failed: {e}"}
 
-    # Log
+    # Log yaz
     try:
-        history = [(message_text, response)]
-        with open(get_conv_log_filename(), "a") as fout:
-            data = {
-                "type": "chat",
-                "model": "PULSE-7B",
-                "state": history,
-                "images": [image_hash],
-                "images_path": [out_path] if out_path else []
-            }
-            fout.write(json.dumps(data) + "\n")
-        _safe_upload(get_conv_log_filename())
-        if out_path:
-            _safe_upload(out_path)
+        row = {
+            "time": datetime.datetime.now().isoformat(),
+            "type": "chat",
+            "model": "PULSE-7B",
+            "state": [(message_text, text)],
+            "image_hash": img_hash,
+            "image_path": img_path or "",
+        }
+        with open(_conv_log_path(), "a") as f:
+            f.write(json.dumps(row, ensure_ascii=False) + "\n")
+        _safe_upload(_conv_log_path())
+        if img_path:
+            _safe_upload(img_path)
     except Exception as e:
-        print(f"[WARN] Failed to log/upload: {e}")
+        print(f"[log] failed: {e}")
 
-    return {
-        "status": "success",
-        "response": response,
-        "conversation_id": id(chatbot.conversation)
-    }
+    return {"status": "success", "response": text, "conversation_id": id(chatbot.conversation)}
 
-# ---------- API yüzeyi ----------
+# ------------- API Yüzeyi -------------
 
-def query(payload):
-    """HF Endpoint ana giriş noktası"""
+def query(payload: dict):
+    """HF Endpoint ana giriş noktası (demo uyumlu)"""
     global model_initialized, tokenizer, model, image_processor, context_len, args
 
-    # Lazy init
     if not model_initialized:
-        ok = initialize_model()
-        if not ok:
+        if not initialize_model():
             return {"error": "Model initialization failed"}
         model_initialized = True
 
     try:
-        # Metin
-        message_text = (
-            payload.get("message")
-            or payload.get("query")
-            or payload.get("prompt")
-            or payload.get("istem")
-            or ""
-        )
-
-        # Prompt normalization (ECG içeren tüm isteklerde ayrıntılı şablonu zorla)
-        if PROMPT_NORMALIZATION and "ecg" in message_text.lower():
-            if "concise" in message_text.lower():
-                message_text = (
-                    "Provide a short, concise clinical summary of the ECG. "
-                    "Still cover rhythm, rate, axis, PR, QRS, ST-T, QT/QTc in brief."
-                )
-            else:
-                message_text = DEFAULT_ECG_PROMPT
-
-        # Görüntü
-        image_input = (
-            payload.get("image")
-            or payload.get("image_url")
-            or payload.get("img")
-            or None
-        )
-
-        # Parametreler
-        max_output_tokens = int(payload.get("max_output_tokens",
-                                  payload.get("max_new_tokens",
-                                  payload.get("max_tokens", 4096))))
-        repetition_penalty = float(payload.get("repetition_penalty", 1.0))
-        conv_mode_override = payload.get("conv_mode", None)
-
-        if not message_text.strip():
-            return {"error": "Missing prompt text. Use 'message', 'query', 'prompt', or 'istem' key"}
-        if image_input is None:
-            return {"error": "Missing image. Use 'image', 'image_url', or 'img' key"}
+        message = payload.get("message") or payload.get("query") or payload.get("prompt") or payload.get("istem") or ""
+        image   = payload.get("image") or payload.get("image_url") or payload.get("img") or None
+
+        if not message.strip():
+            return {"error": "Missing 'message' text"}
+        if image is None:
+            return {"error": "Missing 'image'. Use 'image', 'image_url', or 'img'."}
+
+        # Demo: slider benzeri parametreler
+        max_new_tokens      = int(payload.get("max_output_tokens", payload.get("max_new_tokens", payload.get("max_tokens", 4096))))
+        temperature         = float(payload.get("temperature", 0.05))
+        top_p               = float(payload.get("top_p", 1.0))
+        repetition_penalty  = float(payload.get("repetition_penalty", 1.0))
+        conv_mode_override  = payload.get("conv_mode", None)
+
+        # (Opsiyonel) deterministik sample için seed (demo defaultu: None)
+        det_seed = payload.get("det_seed", None)
+        if det_seed is not None:
+            try:
+                det_seed = int(det_seed)
+            except Exception:
+                det_seed = None
 
         return generate_response(
-            message_text=message_text,
-            image_input=image_input,
-            max_output_tokens=max_output_tokens,
+            message_text=message,
+            image_input=image,
+            max_new_tokens=max_new_tokens,
+            temperature=temperature,
+            top_p=top_p,
             repetition_penalty=repetition_penalty,
-            conv_mode_override=conv_mode_override
+            conv_mode_override=conv_mode_override,
+            det_seed=det_seed,
         )
     except Exception as e:
-        return {"error": f"Query failed: {str(e)}"}
+        return {"error": f"Query failed: {e}"}
 
 def health_check():
     return {
@@ -660,109 +367,108 @@ def health_check():
         "model_initialized": model_initialized,
         "cuda_available": torch.cuda.is_available(),
         "llava_available": LLAVA_AVAILABLE,
-        "transformers_available": TRANSFORMERS_AVAILABLE,
         "cv2_available": CV2_AVAILABLE,
-        "lazy_loading": True
     }
 
 def get_model_info():
     if not model_initialized:
-        return {"error": "Model not initialized yet", "lazy_loading": True}
+        return {"error": "Model not initialized"}
     return {
         "model_path": args.model_path if args else "Unknown",
-        "model_type": "PULSE-7B",
-        "cuda_available": torch.cuda.is_available(),
-        "device": str(model.device) if model else "Unknown"
+        "context_len": context_len,
+        "device": str(next(model.parameters()).device) if model else "Unknown",
     }
 
-def upvote_last_response(conversation_id):
-    try:
-        vote_last_response({"conversation_id": conversation_id}, "upvote", "PULSE-7B")
-        return {"status": "success", "message": "Thank you for your voting!"}
-    except Exception as e:
-        return {"error": f"Failed to upvote: {str(e)}"}
+# ------------- Model init -------------
 
-def downvote_last_response(conversation_id):
-    try:
-        vote_last_response({"conversation_id": conversation_id}, "downvote", "PULSE-7B")
-        return {"status": "success", "message": "Thank you for your voting!"}
-    except Exception as e:
-        return {"error": f"Failed to downvote: {str(e)}"}
+class _Args:
+    def __init__(self):
+        self.model_path = os.getenv("HF_MODEL_ID", "PULSE-ECG/PULSE-7B")
+        self.model_base = None
+        self.num_gpus   = int(os.getenv("NUM_GPUS", "1"))
+        self.conv_mode  = None
+        self.max_new_tokens = int(os.getenv("MAX_NEW_TOKENS", "4096"))
+        self.num_frames = 16
+        self.load_8bit  = bool(int(os.getenv("LOAD_8BIT", "0")))
+        self.load_4bit  = bool(int(os.getenv("LOAD_4BIT", "0")))
+        self.debug      = bool(int(os.getenv("DEBUG", "0")))
+
+class InferenceDemo:
+    def __init__(self, args, model_path, tokenizer, model, image_processor, context_len):
+        if not LLAVA_AVAILABLE:
+            raise ImportError("LLaVA modules not available")
+        disable_torch_init()
+        self.tokenizer, self.model, self.image_processor, self.context_len = (
+            tokenizer, model, image_processor, context_len
+        )
+        conv_mode_auto = _guess_conv_mode(model_path)
+        if args.conv_mode and args.conv_mode != conv_mode_auto:
+            self.conv_mode = args.conv_mode
+        else:
+            self.conv_mode = conv_mode_auto
+            args.conv_mode = conv_mode_auto
+        self.conversation = conv_templates[self.conv_mode].copy()
+        self.num_frames = args.num_frames
 
-def flag_response(conversation_id):
-    try:
-        vote_last_response({"conversation_id": conversation_id}, "flag", "PULSE-7B")
-        return {"status": "success", "message": "Response flagged successfully"}
-    except Exception as e:
-        return {"error": f"Failed to flag response: {str(e)}"}
+class ChatSessionManager:
+    def __init__(self):
+        self.chatbot = None
+        self.args = 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
+            self.model_path = model_path
+            self.chatbot = InferenceDemo(args, model_path, tokenizer, model, image_processor, context_len)
+    def get_chatbot(self, args, model_path, tokenizer, model, image_processor, context_len):
+        self.init_if_needed(args, model_path, tokenizer, model, image_processor, context_len)
+        return self.chatbot
 
-# ---------- Model init ----------
+chat_manager = ChatSessionManager()
 
 def initialize_model():
     """Modeli yükle (lazy)"""
     global tokenizer, model, image_processor, context_len, args
-
     if not LLAVA_AVAILABLE:
-        print("LLaVA modules not available, skipping model initialization")
+        print("LLaVA not available; cannot init.")
         return False
-
     try:
-        class Args:
-            def __init__(self):
-                self.model_path = os.getenv("HF_MODEL_ID", "PULSE-ECG/PULSE-7B")
-                self.model_base = None
-                self.num_gpus = int(os.getenv("NUM_GPUS", "1"))
-                self.conv_mode = None
-                self.max_new_tokens = int(os.getenv("MAX_NEW_TOKENS", "4096"))
-                self.num_frames = 16
-                self.load_8bit = bool(int(os.getenv("LOAD_8BIT", "0")))
-                self.load_4bit = bool(int(os.getenv("LOAD_4BIT", "0")))
-                self.debug = bool(int(os.getenv("DEBUG", "0")))
-
-        globals()["args"] = Args()
-
+        args = _Args()
         model_name = get_model_name_from_path(args.model_path)
-        loaded = load_pretrained_model(
+        tokenizer, model, image_processor, context_len = load_pretrained_model(
             args.model_path, args.model_base, model_name, args.load_8bit, args.load_4bit
         )
-        globals()["tokenizer"], globals()["model"], globals()["image_processor"], globals()["context_len"] = loaded
-
-        # Device: accelerate devicemap varsa ek .to('cuda') gerekmeyebilir
+        # Cihaz
         try:
             _ = next(model.parameters()).device
         except Exception:
             if torch.cuda.is_available():
                 model = model.to(torch.device("cuda"))
-
-        # Deterministik için dropout vb. kapansın
         model.eval()
-
-        print("[init] tokenizer/image_processor/context_len ready")
+        # Chatbot init
+        chat_manager.init_if_needed(args, args.model_path, tokenizer, model, image_processor, context_len)
+        print("[init] model/tokenizer/image_processor loaded.")
         return True
-
     except Exception as e:
-        print(f"Failed to initialize model: {e}")
+        print(f"[init] failed: {e}")
         return False
 
-# ---------- HF EndpointHandler ----------
+# ------------- HF EndpointHandler -------------
 
 class EndpointHandler:
-    """Hugging Face endpoint handler class"""
-
+    """Hugging Face Endpoint uyumlu sınıf"""
     def __init__(self, model_dir):
         self.model_dir = model_dir
         print(f"EndpointHandler initialized with model_dir: {model_dir}")
-
     def __call__(self, payload):
         if "inputs" in payload:
             return query(payload["inputs"])
         return query(payload)
-
     def health_check(self):
         return health_check()
-
     def get_model_info(self):
         return get_model_info()
 
 if __name__ == "__main__":
-    print("Handler loaded. Use `query` or `EndpointHandler` in HF Inference Endpoints.")
+    print("Handler ready. Use `EndpointHandler` or `query` for HF Inference Endpoints.")
+