Update handler.py

handler.py

@@ -1,230 +1,186 @@
-from typing import Dict, List, Any, Optional
+"""
+Custom Inference Handler for Huseyin/tekno25 Model
+Hugging Face Inference Endpoints için özelleştirilmiş handler
+"""
+
 import torch
+from typing import Dict, List, Any
 from transformers import AutoModelForCausalLM, AutoTokenizer
-import json
 import logging
 
-# Loglama ayarları
+# Logger ayarla
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
+
 class EndpointHandler:
     def __init__(self, path=""):
         """
-        Qwen2 7.6B modelini optimize edilmiş şekilde yükle
-        """
-        try:
-            logger.info(f"Model yükleniyor: {path}")
-            
-            # Tokenizer'ı yükle - Qwen2 için trust_remote_code gerekli
-            self.tokenizer = AutoTokenizer.from_pretrained(
-                path,
-                trust_remote_code=True,
-                use_fast=True  # Fast tokenizer kullan
-            )
-            
-            # Model konfigürasyonu
-            model_kwargs = {
-                "torch_dtype": torch.bfloat16 if torch.cuda.is_bf16_supported() else torch.float16,
-                "device_map": "auto",
-                "trust_remote_code": True,
-                "low_cpu_mem_usage": True,  # Bellek optimizasyonu
-            }
-            
-            # Modeli yükle
-            self.model = AutoModelForCausalLM.from_pretrained(
-                path,
-                **model_kwargs
-            )
-            
-            # Model'i eval moduna al
-            self.model.eval()
-            
-            # Tokenizer ayarları
-            if self.tokenizer.pad_token is None:
-                self.tokenizer.pad_token = self.tokenizer.eos_token
-            if self.tokenizer.pad_token_id is None:
-                self.tokenizer.pad_token_id = self.tokenizer.eos_token_id
-                
-            # Chat template kontrolü
-            self.has_chat_template = hasattr(self.tokenizer, 'chat_template') and self.tokenizer.chat_template is not None
-            
-            logger.info(f"Model başarıyla yüklendi. Chat template: {self.has_chat_template}")
-            logger.info(f"Device: {next(self.model.parameters()).device}")
-            logger.info(f"Dtype: {next(self.model.parameters()).dtype}")
-            
-        except Exception as e:
-            logger.error(f"Model yükleme hatası: {str(e)}")
-            raise RuntimeError(f"Model initialization failed: {str(e)}")
-    
-    def format_chat_input(self, messages: List[Dict[str, str]]) -> str:
-        """
-        Chat formatında gelen mesajları işle
+        Model ve tokenizer'ı yükle
+        
+        Args:
+            path: Model dosyalarının bulunduğu dizin
         """
-        if self.has_chat_template:
-            return self.tokenizer.apply_chat_template(
-                messages,
-                tokenize=False,
-                add_generation_prompt=True
-            )
-        else:
-            # Fallback: Basit format
-            formatted = ""
-            for message in messages:
-                role = message.get("role", "user")
-                content = message.get("content", "")
-                if role == "system":
-                    formatted += f"System: {content}\n"
-                elif role == "user":
-                    formatted += f"User: {content}\n"
-                elif role == "assistant":
-                    formatted += f"Assistant: {content}\n"
-            formatted += "Assistant: "
-            return formatted
+        logger.info(f"Model yükleniyor: {path}")
+        
+        # Tokenizer'ı yükle
+        self.tokenizer = AutoTokenizer.from_pretrained(
+            path,
+            trust_remote_code=True
+        )
+        
+        # Modeli yükle
+        self.model = AutoModelForCausalLM.from_pretrained(
+            path,
+            torch_dtype=torch.float16,  # Bellek optimizasyonu için
+            device_map="auto",  # Otomatik cihaz ataması
+            trust_remote_code=True
+        )
+        
+        # Eğer tokenizer'da pad_token yoksa ekle
+        if self.tokenizer.pad_token is None:
+            self.tokenizer.pad_token = self.tokenizer.eos_token
+        
+        logger.info("Model başarıyla yüklendi!")
     
-    @torch.inference_mode()
     def __call__(self, data: Dict[str, Any]) -> List[Dict[str, Any]]:
         """
-        Inference endpoint - Hem text hem de chat formatını destekler
+        Inference endpoint'i için ana fonksiyon
+        
+        Args:
+            data: İstek verisi
+                - inputs (str veya List[str]): Giriş metni/metinleri
+                - parameters (dict, optional): Generasyon parametreleri
+        
+        Returns:
+            List[Dict]: Üretilen metin(ler)
         """
         try:
-            # Input türünü belirle
-            inputs = data.pop("inputs", None)
-            messages = data.pop("messages", None)
-            
-            # Input kontrolü
-            if not inputs and not messages:
-                return [{"error": "Either 'inputs' or 'messages' must be provided"}]
-            
-            # Chat format'ı kontrol et
-            if messages:
-                text_input = self.format_chat_input(messages)
-            else:
-                text_input = inputs
-            
-            # Parametreleri al
-            parameters = data.pop("parameters", {})
-            
-            # Generation parametreleri
-            max_new_tokens = parameters.get("max_new_tokens", 256)
-            temperature = parameters.get("temperature", 0.7)
-            top_p = parameters.get("top_p", 0.9)
-            top_k = parameters.get("top_k", 50)
-            do_sample = parameters.get("do_sample", True)
-            repetition_penalty = parameters.get("repetition_penalty", 1.1)
-            num_return_sequences = parameters.get("num_return_sequences", 1)
-            stop_sequences = parameters.get("stop_sequences", None)
-            
-            logger.info(f"Processing input (length: {len(text_input)})")
-            
-            # Tokenize
-            inputs_encoded = self.tokenizer(
-                text_input,
-                return_tensors="pt",
-                padding=True,
-                truncation=True,
-                max_length=min(2048, self.model.config.max_position_embeddings),
-                return_attention_mask=True
-            )
-            
-            # Device'a taşı
-            input_ids = inputs_encoded["input_ids"].to(self.model.device)
-            attention_mask = inputs_encoded["attention_mask"].to(self.model.device)
-            
-            # Stopping criteria ayarla
-            stop_token_ids = []
-            if stop_sequences:
-                for seq in stop_sequences:
-                    tokens = self.tokenizer.encode(seq, add_special_tokens=False)
-                    stop_token_ids.extend(tokens)
-            
-            # Generate
-            generation_kwargs = {
-                "input_ids": input_ids,
-                "attention_mask": attention_mask,
-                "max_new_tokens": max_new_tokens,
-                "temperature": temperature if do_sample else 1.0,
-                "top_p": top_p if do_sample else 1.0,
-                "top_k": top_k if do_sample else None,
-                "do_sample": do_sample,
-                "repetition_penalty": repetition_penalty,
-                "num_return_sequences": num_return_sequences,
-                "pad_token_id": self.tokenizer.pad_token_id,
-                "eos_token_id": self.tokenizer.eos_token_id,
-                "use_cache": True,
+            # Giriş verilerini al
+            inputs = data.get("inputs", "")
+            parameters = data.get("parameters", {})
+            
+            # Eğer inputs bir string ise listeye çevir
+            if isinstance(inputs, str):
+                inputs = [inputs]
+            
+            # Varsayılan parametreler
+            default_params = {
+                "max_new_tokens": 512,
+                "temperature": 0.7,
+                "top_p": 0.9,
+                "top_k": 50,
+                "do_sample": True,
+                "repetition_penalty": 1.1,
+                "return_full_text": False
             }
             
-            # Stop tokens ekle
-            if stop_token_ids:
-                generation_kwargs["eos_token_id"] = stop_token_ids
+            # Kullanıcı parametrelerini varsayılanlarla birleştir
+            generation_params = {**default_params, **parameters}
             
-            # Generate
-            outputs = self.model.generate(**generation_kwargs)
+            # return_full_text parametresini ayır
+            return_full_text = generation_params.pop("return_full_text", False)
             
-            # Decode
+            # Batch işleme için sonuçları topla
             results = []
-            for output in outputs:
-                # Input kısmını çıkar
-                generated_ids = output[input_ids.shape[-1]:]
-                generated_text = self.tokenizer.decode(
-                    generated_ids,
-                    skip_special_tokens=True,
-                    clean_up_tokenization_spaces=True
-                )
+            
+            for text_input in inputs:
+                # Tokenize et
+                encoded_inputs = self.tokenizer(
+                    text_input,
+                    return_tensors="pt",
+                    padding=True,
+                    truncation=True,
+                    max_length=2048
+                ).to(self.model.device)
+                
+                # Çıktı üret
+                with torch.no_grad():
+                    output_ids = self.model.generate(
+                        **encoded_inputs,
+                        **generation_params
+                    )
+                
+                # Decode et
+                if return_full_text:
+                    # Tam metni döndür (giriş + üretilen)
+                    generated_text = self.tokenizer.decode(
+                        output_ids[0],
+                        skip_special_tokens=True
+                    )
+                else:
+                    # Sadece üretilen kısmı döndür
+                    input_length = encoded_inputs.input_ids.shape[1]
+                    generated_text = self.tokenizer.decode(
+                        output_ids[0][input_length:],
+                        skip_special_tokens=True
+                    )
                 
                 results.append({
-                    "generated_text": generated_text,
-                    "details": {
-                        "finish_reason": "length" if len(generated_ids) >= max_new_tokens else "stop",
-                        "generated_tokens": len(generated_ids),
-                        "input_tokens": input_ids.shape[-1]
-                    }
+                    "generated_text": generated_text
                 })
             
-            logger.info(f"Generation completed. Generated {len(results)} sequences")
-            
-            # Tek sonuç istenmişse direkt döndür
-            if num_return_sequences == 1:
-                return results
-            else:
-                return [{"results": results}]
+            return results
             
-        except torch.cuda.OutOfMemoryError:
-            logger.error("GPU bellek yetersiz!")
-            return [{
-                "error": "GPU out of memory. Try reducing max_new_tokens or input length",
-                "type": "memory_error"
-            }]
         except Exception as e:
-            logger.error(f"Inference hatası: {str(e)}")
-            import traceback
-            logger.error(traceback.format_exc())
+            logger.error(f"Inference sırasında hata: {str(e)}")
             return [{
                 "error": str(e),
-                "type": "inference_error",
-                "traceback": traceback.format_exc()
+                "error_type": type(e).__name__
             }]
+
+
+# Alternatif: Pipeline kullanımı için handler
+class PipelineHandler:
+    """
+    Transformers pipeline kullanarak daha basit bir handler
+    """
+    
+    def __init__(self, path=""):
+        from transformers import pipeline
+        
+        logger.info(f"Pipeline yükleniyor: {path}")
+        
+        self.pipeline = pipeline(
+            "text-generation",
+            model=path,
+            torch_dtype=torch.float16,
+            device_map="auto",
+            trust_remote_code=True
+        )
+        
+        logger.info("Pipeline başarıyla yüklendi!")
     
-    def health_check(self) -> Dict[str, Any]:
+    def __call__(self, data: Dict[str, Any]) -> List[Dict[str, Any]]:
         """
-        Endpoint sağlık kontrolü
+        Pipeline tabanlı inference
         """
         try:
-            test_input = "Test"
-            inputs = self.tokenizer(test_input, return_tensors="pt")
-            with torch.no_grad():
-                _ = self.model.generate(
-                    inputs.input_ids.to(self.model.device),
-                    max_new_tokens=5
-                )
-            return {
-                "status": "healthy",
-                "model": "Qwen2-7.6B",
-                "device": str(next(self.model.parameters()).device),
-                "dtype": str(next(self.model.parameters()).dtype)
+            inputs = data.get("inputs", "")
+            parameters = data.get("parameters", {})
+            
+            # Varsayılan parametreler
+            default_params = {
+                "max_new_tokens": 512,
+                "temperature": 0.7,
+                "top_p": 0.9,
+                "do_sample": True,
+                "return_full_text": False
             }
+            
+            generation_params = {**default_params, **parameters}
+            
+            # Pipeline'ı çalıştır
+            outputs = self.pipeline(
+                inputs,
+                **generation_params
+            )
+            
+            return outputs
+            
         except Exception as e:
-            return {
-                "status": "unhealthy",
-                "error": str(e)
-            }
+            logger.error(f"Pipeline inference hatası: {str(e)}")
+            return [{
+                "error": str(e),
+                "error_type": type(e).__name__
+            }]