isa-model 0.4.0__py3-none-any.whl → 0.4.3__py3-none-any.whl

isa_model/inference/services/vision/isa_vision_service.py

@@ -9,6 +9,7 @@ import logging
 import base64
 import io
 import time
+import asyncio
 from typing import Dict, Any, List, Union, Optional, BinaryIO
 from PIL import Image
 
@@ -36,7 +37,7 @@ class ISAVisionService(BaseVisionService):
     def __init__(self, 
                  modal_app_id: str = "ap-VlHUQoiPUdy9cgrHSfG7Fk",
                  modal_app_name: str = "isa-vision-ui-optimized",
-                 timeout: int = 30):
+                 timeout: int = 60):
         """
         初始化ISA Vision服务
         
@@ -77,6 +78,31 @@ class ISAVisionService(BaseVisionService):
         self.request_count = 0
         self.total_cost = 0.0
         
+        # 性能优化 - 预热连接（延迟初始化）
+        self._connection_warmed = False
+        
+        # 简单缓存机制（可选）
+        self._result_cache = {}
+        self._cache_max_size = 100
+        
+    async def _warm_connection(self):
+        """预热Modal连接，减少首次调用延迟"""
+        if self._connection_warmed or not self.modal_app:
+            return
+            
+        try:
+            logger.info("Warming up Modal connection...")
+            # 尝试获取服务状态来预热连接
+            if hasattr(self.modal_app, 'list_functions'):
+                await asyncio.wait_for(
+                    asyncio.to_thread(self.modal_app.list_functions),
+                    timeout=10
+                )
+            self._connection_warmed = True
+            logger.info("✅ Modal connection warmed up")
+        except Exception as e:
+            logger.warning(f"Failed to warm up connection: {e}")
+    
     async def analyze_image(
         self, 
         image: Union[str, BinaryIO],
@@ -154,6 +180,9 @@ class ISAVisionService(BaseVisionService):
                     'error': 'Modal app or service not available'
                 }
             
+            # 预热连接以减少延迟
+            await self._warm_connection()
+            
             # 准备图像数据
             image_b64 = await self._prepare_image_base64(image)
             
@@ -208,11 +237,22 @@ class ISAVisionService(BaseVisionService):
             
             # 创建实例并调用优化方法（快速模式，无字幕）
             instance = OptimizedUIDetectionService()
-            result = instance.detect_ui_elements_fast.remote(image_b64, enable_captions=False)
+            # 使用超时控制Modal调用
+            result = await asyncio.wait_for(
+                instance.detect_ui_elements_fast.remote(image_b64, enable_captions=False),
+                timeout=self.timeout
+            )
             
             logger.info("✅ Modal SDK call successful")
             return result
                         
+        except asyncio.TimeoutError:
+            logger.error(f"Modal SDK call timed out after {self.timeout} seconds")
+            return {
+                'success': False,
+                'error': f'Modal service timeout after {self.timeout} seconds',
+                'timeout': True
+            }
         except Exception as e:
             logger.error(f"Modal SDK call failed: {e}")
             return {
@@ -316,11 +356,22 @@ class ISAVisionService(BaseVisionService):
             
             # 创建实例并调用方法
             instance = SuryaOCRService()
-            result = instance.extract_text.remote(image_b64, languages)
+            # 使用超时控制OCR调用
+            result = await asyncio.wait_for(
+                instance.extract_text.remote(image_b64, languages),
+                timeout=self.timeout
+            )
             
             logger.info("✅ OCR service call successful")
             return result
                         
+        except asyncio.TimeoutError:
+            logger.error(f"OCR service call timed out after {self.timeout} seconds")
+            return {
+                'success': False,
+                'error': f'OCR service timeout after {self.timeout} seconds',
+                'timeout': True
+            }
         except Exception as e:
             logger.error(f"OCR service call failed: {e}")
             return {
@@ -499,7 +550,7 @@ class ISAVisionService(BaseVisionService):
         """准备base64编码的图像"""
         if isinstance(image, str):
             # Check if it's already base64 encoded
-            if image.startswith('data:image') or len(image) > 1000:
+            if image.startswith('data:image') or (not image.startswith('http') and len(image) > 1000):
                 # Likely already base64
                 if image.startswith('data:image'):
                     # Extract base64 part
@@ -507,6 +558,16 @@ class ISAVisionService(BaseVisionService):
                 else:
                     # Assume it's pure base64
                     return image
+            elif image.startswith('http://') or image.startswith('https://'):
+                # URL - download the image
+                import aiohttp
+                async with aiohttp.ClientSession() as session:
+                    async with session.get(image) as response:
+                        if response.status == 200:
+                            image_data = await response.read()
+                            return base64.b64encode(image_data).decode('utf-8')
+                        else:
+                            raise ValueError(f"Failed to download image from URL: {response.status}")
             else:
                 # File path
                 with open(image, 'rb') as f:

isa_model/inference/services/vision/openai_vision_service.py

@@ -92,12 +92,21 @@ class OpenAIVisionService(BaseVisionService, VisionPromptMixin):
                 }
             ]
             
-            response = await self._client.chat.completions.create(  # type: ignore
-                model=self.model_name,
-                messages=messages,  # type: ignore
-                max_tokens=max_tokens,
-                temperature=self.temperature
-            )
+            # Use max_completion_tokens for newer models like gpt-4o-mini
+            completion_params = {
+                "model": self.model_name,
+                "messages": messages,  # type: ignore
+                "temperature": self.temperature
+            }
+            
+            # Check if model uses new parameter name
+            # All newer models (gpt-4o, gpt-4.1, o1, etc.) use max_completion_tokens
+            if any(prefix in self.model_name for prefix in ["gpt-4o", "gpt-4.1", "o1"]):
+                completion_params["max_completion_tokens"] = max_tokens
+            else:
+                completion_params["max_tokens"] = max_tokens
+            
+            response = await self._client.chat.completions.create(**completion_params)  # type: ignore
             
             # Track usage for billing
             if response.usage:
@@ -162,7 +171,7 @@ class OpenAIVisionService(BaseVisionService, VisionPromptMixin):
         图像描述 - 使用专门提示词
         """
         prompt = self.get_task_prompt("describe", detail_level=detail_level)
-        return await self.analyze_image(image, prompt)
+        return await self.analyze_image(image, prompt, max_tokens=1000)
     
     async def extract_text(self, image: Union[str, BinaryIO]) -> Dict[str, Any]:
         """
@@ -170,7 +179,7 @@ class OpenAIVisionService(BaseVisionService, VisionPromptMixin):
         """
         prompt = self.get_task_prompt("extract_text")
         
-        return await self.analyze_image(image, prompt)
+        return await self.analyze_image(image, prompt, max_tokens=1000)
     
     async def detect_objects(
         self, 
@@ -182,7 +191,7 @@ class OpenAIVisionService(BaseVisionService, VisionPromptMixin):
         """
         prompt = self.get_task_prompt("detect_objects", confidence_threshold=confidence_threshold)
         
-        return await self.analyze_image(image, prompt)
+        return await self.analyze_image(image, prompt, max_tokens=1000)
     
     async def detect_ui_elements(
         self,
@@ -195,7 +204,7 @@ class OpenAIVisionService(BaseVisionService, VisionPromptMixin):
         """
         prompt = self.get_task_prompt("detect_ui_elements", element_types=element_types, confidence_threshold=confidence_threshold)
         
-        return await self.analyze_image(image, prompt)
+        return await self.analyze_image(image, prompt, max_tokens=1000)
     
     async def detect_document_elements(
         self,

isa_model/inference/services/vision/vgg16_vision_service.py

@@ -0,0 +1,257 @@
+#!/usr/bin/env python3
+"""
+VGG16 Vision Service
+Computer vision service using VGG16 for image classification
+Based on the aircraft damage detection notebook implementation
+"""
+
+import os
+import numpy as np
+from typing import Dict, List, Any, Optional, Union, BinaryIO
+import logging
+from PIL import Image
+import io
+
+from .base_vision_service import BaseVisionService
+
+logger = logging.getLogger(__name__)
+
+def _lazy_import_vgg16_deps():
+    """Lazy import VGG16 dependencies"""
+    try:
+        import tensorflow as tf
+        from tensorflow.keras.applications import VGG16
+        from tensorflow.keras.layers import Dense, Dropout, Flatten
+        from tensorflow.keras.models import Sequential, Model
+        from tensorflow.keras.optimizers import Adam
+        from tensorflow.keras.preprocessing.image import ImageDataGenerator
+        
+        return {
+            'tf': tf,
+            'VGG16': VGG16,
+            'Dense': Dense,
+            'Dropout': Dropout,
+            'Flatten': Flatten,
+            'Sequential': Sequential,
+            'Model': Model,
+            'Adam': Adam,
+            'ImageDataGenerator': ImageDataGenerator,
+            'available': True
+        }
+    except ImportError as e:
+        logger.warning(f"VGG16 dependencies not available: {e}")
+        return {'available': False}
+
+class VGG16VisionService(BaseVisionService):
+    """
+    VGG16-based vision service for image classification
+    Provides an alternative implementation to VLM-based classification
+    """
+    
+    def __init__(self, model_path: Optional[str] = None, class_names: Optional[List[str]] = None):
+        """
+        Initialize VGG16 vision service
+        
+        Args:
+            model_path: Path to trained VGG16 model
+            class_names: List of class names for classification
+        """
+        super().__init__()
+        
+        self.model_path = model_path
+        self.class_names = class_names or ["class_0", "class_1"]
+        self.model = None
+        self.input_shape = (224, 224, 3)
+        
+        # Lazy load dependencies
+        self.vgg16_components = _lazy_import_vgg16_deps()
+        
+        if not self.vgg16_components['available']:
+            raise ImportError("TensorFlow and VGG16 dependencies are required")
+        
+        # Load model if path provided
+        if model_path and os.path.exists(model_path):
+            self._load_model(model_path)
+    
+    def _load_model(self, model_path: str):
+        """Load trained VGG16 model"""
+        try:
+            tf = self.vgg16_components['tf']
+            self.model = tf.keras.models.load_model(model_path)
+            logger.info(f"VGG16 model loaded from {model_path}")
+        except Exception as e:
+            logger.error(f"Error loading VGG16 model: {e}")
+            raise
+    
+    def _preprocess_image(self, image: Union[str, BinaryIO]) -> np.ndarray:
+        """
+        Preprocess image for VGG16 input
+        
+        Args:
+            image: Image path or binary data
+            
+        Returns:
+            Preprocessed image array
+        """
+        try:
+            # Handle different image input types
+            if isinstance(image, str):
+                # File path
+                pil_image = Image.open(image).convert('RGB')
+            elif hasattr(image, 'read'):
+                # Binary IO
+                image_data = image.read()
+                pil_image = Image.open(io.BytesIO(image_data)).convert('RGB')
+            else:
+                raise ValueError("Unsupported image format")
+            
+            # Resize to VGG16 input size
+            pil_image = pil_image.resize((self.input_shape[0], self.input_shape[1]))
+            
+            # Convert to array and normalize
+            image_array = np.array(pil_image) / 255.0
+            
+            # Add batch dimension
+            image_batch = np.expand_dims(image_array, axis=0)
+            
+            return image_batch, image_array
+            
+        except Exception as e:
+            logger.error(f"Error preprocessing image: {e}")
+            raise
+    
+    async def classify_image(self, 
+                           image: Union[str, BinaryIO], 
+                           categories: Optional[List[str]] = None) -> Dict[str, Any]:
+        """
+        Classify image using trained VGG16 model
+        
+        Args:
+            image: Image path or binary data
+            categories: Optional list of categories (uses model's classes if None)
+            
+        Returns:
+            Classification results
+        """
+        try:
+            if self.model is None:
+                return {
+                    "error": "No trained model available. Please load a model first.",
+                    "service": "VGG16VisionService"
+                }
+            
+            # Preprocess image
+            image_batch, image_array = self._preprocess_image(image)
+            
+            # Make prediction
+            predictions = self.model.predict(image_batch, verbose=0)
+            
+            # Use provided categories or default class names
+            class_names = categories or self.class_names
+            
+            # Process predictions based on model output
+            if len(predictions[0]) == 1:  # Binary classification
+                predicted_class_idx = int(predictions[0] > 0.5)
+                confidence = float(predictions[0][0]) if predicted_class_idx == 1 else float(1 - predictions[0][0])
+                
+                # Create probability distribution
+                probabilities = {
+                    class_names[0]: float(1 - predictions[0][0]),
+                    class_names[1]: float(predictions[0][0])
+                }
+            else:  # Multiclass classification
+                predicted_class_idx = np.argmax(predictions[0])
+                confidence = float(predictions[0][predicted_class_idx])
+                
+                # Create probability distribution
+                probabilities = {
+                    class_names[i]: float(predictions[0][i]) 
+                    for i in range(min(len(class_names), len(predictions[0])))
+                }
+            
+            predicted_class = class_names[predicted_class_idx] if predicted_class_idx < len(class_names) else f"class_{predicted_class_idx}"
+            
+            return {
+                "task": "classify",
+                "service": "VGG16VisionService",
+                "predicted_class": predicted_class,
+                "confidence": confidence,
+                "probabilities": probabilities,
+                "model_type": "VGG16",
+                "success": True
+            }
+            
+        except Exception as e:
+            logger.error(f"Error classifying image: {e}")
+            return {
+                "error": str(e),
+                "service": "VGG16VisionService",
+                "success": False
+            }
+    
+    async def analyze_image(self, 
+                          image: Union[str, BinaryIO], 
+                          prompt: Optional[str] = None,
+                          max_tokens: int = 1000) -> Dict[str, Any]:
+        """
+        Analyze image using VGG16 classification
+        
+        Args:
+            image: Image path or binary data
+            prompt: Optional prompt (used to guide interpretation)
+            max_tokens: Not used for classification
+            
+        Returns:
+            Analysis results
+        """
+        # For VGG16, analysis is essentially classification
+        classification_result = await self.classify_image(image)
+        
+        if classification_result.get("success"):
+            # Create analysis text based on classification
+            predicted_class = classification_result["predicted_class"]
+            confidence = classification_result["confidence"]
+            
+            analysis_text = f"The image has been classified as '{predicted_class}' with {confidence:.2%} confidence."
+            
+            if prompt:
+                analysis_text += f" Analysis context: {prompt}"
+            
+            return {
+                "task": "analyze",
+                "service": "VGG16VisionService",
+                "text": analysis_text,
+                "confidence": confidence,
+                "classification": classification_result,
+                "success": True
+            }
+        else:
+            return classification_result
+    
+    def set_class_names(self, class_names: List[str]):
+        """Set class names for classification"""
+        self.class_names = class_names
+    
+    def load_trained_model(self, model_path: str, class_names: Optional[List[str]] = None):
+        """
+        Load a trained VGG16 model
+        
+        Args:
+            model_path: Path to the trained model
+            class_names: Optional class names
+        """
+        self._load_model(model_path)
+        if class_names:
+            self.set_class_names(class_names)
+    
+    def get_service_info(self) -> Dict[str, Any]:
+        """Get service information"""
+        return {
+            "service_name": "VGG16VisionService",
+            "model_type": "VGG16",
+            "capabilities": ["classify", "analyze"],
+            "model_loaded": self.model is not None,
+            "input_shape": self.input_shape,
+            "class_names": self.class_names,
+            "dependencies_available": self.vgg16_components['available']
+        }

isa_model/serving/api/cache_manager.py

@@ -0,0 +1,245 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Simple Cache Manager for ISA Model API
+Provides in-memory caching to improve API performance
+"""
+
+import time
+import logging
+from typing import Dict, Any, Optional, Callable
+from dataclasses import dataclass
+from threading import RLock
+import asyncio
+import hashlib
+import json
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class CacheEntry:
+    """Cache entry with data and metadata"""
+    data: Any
+    created_at: float
+    ttl: float
+    access_count: int = 0
+    last_accessed: float = None
+    
+    def is_expired(self) -> bool:
+        """Check if cache entry is expired"""
+        return time.time() - self.created_at > self.ttl
+    
+    def access(self) -> Any:
+        """Mark as accessed and return data"""
+        self.access_count += 1
+        self.last_accessed = time.time()
+        return self.data
+
+class APICache:
+    """
+    Simple in-memory cache for API responses
+    Thread-safe with automatic expiration
+    """
+    
+    def __init__(self, default_ttl: float = 300.0, max_size: int = 1000):
+        self.default_ttl = default_ttl  # 5 minutes default
+        self.max_size = max_size
+        self._cache: Dict[str, CacheEntry] = {}
+        self._lock = RLock()
+        self._stats = {
+            "hits": 0,
+            "misses": 0,
+            "evictions": 0,
+            "total_requests": 0
+        }
+    
+    def _generate_key(self, *args, **kwargs) -> str:
+        """Generate cache key from arguments"""
+        # Create a stable key from arguments
+        key_data = {
+            "args": args,
+            "kwargs": sorted(kwargs.items()) if kwargs else {}
+        }
+        key_string = json.dumps(key_data, sort_keys=True, default=str)
+        return hashlib.md5(key_string.encode()).hexdigest()
+    
+    def _cleanup_expired(self):
+        """Remove expired entries"""
+        with self._lock:
+            current_time = time.time()
+            expired_keys = [
+                key for key, entry in self._cache.items()
+                if entry.is_expired()
+            ]
+            
+            for key in expired_keys:
+                del self._cache[key]
+            
+            if expired_keys:
+                logger.debug(f"Cleaned up {len(expired_keys)} expired cache entries")
+    
+    def _evict_lru(self):
+        """Evict least recently used entries when cache is full"""
+        with self._lock:
+            if len(self._cache) >= self.max_size:
+                # Sort by last_accessed time (LRU)
+                sorted_entries = sorted(
+                    self._cache.items(),
+                    key=lambda x: x[1].last_accessed or x[1].created_at
+                )
+                
+                # Remove oldest 20% of entries
+                num_to_remove = max(1, len(sorted_entries) // 5)
+                for key, _ in sorted_entries[:num_to_remove]:
+                    del self._cache[key]
+                    self._stats["evictions"] += 1
+                
+                logger.debug(f"Evicted {num_to_remove} LRU cache entries")
+    
+    def get(self, key: str) -> Optional[Any]:
+        """Get cached value by key"""
+        with self._lock:
+            self._stats["total_requests"] += 1
+            
+            if key in self._cache:
+                entry = self._cache[key]
+                if not entry.is_expired():
+                    self._stats["hits"] += 1
+                    return entry.access()
+                else:
+                    # Remove expired entry
+                    del self._cache[key]
+            
+            self._stats["misses"] += 1
+            return None
+    
+    def set(self, key: str, value: Any, ttl: Optional[float] = None) -> None:
+        """Set cached value with optional TTL"""
+        with self._lock:
+            # Cleanup and eviction
+            self._cleanup_expired()
+            self._evict_lru()
+            
+            entry = CacheEntry(
+                data=value,
+                created_at=time.time(),
+                ttl=ttl or self.default_ttl,
+                last_accessed=time.time()
+            )
+            
+            self._cache[key] = entry
+    
+    def delete(self, key: str) -> bool:
+        """Delete cached value"""
+        with self._lock:
+            if key in self._cache:
+                del self._cache[key]
+                return True
+            return False
+    
+    def clear(self) -> None:
+        """Clear all cached values"""
+        with self._lock:
+            self._cache.clear()
+            logger.info("Cache cleared")
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Get cache statistics"""
+        with self._lock:
+            hit_rate = (
+                self._stats["hits"] / self._stats["total_requests"]
+                if self._stats["total_requests"] > 0 else 0
+            )
+            
+            return {
+                "cache_size": len(self._cache),
+                "max_size": self.max_size,
+                "default_ttl": self.default_ttl,
+                "hit_rate": round(hit_rate * 100, 2),
+                **self._stats
+            }
+
+# Decorator for caching function results
+def cached(ttl: float = 300.0, cache_key_func: Optional[Callable] = None):
+    """
+    Decorator to cache function results
+    
+    Args:
+        ttl: Time to live in seconds
+        cache_key_func: Custom function to generate cache key
+    """
+    def decorator(func):
+        async def async_wrapper(*args, **kwargs):
+            # Generate cache key
+            if cache_key_func:
+                cache_key = cache_key_func(*args, **kwargs)
+            else:
+                cache_key = api_cache._generate_key(func.__name__, *args, **kwargs)
+            
+            # Try to get from cache
+            cached_result = api_cache.get(cache_key)
+            if cached_result is not None:
+                logger.debug(f"Cache hit for {func.__name__}")
+                return cached_result
+            
+            # Execute function and cache result
+            try:
+                result = await func(*args, **kwargs)
+                api_cache.set(cache_key, result, ttl)
+                logger.debug(f"Cached result for {func.__name__}")
+                return result
+            except Exception as e:
+                logger.error(f"Function {func.__name__} failed: {e}")
+                raise
+        
+        def sync_wrapper(*args, **kwargs):
+            # Generate cache key
+            if cache_key_func:
+                cache_key = cache_key_func(*args, **kwargs)
+            else:
+                cache_key = api_cache._generate_key(func.__name__, *args, **kwargs)
+            
+            # Try to get from cache
+            cached_result = api_cache.get(cache_key)
+            if cached_result is not None:
+                logger.debug(f"Cache hit for {func.__name__}")
+                return cached_result
+            
+            # Execute function and cache result
+            try:
+                result = func(*args, **kwargs)
+                api_cache.set(cache_key, result, ttl)
+                logger.debug(f"Cached result for {func.__name__}")
+                return result
+            except Exception as e:
+                logger.error(f"Function {func.__name__} failed: {e}")
+                raise
+        
+        # Return appropriate wrapper based on function type
+        if asyncio.iscoroutinefunction(func):
+            return async_wrapper
+        else:
+            return sync_wrapper
+    
+    return decorator
+
+# Global cache instance
+api_cache = APICache(default_ttl=300.0, max_size=1000)
+
+def get_api_cache() -> APICache:
+    """Get the global API cache instance"""
+    return api_cache
+
+# Cache key generators for common patterns
+def model_list_cache_key(service_type=None):
+    """Generate cache key for model list API"""
+    return f"models_list_{service_type or 'all'}"
+
+def provider_list_cache_key():
+    """Generate cache key for provider list API"""
+    return "providers_list"
+
+def custom_models_cache_key(model_type=None, provider=None):
+    """Generate cache key for custom models API"""
+    return f"custom_models_{model_type or 'all'}_{provider or 'all'}"