Upload 14 files

major update with deepseek integration

deployment_guide.md

@@ -0,0 +1,133 @@
+# PULSE-7B Handler Deployment Guide
+
+## 🚀 Deployment Rehberi
+
+### Gereksinimler
+- Python 3.8+
+- CUDA 11.8+ (GPU kullanımı için)
+- Minimum 16GB RAM (CPU), 8GB VRAM (GPU)
+
+### Kurulum
+
+1. **Bağımlılıkları yükleyin:**
+```bash
+pip install -r requirements.txt
+```
+
+2. **Flash Attention (isteğe bağlı, performans için):**
+```bash
+pip install flash-attn --no-build-isolation
+```
+
+### HuggingFace Inference Deployment
+
+#### 1. Model Repository Yapısı
+```
+your-model-repo/
+├── handler.py
+├── config.json
+├── generation_config.json
+├── requirements.txt
+├── model.safetensors.index.json
+├── tokenizer_config.json
+├── special_tokens_map.json
+└── tokenizer.model
+```
+
+#### 2. Endpoint Oluşturma
+```bash
+# HuggingFace CLI ile deploy
+huggingface-cli login
+huggingface-cli repo create your-pulse-endpoint --type=space
+```
+
+#### 3. Test Requests
+
+**Image URL ile test:**
+```bash
+curl -X POST "YOUR_ENDPOINT_URL" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "inputs": {
+      "query": "Analyze this ECG image",
+      "image": "https://i.imgur.com/7uuejqO.jpeg"
+    },
+    "parameters": {
+      "temperature": 0.2,
+      "max_new_tokens": 512
+    }
+  }'
+```
+
+**Base64 ile test:**
+```bash
+curl -X POST "YOUR_ENDPOINT_URL" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "inputs": {
+      "query": "What do you see in this ECG?",
+      "image": "data:image/jpeg;base64,/9j/4AAQ..."
+    },
+    "parameters": {
+      "temperature": 0.2
+    }
+  }'
+```
+
+### Performans Optimizasyonları
+
+#### GPU Memory Optimizasyonu
+- `torch_dtype=torch.bfloat16` kullanın
+- `low_cpu_mem_usage=True` ayarlayın
+- `device_map="auto"` ile otomatik dağıtım
+
+#### CPU Optimizasyonu
+- `torch_dtype=torch.float32` kullanın
+- Thread sayısını ayarlayın: `torch.set_num_threads(4)`
+
+### Monitoring ve Debugging
+
+#### Log Seviyeleri
+```python
+import logging
+logging.basicConfig(level=logging.INFO)
+```
+
+#### Memory Usage
+```python
+import torch
+print(f"GPU Memory: {torch.cuda.memory_allocated()/1024**3:.2f}GB")
+```
+
+### Troubleshooting
+
+#### Common Issues:
+
+1. **CUDA Out of Memory**
+   - Batch size'ı azaltın
+   - `max_new_tokens` değerini düşürün
+   - Gradient checkpointing kullanın
+
+2. **Slow Image Processing**
+   - Image timeout değerini artırın
+   - Image resize threshold ayarlayın
+
+3. **Model Loading Issues**
+   - HuggingFace token'ını kontrol edin
+   - Network bağlantısını doğrulayın
+   - Cache dizinini temizleyin
+
+### Security Best Practices
+
+- Image URL'leri validate edin
+- Base64 boyut limitlerini ayarlayın
+- Rate limiting uygulayın
+- Input sanitization yapın
+
+### Monitoring Metrics
+
+- Response time
+- Memory usage
+- Error rates
+- Image processing success rate
+- Token generation speed

generation_config.json

@@ -1,8 +1,49 @@
 {
+  "_from_model_config": true,
   "attn_implementation": "flash_attention_2",
   "bos_token_id": 1,
   "eos_token_id": 2,
-  "max_length": 4096,
   "pad_token_id": 0,
-  "transformers_version": "4.37.2"
+  "max_length": 4096,
+  "max_new_tokens": 2048,
+  "min_length": 1,
+  "min_new_tokens": 1,
+  "early_stopping": false,
+  "max_time": null,
+  "do_sample": true,
+  "num_beams": 1,
+  "num_beam_groups": 1,
+  "penalty_alpha": null,
+  "use_cache": true,
+  "temperature": 0.2,
+  "top_k": 50,
+  "top_p": 0.9,
+  "typical_p": 1.0,
+  "epsilon_cutoff": 0.0,
+  "eta_cutoff": 0.0,
+  "diversity_penalty": 0.0,
+  "repetition_penalty": 1.05,
+  "encoder_repetition_penalty": 1.0,
+  "length_penalty": 1.0,
+  "no_repeat_ngram_size": 0,
+  "bad_words_ids": null,
+  "force_words_ids": null,
+  "renormalize_logits": false,
+  "constraints": null,
+  "forced_bos_token_id": null,
+  "forced_eos_token_id": null,
+  "remove_invalid_values": false,
+  "exponential_decay_length_penalty": null,
+  "suppress_tokens": null,
+  "begin_suppress_tokens": null,
+  "forced_decoder_ids": null,
+  "sequence_bias": null,
+  "guidance_scale": null,
+  "low_memory": null,
+  "num_return_sequences": 1,
+  "output_attentions": false,
+  "output_hidden_states": false,
+  "output_scores": false,
+  "return_dict_in_generate": false,
+  "transformers_version": "4.40.0"
 }

handler.py

@@ -10,6 +10,23 @@ import base64
 from io import BytesIO
 from PIL import Image
 import requests
+import time
+
+# Import utilities if available
+try:
+    from utils import (
+        performance_monitor, 
+        validate_image_input, 
+        sanitize_parameters, 
+        get_system_info,
+        create_health_check,
+        deepseek_client
+    )
+    UTILS_AVAILABLE = True
+except ImportError:
+    UTILS_AVAILABLE = False
+    deepseek_client = None
+    print("⚠️ Utils module not found - performance monitoring and DeepSeek integration disabled")
 
 
 class EndpointHandler:
@@ -171,6 +188,56 @@ class EndpointHandler:
         
         return None
 
+    def add_turkish_commentary(self, response: Dict[str, Any], enable_commentary: bool, timeout: int = 30) -> Dict[str, Any]:
+        """Add Turkish commentary to the response using DeepSeek API"""
+        if not enable_commentary:
+            return response
+            
+        if not UTILS_AVAILABLE or not deepseek_client:
+            print("⚠️ DeepSeek client not available - skipping Turkish commentary")
+            response["commentary_status"] = "unavailable"
+            return response
+            
+        if not deepseek_client.is_available():
+            print("⚠️ DeepSeek API key not configured - skipping Turkish commentary")
+            response["commentary_status"] = "api_key_missing"
+            return response
+            
+        generated_text = response.get("generated_text", "")
+        if not generated_text:
+            print("⚠️ No generated text to comment on")
+            response["commentary_status"] = "no_text"
+            return response
+            
+        print("🔄 DeepSeek ile Türkçe yorum ekleniyor...")
+        commentary_result = deepseek_client.get_turkish_commentary(generated_text, timeout)
+        
+        if commentary_result["success"]:
+            response["comment_text"] = commentary_result["comment_text"]
+            response["commentary_model"] = commentary_result.get("model", "deepseek-chat")
+            response["commentary_tokens"] = commentary_result.get("tokens_used", 0)
+            response["commentary_status"] = "success"
+            print("✅ Türkçe yorum başarıyla eklendi")
+        else:
+            response["comment_text"] = ""
+            response["commentary_error"] = commentary_result["error"]
+            response["commentary_status"] = "failed"
+            print(f"❌ Türkçe yorum eklenemedi: {commentary_result['error']}")
+            
+        return response
+
+    def health_check(self) -> Dict[str, Any]:
+        """Health check endpoint"""
+        if UTILS_AVAILABLE:
+            return create_health_check()
+        else:
+            return {
+                'status': 'healthy',
+                'model': 'PULSE-7B',
+                'timestamp': time.time(),
+                'handler_version': '2.0.0'
+            }
+
     def __call__(self, data: Dict[str, Any]) -> List[Dict[str, Any]]:
         """
         Main processing function - where the magic happens!
@@ -189,6 +256,12 @@ class EndpointHandler:
                 "handler": "Ubden® Team Enhanced Handler"
             }]
         
+        # Performance monitoring
+        start_time = time.time()
+        request_type = "text_only"
+        success = False
+        image_processing_time = 0.0
+        
         try:
             # Parse the inputs - flexible format support
             inputs = data.get("inputs", "")
@@ -203,7 +276,20 @@ class EndpointHandler:
                 # Check for image in various formats
                 image_input = inputs.get("image", inputs.get("image_url", inputs.get("image_base64", None)))
                 if image_input:
+                    # Determine request type and validate input
+                    if UTILS_AVAILABLE:
+                        validation = validate_image_input(image_input)
+                        request_type = validation.get('type', 'unknown')
+                        if request_type == 'url':
+                            request_type = 'image_url'
+                    else:
+                        request_type = 'image_url' if image_input.startswith(('http://', 'https://')) else 'base64'
+                    
+                    # Process image with timing
+                    image_start = time.time()
                     image = self.process_image_input(image_input)
+                    image_processing_time = time.time() - image_start
+                    
                     if image:
                         print(f"✅ Image processed successfully: {image.size[0]}x{image.size[1]} pixels")
                         # Add image context to the prompt for better processing
@@ -220,13 +306,29 @@ class EndpointHandler:
             
             # Get generation parameters with sensible defaults
             parameters = data.get("parameters", {})
-            max_new_tokens = min(parameters.get("max_new_tokens", 512), 2048)  # Increased default
-            temperature = max(0.01, min(parameters.get("temperature", 0.2), 2.0))  # Clamp temperature
-            top_p = max(0.01, min(parameters.get("top_p", 0.9), 1.0))  # Clamp top_p
-            do_sample = parameters.get("do_sample", temperature > 0.01)  # Auto-set based on temperature
-            repetition_penalty = max(1.0, min(parameters.get("repetition_penalty", 1.05), 2.0))  # Clamp penalty
-            stop_sequences = parameters.get("stop", ["</s>"])  # Support stop sequences
-            return_full_text = parameters.get("return_full_text", False)
+            
+            # Check if Turkish commentary is requested
+            enable_turkish_commentary = parameters.get("enable_turkish_commentary", True)  # Default true
+            deepseek_timeout = parameters.get("deepseek_timeout", 30)
+            
+            # Use utils for parameter sanitization if available
+            if UTILS_AVAILABLE:
+                sanitized_params = sanitize_parameters(parameters)
+                max_new_tokens = sanitized_params["max_new_tokens"]
+                temperature = sanitized_params["temperature"]
+                top_p = sanitized_params["top_p"]
+                repetition_penalty = sanitized_params["repetition_penalty"]
+                stop_sequences = sanitized_params["stop"]
+                return_full_text = sanitized_params["return_full_text"]
+                do_sample = sanitized_params["do_sample"]
+            else:
+                max_new_tokens = min(parameters.get("max_new_tokens", 512), 2048)
+                temperature = max(0.01, min(parameters.get("temperature", 0.2), 2.0))
+                top_p = max(0.01, min(parameters.get("top_p", 0.9), 1.0))
+                do_sample = parameters.get("do_sample", temperature > 0.01)
+                repetition_penalty = max(1.0, min(parameters.get("repetition_penalty", 1.05), 2.0))
+                stop_sequences = parameters.get("stop", ["</s>"])
+                return_full_text = parameters.get("return_full_text", False)
             
             print(f"🎛️ Generation params: max_tokens={max_new_tokens}, temp={temperature}, top_p={top_p}, rep_penalty={repetition_penalty}")
             
@@ -255,17 +357,43 @@ class EndpointHandler:
                         if generated_text.endswith(stop_seq):
                             generated_text = generated_text[:-len(stop_seq)].rstrip()
                     
-                    return [{
+                    success = True
+                    result = {
                         "generated_text": generated_text,
                         "model": "PULSE-7B",
                         "processing_method": "pipeline"
-                    }]
+                    }
+                    
+                    # Add Turkish commentary if requested
+                    result = self.add_turkish_commentary(result, enable_turkish_commentary, deepseek_timeout)
+                    
+                    # Log performance metrics
+                    if UTILS_AVAILABLE:
+                        generation_time = time.time() - start_time
+                        performance_monitor.log_request(
+                            request_type, success, generation_time, image_processing_time
+                        )
+                    
+                    return [result]
                 else:
-                    return [{
+                    success = True
+                    result_dict = {
                         "generated_text": str(result),
                         "model": "PULSE-7B", 
                         "processing_method": "pipeline"
-                    }]
+                    }
+                    
+                    # Add Turkish commentary if requested
+                    result_dict = self.add_turkish_commentary(result_dict, enable_turkish_commentary, deepseek_timeout)
+                    
+                    # Log performance metrics
+                    if UTILS_AVAILABLE:
+                        generation_time = time.time() - start_time
+                        performance_monitor.log_request(
+                            request_type, success, generation_time, image_processing_time
+                        )
+                    
+                    return [result_dict]
             
             # Manual generation mode
             else:
@@ -323,15 +451,36 @@ class EndpointHandler:
                     if generated_text.endswith(stop_seq):
                         generated_text = generated_text[:-len(stop_seq)].rstrip()
                 
-                return [{
+                success = True
+                result = {
                     "generated_text": generated_text.strip(),
                     "model": "PULSE-7B",
                     "processing_method": "manual"
-                }]
+                }
+                
+                # Add Turkish commentary if requested
+                result = self.add_turkish_commentary(result, enable_turkish_commentary, deepseek_timeout)
+                
+                # Log performance metrics
+                if UTILS_AVAILABLE:
+                    generation_time = time.time() - start_time
+                    performance_monitor.log_request(
+                        request_type, success, generation_time, image_processing_time
+                    )
+                
+                return [result]
             
         except Exception as e:
             error_msg = f"Generation error: {str(e)}"
             print(f"❌ {error_msg}")
+            
+            # Log failed request
+            if UTILS_AVAILABLE:
+                generation_time = time.time() - start_time
+                performance_monitor.log_request(
+                    request_type, success, generation_time, image_processing_time
+                )
+            
             return [{
                 "generated_text": "",
                 "error": error_msg,

requirements.txt

@@ -3,4 +3,20 @@ torch>=2.1.0
 accelerate>=0.25.0
 sentencepiece
 safetensors
-protobuf
+protobuf
+
+# Image processing dependencies
+Pillow>=9.0.0
+requests>=2.28.0
+
+# Optional performance improvements
+flash-attn>=2.0.0; sys_platform != "darwin"
+bitsandbytes>=0.41.0; sys_platform != "darwin"
+
+# Utility libraries
+numpy>=1.21.0
+typing-extensions>=4.0.0
+psutil>=5.8.0
+
+# HuggingFace Inference specific
+huggingface-hub>=0.16.0

test_requests.json

@@ -1,142 +1,220 @@
-{
-  "test_requests": {
-    "image_url_request": {
-      "description": "ECG analizi için image URL ile istek",
-      "request": {
-        "inputs": {
-          "query": "What are the main features and diagnosis in this ECG image? Provide a concise, clinical answer.",
-          "image": "https://i.imgur.com/7uuejqO.jpeg"
-        },
-        "parameters": {
-          "max_new_tokens": 512,
-          "temperature": 0.2,
-          "top_p": 0.9,
-          "repetition_penalty": 1.05,
-          "stop": ["</s>"],
-          "return_full_text": false
-        }
-      }
-    },
-    
-    "base64_request": {
-      "description": "ECG analizi için base64 encoded image ile istek",
-      "request": {
-        "inputs": {
-          "query": "What are the main features and diagnosis in this ECG image? Provide a concise, clinical answer.",
-          "image": "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAAYEBQYFBAYGBQYHBwYIChAKCgkJChQODwwQFxQYGBcUFhYaHSUfGhsjHBYWICwgIyYnKSopGR8tMC0oMCUoKSj/2wBDAQcHBwoIChMKChMoGhYaKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCj/wAARCAABAAEDASIAAhEBAxEB/8QAFQABAQAAAAAAAAAAAAAAAAAAAAv/xAAUEAEAAAAAAAAAAAAAAAAAAAAA/8QAFQEBAQAAAAAAAAAAAAAAAAAAAAX/xAAUEQEAAAAAAAAAAAAAAAAAAAAA/9oADAMBAAIRAxEAPwCdABmX/9k="
-        },
-        "parameters": {
-          "max_new_tokens": 512,
-          "temperature": 0.2,
-          "top_p": 0.9,
-          "repetition_penalty": 1.05,
-          "stop": ["</s>"],
-          "return_full_text": false
-        }
-      }
-    },
-
-    "minimal_url_request": {
-      "description": "Minimal parametrelerle image URL isteği",
-      "request": {
-        "inputs": {
-          "query": "Analyze this ECG image.",
-          "image": "https://i.imgur.com/7uuejqO.jpeg"
-        },
-        "parameters": {
-          "temperature": 0.2
-        }
-      }
-    },
-
-    "minimal_base64_request": {
-      "description": "Minimal parametrelerle base64 isteği",
-      "request": {
-        "inputs": {
-          "query": "Analyze this ECG image.",
-          "image": "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAAYEBQYFBAYGBQYHBwYIChAKCgkJChQODwwQFxQYGBcUFhYaHSUfGhsjHBYWICwgIyYnKSopGR8tMC0oMCUoKSj/2wBDAQcHBwoIChMKChMoGhYaKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCj/wAARCAABAAEDASIAAhEBAxEB/8QAFQABAQAAAAAAAAAAAAAAAAAAAAv/xAAUEAEAAAAAAAAAAAAAAAAAAAAA/8QAFQEBAQAAAAAAAAAAAAAAAAAAAAX/xAAUEQEAAAAAAAAAAAAAAAAAAAAA/9oADAMBAAIRAxEAPwCdABmX/9k="
-        },
-        "parameters": {
-          "temperature": 0.2
-        }
-      }
-    },
-
-    "text_only_request": {
-      "description": "Sadece text ile istek (image olmadan)",
-      "request": {
-        "inputs": {
-          "query": "What are the common causes of atrial fibrillation?"
-        },
-        "parameters": {
-          "max_new_tokens": 256,
-          "temperature": 0.3,
-          "top_p": 0.9
-        }
-      }
-    },
-
-    "advanced_parameters_request": {
-      "description": "Gelişmiş parametrelerle image URL isteği",
-      "request": {
-        "inputs": {
-          "query": "Provide detailed ECG analysis including rhythm, rate, intervals, and potential abnormalities.",
-          "image": "https://i.imgur.com/7uuejqO.jpeg"
-        },
-        "parameters": {
-          "max_new_tokens": 1024,
-          "temperature": 0.1,
-          "top_p": 0.95,
-          "repetition_penalty": 1.1,
-          "stop": ["</s>", "\n\n"],
-          "return_full_text": false,
-          "do_sample": true
-        }
-      }
-    }
-  },
-
-  "expected_response_format": {
-    "description": "Beklenen response formatı",
-    "format": [
-      {
-        "generated_text": "ECG analysis response text here...",
-        "model": "PULSE-7B",
-        "processing_method": "pipeline"
-      }
-    ]
-  },
-
-  "error_response_format": {
-    "description": "Hata durumunda response formatı",
-    "format": [
-      {
-        "generated_text": "",
-        "error": "Error message here...",
-        "model": "PULSE-7B",
-        "handler": "Ubden® Team Enhanced Handler",
-        "success": false
-      }
-    ]
-  },
-
-  "usage_notes": {
-    "supported_image_formats": [
-      "JPEG", "PNG", "GIF", "BMP", "WebP"
-    ],
-    "supported_input_methods": [
-      "HTTP/HTTPS URL",
-      "Base64 encoded with data URI prefix",
-      "Raw base64 string"
-    ],
-    "parameter_limits": {
-      "max_new_tokens": "1-2048",
-      "temperature": "0.01-2.0",
-      "top_p": "0.01-1.0",
-      "repetition_penalty": "1.0-2.0"
-    },
-    "query_field_alternatives": [
-      "query", "text", "prompt"
-    ]
-  }
-}
+{
+  "test_requests": {
+    "image_url_request": {
+      "description": "ECG analizi için image URL ile istek",
+      "request": {
+        "inputs": {
+          "query": "What are the main features and diagnosis in this ECG image? Provide a concise, clinical answer.",
+          "image": "https://i.imgur.com/7uuejqO.jpeg"
+        },
+        "parameters": {
+          "max_new_tokens": 512,
+          "temperature": 0.2,
+          "top_p": 0.9,
+          "repetition_penalty": 1.05,
+          "stop": ["</s>"],
+          "return_full_text": false
+        }
+      }
+    },
+    
+    "base64_request": {
+      "description": "ECG analizi için base64 encoded image ile istek",
+      "request": {
+        "inputs": {
+          "query": "What are the main features and diagnosis in this ECG image? Provide a concise, clinical answer.",
+          "image": "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAAYEBQYFBAYGBQYHBwYIChAKCgkJChQODwwQFxQYGBcUFhYaHSUfGhsjHBYWICwgIyYnKSopGR8tMC0oMCUoKSj/2wBDAQcHBwoIChMKChMoGhYaKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCj/wAARCAABAAEDASIAAhEBAxEB/8QAFQABAQAAAAAAAAAAAAAAAAAAAAv/xAAUEAEAAAAAAAAAAAAAAAAAAAAA/8QAFQEBAQAAAAAAAAAAAAAAAAAAAAX/xAAUEQEAAAAAAAAAAAAAAAAAAAAA/9oADAMBAAIRAxEAPwCdABmX/9k="
+        },
+        "parameters": {
+          "max_new_tokens": 512,
+          "temperature": 0.2,
+          "top_p": 0.9,
+          "repetition_penalty": 1.05,
+          "stop": ["</s>"],
+          "return_full_text": false
+        }
+      }
+    },
+
+    "minimal_url_request": {
+      "description": "Minimal parametrelerle image URL isteği",
+      "request": {
+        "inputs": {
+          "query": "Analyze this ECG image.",
+          "image": "https://i.imgur.com/7uuejqO.jpeg"
+        },
+        "parameters": {
+          "temperature": 0.2
+        }
+      }
+    },
+
+    "minimal_base64_request": {
+      "description": "Minimal parametrelerle base64 isteği",
+      "request": {
+        "inputs": {
+          "query": "Analyze this ECG image.",
+          "image": "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAAYEBQYFBAYGBQYHBwYIChAKCgkJChQODwwQFxQYGBcUFhYaHSUfGhsjHBYWICwgIyYnKSopGR8tMC0oMCUoKSj/2wBDAQcHBwoIChMKChMoGhYaKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCj/wAARCAABAAEDASIAAhEBAxEB/8QAFQABAQAAAAAAAAAAAAAAAAAAAAv/xAAUEAEAAAAAAAAAAAAAAAAAAAAA/8QAFQEBAQAAAAAAAAAAAAAAAAAAAAX/xAAUEQEAAAAAAAAAAAAAAAAAAAAA/9oADAMBAAIRAxEAPwCdABmX/9k="
+        },
+        "parameters": {
+          "temperature": 0.2
+        }
+      }
+    },
+
+    "text_only_request": {
+      "description": "Sadece text ile istek (image olmadan)",
+      "request": {
+        "inputs": {
+          "query": "What are the common causes of atrial fibrillation?"
+        },
+        "parameters": {
+          "max_new_tokens": 256,
+          "temperature": 0.3,
+          "top_p": 0.9
+        }
+      }
+    },
+
+    "advanced_parameters_request": {
+      "description": "Gelişmiş parametrelerle image URL isteği",
+      "request": {
+        "inputs": {
+          "query": "Provide detailed ECG analysis including rhythm, rate, intervals, and potential abnormalities.",
+          "image": "https://i.imgur.com/7uuejqO.jpeg"
+        },
+        "parameters": {
+          "max_new_tokens": 1024,
+          "temperature": 0.1,
+          "top_p": 0.95,
+          "repetition_penalty": 1.1,
+          "stop": ["</s>", "\n\n"],
+          "return_full_text": false,
+          "do_sample": true
+        }
+      }
+    },
+
+    "deepseek_enabled_request": {
+      "description": "DeepSeek Türkçe yorum özelliği aktif - Image URL",
+      "request": {
+        "inputs": {
+          "query": "What are the main features and diagnosis in this ECG image? Provide a concise, clinical answer.",
+          "image": "https://i.imgur.com/7uuejqO.jpeg"
+        },
+        "parameters": {
+          "max_new_tokens": 512,
+          "temperature": 0.2,
+          "top_p": 0.9,
+          "repetition_penalty": 1.05,
+          "enable_turkish_commentary": true,
+          "deepseek_timeout": 30
+        }
+      }
+    },
+
+    "deepseek_enabled_base64_request": {
+      "description": "DeepSeek Türkçe yorum özelliği aktif - Base64",
+      "request": {
+        "inputs": {
+          "query": "What are the main features and diagnosis in this ECG image? Provide a concise, clinical answer.",
+          "image": "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAAYEBQYFBAYGBQYHBwYIChAKCgkJChQODwwQFxQYGBcUFhYaHSUfGhsjHBYWICwgIyYnKSopGR8tMC0oMCUoKSj/2wBDAQcHBwoIChMKChMoGhYaKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCj/wAARCAABAAEDASIAAhEBAxEB/8QAFQABAQAAAAAAAAAAAAAAAAAAAAv/xAAUEAEAAAAAAAAAAAAAAAAAAAAA/8QAFQEBAQAAAAAAAAAAAAAAAAAAAAX/xAAUEQEAAAAAAAAAAAAAAAAAAAAA/9oADAMBAAIRAxEAPwCdABmX/9k="
+        },
+        "parameters": {
+          "max_new_tokens": 512,
+          "temperature": 0.2,
+          "enable_turkish_commentary": true,
+          "deepseek_timeout": 25
+        }
+      }
+    },
+
+    "deepseek_disabled_request": {
+      "description": "DeepSeek Türkçe yorum özelliği deaktif",
+      "request": {
+        "inputs": {
+          "query": "Analyze this ECG image briefly.",
+          "image": "https://i.imgur.com/7uuejqO.jpeg"
+        },
+        "parameters": {
+          "temperature": 0.2,
+          "enable_turkish_commentary": false
+        }
+      }
+    }
+  },
+
+  "expected_response_format": {
+    "description": "Beklenen response formatı (DeepSeek aktif)",
+    "format": [
+      {
+        "generated_text": "Answer: This ECG image shows a sinus rhythm with a normal heart rate...",
+        "model": "PULSE-7B",
+        "processing_method": "pipeline",
+        "comment_text": "Bu EKG sonucu normal sinüs ritmi göstermektedir. Kalp atış hızı normaldir ve düzenli bir ritim görülmektedir...",
+        "commentary_model": "deepseek-chat",
+        "commentary_tokens": 85,
+        "commentary_status": "success"
+      }
+    ]
+  },
+
+  "expected_response_format_no_commentary": {
+    "description": "Beklenen response formatı (DeepSeek deaktif)",
+    "format": [
+      {
+        "generated_text": "Answer: This ECG image shows a sinus rhythm with a normal heart rate...",
+        "model": "PULSE-7B",
+        "processing_method": "pipeline"
+      }
+    ]
+  },
+
+  "error_response_format": {
+    "description": "Hata durumunda response formatı",
+    "format": [
+      {
+        "generated_text": "",
+        "error": "Error message here...",
+        "model": "PULSE-7B",
+        "handler": "Ubden® Team Enhanced Handler",
+        "success": false
+      }
+    ]
+  },
+
+  "usage_notes": {
+    "supported_image_formats": [
+      "JPEG", "PNG", "GIF", "BMP", "WebP"
+    ],
+    "supported_input_methods": [
+      "HTTP/HTTPS URL",
+      "Base64 encoded with data URI prefix",
+      "Raw base64 string"
+    ],
+    "parameter_limits": {
+      "max_new_tokens": "1-2048",
+      "temperature": "0.01-2.0",
+      "top_p": "0.01-1.0",
+      "repetition_penalty": "1.0-2.0"
+    },
+    "query_field_alternatives": [
+      "query", "text", "prompt"
+    ],
+    "deepseek_integration": {
+      "enable_turkish_commentary": "true/false (default: true)",
+      "deepseek_timeout": "10-60 seconds (default: 30)",
+      "environment_variable": "deep_key (DeepSeek API key)",
+      "commentary_status_values": [
+        "success", "failed", "unavailable", "api_key_missing", "no_text"
+      ]
+    },
+    "response_fields_with_commentary": [
+      "generated_text", "model", "processing_method",
+      "comment_text", "commentary_model", "commentary_tokens", "commentary_status"
+    ],
+    "response_fields_without_commentary": [
+      "generated_text", "model", "processing_method"
+    ]
+  }
+}

utils.py

@@ -0,0 +1,360 @@
+"""
+PULSE-7B Handler Utilities
+Ubden® Team - Performance monitoring and helper functions
+"""
+
+import time
+import torch
+import psutil
+import logging
+import os
+import json
+import requests
+from typing import Dict, Any, Optional
+from functools import wraps
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class PerformanceMonitor:
+    """Performance monitoring utilities for PULSE-7B handler"""
+    
+    def __init__(self):
+        self.metrics = {
+            'total_requests': 0,
+            'successful_requests': 0,
+            'failed_requests': 0,
+            'image_url_requests': 0,
+            'base64_requests': 0,
+            'text_only_requests': 0,
+            'total_generation_time': 0.0,
+            'total_image_processing_time': 0.0
+        }
+    
+    def log_request(self, request_type: str, success: bool, 
+                   generation_time: float = 0.0, 
+                   image_processing_time: float = 0.0):
+        """Log request metrics"""
+        self.metrics['total_requests'] += 1
+        
+        if success:
+            self.metrics['successful_requests'] += 1
+        else:
+            self.metrics['failed_requests'] += 1
+        
+        if request_type == 'image_url':
+            self.metrics['image_url_requests'] += 1
+        elif request_type == 'base64':
+            self.metrics['base64_requests'] += 1
+        else:
+            self.metrics['text_only_requests'] += 1
+        
+        self.metrics['total_generation_time'] += generation_time
+        self.metrics['total_image_processing_time'] += image_processing_time
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Get current performance statistics"""
+        total_requests = self.metrics['total_requests']
+        if total_requests == 0:
+            return self.metrics
+        
+        success_rate = (self.metrics['successful_requests'] / total_requests) * 100
+        avg_generation_time = self.metrics['total_generation_time'] / total_requests
+        avg_image_processing_time = self.metrics['total_image_processing_time'] / max(
+            self.metrics['image_url_requests'] + self.metrics['base64_requests'], 1
+        )
+        
+        return {
+            **self.metrics,
+            'success_rate_percent': round(success_rate, 2),
+            'avg_generation_time_seconds': round(avg_generation_time, 3),
+            'avg_image_processing_time_seconds': round(avg_image_processing_time, 3)
+        }
+    
+    def reset_stats(self):
+        """Reset all metrics"""
+        for key in self.metrics:
+            self.metrics[key] = 0 if isinstance(self.metrics[key], int) else 0.0
+
+def timing_decorator(func):
+    """Decorator to measure function execution time"""
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        start_time = time.time()
+        try:
+            result = func(*args, **kwargs)
+            execution_time = time.time() - start_time
+            logger.info(f"{func.__name__} completed in {execution_time:.3f}s")
+            return result, execution_time
+        except Exception as e:
+            execution_time = time.time() - start_time
+            logger.error(f"{func.__name__} failed in {execution_time:.3f}s: {e}")
+            raise e
+    return wrapper
+
+def get_system_info() -> Dict[str, Any]:
+    """Get current system resource information"""
+    cpu_percent = psutil.cpu_percent(interval=1)
+    memory = psutil.virtual_memory()
+    
+    system_info = {
+        'cpu_usage_percent': cpu_percent,
+        'memory_total_gb': round(memory.total / (1024**3), 2),
+        'memory_used_gb': round(memory.used / (1024**3), 2),
+        'memory_available_gb': round(memory.available / (1024**3), 2),
+        'memory_usage_percent': memory.percent
+    }
+    
+    # Add GPU info if available
+    if torch.cuda.is_available():
+        gpu_memory = torch.cuda.memory_stats()
+        system_info.update({
+            'gpu_available': True,
+            'gpu_memory_allocated_gb': round(
+                torch.cuda.memory_allocated() / (1024**3), 2
+            ),
+            'gpu_memory_reserved_gb': round(
+                torch.cuda.memory_reserved() / (1024**3), 2
+            ),
+            'gpu_device_name': torch.cuda.get_device_name(0)
+        })
+    else:
+        system_info['gpu_available'] = False
+    
+    return system_info
+
+def validate_image_input(image_input: str) -> Dict[str, Any]:
+    """Validate image input and return metadata"""
+    if not image_input or not isinstance(image_input, str):
+        return {'valid': False, 'type': None, 'error': 'Invalid input type'}
+    
+    # Check if URL
+    if image_input.startswith(('http://', 'https://')):
+        return {
+            'valid': True,
+            'type': 'url',
+            'length': len(image_input),
+            'domain': image_input.split('/')[2] if '/' in image_input else 'unknown'
+        }
+    
+    # Check if base64
+    elif image_input.startswith('data:image/') or len(image_input) > 100:
+        is_data_url = image_input.startswith('data:')
+        base64_data = image_input
+        
+        if is_data_url:
+            if 'base64,' in image_input:
+                base64_data = image_input.split('base64,')[1]
+            else:
+                return {'valid': False, 'type': 'base64', 'error': 'Invalid data URL format'}
+        
+        # Estimate decoded size
+        estimated_size = len(base64_data) * 3 // 4
+        
+        return {
+            'valid': True,
+            'type': 'base64',
+            'is_data_url': is_data_url,
+            'base64_length': len(base64_data),
+            'estimated_size_bytes': estimated_size,
+            'estimated_size_kb': round(estimated_size / 1024, 2)
+        }
+    
+    return {'valid': False, 'type': None, 'error': 'Unrecognized format'}
+
+def sanitize_parameters(parameters: Dict[str, Any]) -> Dict[str, Any]:
+    """Sanitize and validate generation parameters"""
+    sanitized = {}
+    
+    # Max new tokens
+    max_new_tokens = parameters.get('max_new_tokens', 512)
+    sanitized['max_new_tokens'] = max(1, min(max_new_tokens, 2048))
+    
+    # Temperature
+    temperature = parameters.get('temperature', 0.2)
+    sanitized['temperature'] = max(0.01, min(temperature, 2.0))
+    
+    # Top-p
+    top_p = parameters.get('top_p', 0.9)
+    sanitized['top_p'] = max(0.01, min(top_p, 1.0))
+    
+    # Repetition penalty
+    repetition_penalty = parameters.get('repetition_penalty', 1.05)
+    sanitized['repetition_penalty'] = max(1.0, min(repetition_penalty, 2.0))
+    
+    # Stop sequences
+    stop = parameters.get('stop', ['</s>'])
+    if isinstance(stop, str):
+        stop = [stop]
+    sanitized['stop'] = stop[:5]  # Limit to 5 stop sequences
+    
+    # Return full text
+    sanitized['return_full_text'] = bool(parameters.get('return_full_text', False))
+    
+    # Do sample
+    sanitized['do_sample'] = bool(parameters.get('do_sample', sanitized['temperature'] > 0.01))
+    
+    return sanitized
+
+def create_health_check() -> Dict[str, Any]:
+    """Create a health check response"""
+    try:
+        system_info = get_system_info()
+        
+        health_status = {
+            'status': 'healthy',
+            'timestamp': time.time(),
+            'system': system_info,
+            'model': 'PULSE-7B',
+            'handler_version': '2.0.0',
+            'features': [
+                'image_url_support',
+                'base64_image_support',
+                'stop_sequences',
+                'parameter_validation',
+                'performance_monitoring'
+            ]
+        }
+        
+        # Check if system is under stress
+        if system_info['memory_usage_percent'] > 90:
+            health_status['warnings'] = ['High memory usage']
+        
+        if system_info['cpu_usage_percent'] > 90:
+            health_status.setdefault('warnings', []).append('High CPU usage')
+        
+        return health_status
+        
+    except Exception as e:
+        return {
+            'status': 'unhealthy',
+            'timestamp': time.time(),
+            'error': str(e)
+        }
+
+class DeepSeekClient:
+    """DeepSeek API client for Turkish commentary"""
+    
+    def __init__(self, api_key: Optional[str] = None):
+        self.api_key = api_key or os.getenv('deep_key') or os.getenv('DEEPSEEK_API_KEY')
+        self.base_url = "https://api.deepseek.com/v1/chat/completions"
+        self.headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}" if self.api_key else ""
+        }
+        
+    def is_available(self) -> bool:
+        """Check if DeepSeek API is available"""
+        return bool(self.api_key)
+    
+    def get_turkish_commentary(self, english_analysis: str, timeout: int = 30) -> Dict[str, Any]:
+        """
+        Get Turkish commentary for English medical analysis
+        
+        Args:
+            english_analysis: English medical analysis text
+            timeout: Request timeout in seconds
+            
+        Returns:
+            Dict with success status and commentary
+        """
+        if not self.is_available():
+            return {
+                "success": False,
+                "error": "DeepSeek API key not configured",
+                "comment_text": ""
+            }
+        
+        try:
+            # Prepare the prompt for Turkish medical commentary
+            prompt = f"""Bu bir EKG sonucu klinik incelemesi. Aşağıdaki İngilizce medikal analizi Türkçe olarak yorumla ve hasta için anlaşılır bir dilde açıkla:
+
+"{english_analysis}"
+
+Lütfen:
+1. Medikal terimleri Türkçe karşılıklarıyla açıkla
+2. Hastanın anlayabileceği basit bir dille yaz
+3. Gerekirse aciliyet durumu hakkında bilgi ver
+4. Kısa ve net ol
+
+Türkçe Yorum:"""
+
+            payload = {
+                "model": "deepseek-chat",
+                "messages": [
+                    {
+                        "role": "system", 
+                        "content": "Sen deneyimli bir kardiyolog doktorsun. EKG sonuçlarını Türkçe olarak hastalar için anlaşılır şekilde açıklıyorsun."
+                    },
+                    {
+                        "role": "user", 
+                        "content": prompt
+                    }
+                ],
+                "temperature": 0.3,
+                "max_tokens": 500,
+                "stream": False
+            }
+            
+            logger.info("🔄 DeepSeek API'ye Türkçe yorum için istek gönderiliyor...")
+            
+            response = requests.post(
+                self.base_url,
+                headers=self.headers,
+                json=payload,
+                timeout=timeout
+            )
+            
+            response.raise_for_status()
+            result = response.json()
+            
+            if 'choices' in result and len(result['choices']) > 0:
+                comment_text = result['choices'][0]['message']['content'].strip()
+                
+                # Clean up the response - remove "Türkçe Yorum:" prefix if present
+                if comment_text.startswith("Türkçe Yorum:"):
+                    comment_text = comment_text[13:].strip()
+                
+                logger.info("✅ DeepSeek'ten Türkçe yorum başarıyla alındı")
+                
+                return {
+                    "success": True,
+                    "comment_text": comment_text,
+                    "model": "deepseek-chat",
+                    "tokens_used": result.get('usage', {}).get('total_tokens', 0)
+                }
+            else:
+                return {
+                    "success": False,
+                    "error": "DeepSeek API'den geçersiz yanıt",
+                    "comment_text": ""
+                }
+                
+        except requests.exceptions.Timeout:
+            logger.error("❌ DeepSeek API timeout")
+            return {
+                "success": False,
+                "error": "DeepSeek API timeout - istek zaman aşımına uğradı",
+                "comment_text": ""
+            }
+            
+        except requests.exceptions.RequestException as e:
+            logger.error(f"❌ DeepSeek API request error: {e}")
+            return {
+                "success": False,
+                "error": f"DeepSeek API bağlantı hatası: {str(e)}",
+                "comment_text": ""
+            }
+            
+        except Exception as e:
+            logger.error(f"❌ DeepSeek API unexpected error: {e}")
+            return {
+                "success": False,
+                "error": f"DeepSeek API beklenmeyen hata: {str(e)}",
+                "comment_text": ""
+            }
+
+# Global instances
+performance_monitor = PerformanceMonitor()
+deepseek_client = DeepSeekClient()