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

isa_model/inference/services/vision/tests/test_ocr_client.py

@@ -0,0 +1,284 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Test OCR Client using ISA Model Client
+Tests the SuryaOCR service for text extraction through the unified client.
+"""
+
+import asyncio
+import logging
+from typing import Dict, Any
+
+from isa_model.client import ISAModelClient
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class OCRTester:
+    """Test client for SuryaOCR service using ISA Model Client"""
+    
+    def __init__(self):
+        self.client = ISAModelClient()
+        
+        # Test configuration for OCR service
+        self.test_config = {
+            "model": "isa-suryaocr",
+            "provider": "isa", 
+            "task": "extract",
+            "input_image": "isa_model/inference/services/vision/tests/contract.png"
+        }
+    
+    async def test_ocr_extraction(self) -> Dict[str, Any]:
+        """Test OCR text extraction from contract image using unified client"""
+        logger.info("Testing OCR text extraction via unified client...")
+        
+        try:
+            config = self.test_config
+            
+            result = await self.client.invoke(
+                input_data=config["input_image"],
+                task=config["task"],
+                service_type="vision",
+                model=config["model"],
+                provider=config["provider"],
+                languages=["en", "zh"]
+            )
+            
+            if result.get("success"):
+                response = result["result"]
+                logger.info(f"OCR extraction successful")
+                
+                # Get extracted text
+                extracted_text = response.get('text', '')
+                text_length = len(extracted_text)
+                logger.info(f"Text extracted: {text_length} characters")
+                
+                # Get cost information
+                cost = response.get('metadata', {}).get('billing', {}).get('estimated_cost_usd', 0)
+                logger.info(f"Cost: ${cost:.6f}")
+                
+                # Log first 200 characters of extracted text for verification
+                if extracted_text:
+                    preview_text = extracted_text[:200] + "..." if text_length > 200 else extracted_text
+                    logger.info(f"Text preview: {preview_text}")
+                
+                return {
+                    "status": "success",
+                    "result": response,
+                    "metadata": result.get("metadata", {}),
+                    "text_length": text_length,
+                    "cost": cost
+                }
+            else:
+                error_msg = result.get("error", "Unknown error")
+                logger.error(f"OCR extraction failed: {error_msg}")
+                return {"status": "error", "error": error_msg}
+                
+        except Exception as e:
+            logger.error(f"OCR extraction failed with exception: {e}")
+            return {"status": "error", "error": str(e)}
+    
+    async def test_direct_vision_service(self) -> Dict[str, Any]:
+        """Test OCR using direct ISA vision service call"""
+        logger.info("Testing direct ISA vision service OCR...")
+        
+        try:
+            from isa_model.inference import AIFactory
+            
+            # Get ISA vision service directly
+            vision = AIFactory().get_vision(provider="isa")
+            
+            # Extract text using SuryaOCR
+            result = await vision.extract_text(
+                self.test_config["input_image"],
+                languages=["en", "zh"]
+            )
+            
+            if result.get('success'):
+                logger.info(f"Direct SuryaOCR successful")
+                
+                # Get extracted text from text_results array
+                text_results = result.get('text_results', [])
+                extracted_text = ' '.join([item.get('text', '') for item in text_results])
+                text_length = len(extracted_text)
+                logger.info(f"Text extracted: {text_length} characters from {len(text_results)} detected regions")
+                
+                # Get cost information
+                cost = result.get('billing', {}).get('estimated_cost_usd', 0)
+                logger.info(f"Cost: ${cost:.6f}")
+                
+                # Count Chinese and English characters
+                chinese_chars = sum(1 for char in extracted_text if '\u4e00' <= char <= '\u9fff')
+                english_chars = sum(1 for char in extracted_text if char.isalpha() and ord(char) < 256)
+                logger.info(f"Chinese characters: {chinese_chars}, English characters: {english_chars}")
+                
+                # Log text preview (first few items)
+                if text_results:
+                    sample_texts = [item.get('text', '') for item in text_results[:5]]
+                    logger.info(f"Sample extracted text: {sample_texts}")
+                
+                return {
+                    "status": "success", 
+                    "result": result,
+                    "text_length": text_length,
+                    "cost": cost
+                }
+            else:
+                error_msg = result.get("error", "Unknown error")
+                logger.error(f"Direct SuryaOCR failed: {error_msg}")
+                return {"status": "error", "error": error_msg}
+                
+        except Exception as e:
+            logger.error(f"Direct SuryaOCR failed with exception: {e}")
+            return {"status": "error", "error": str(e)}
+    
+    async def test_chinese_and_english_ocr(self) -> Dict[str, Any]:
+        """Test OCR with Chinese and English language support"""
+        logger.info("Testing Chinese and English OCR support...")
+        
+        try:
+            from isa_model.inference import AIFactory
+            
+            vision = AIFactory().get_vision(provider="isa")
+            
+            # Test with both Chinese and English languages
+            result = await vision.extract_text(
+                self.test_config["input_image"],
+                languages=["zh", "en"]  # Chinese first, then English
+            )
+            
+            if result.get('success'):
+                logger.info(f"Multi-language OCR successful")
+                
+                extracted_text = result.get('text', '')
+                text_length = len(extracted_text)
+                logger.info(f"Text length: {text_length}")
+                
+                # Check for Chinese characters
+                chinese_chars = sum(1 for char in extracted_text if '\u4e00' <= char <= '\u9fff')
+                english_chars = sum(1 for char in extracted_text if char.isalpha() and ord(char) < 256)
+                
+                logger.info(f"Chinese characters detected: {chinese_chars}")
+                logger.info(f"English characters detected: {english_chars}")
+                
+                # Get cost
+                cost = result.get('billing', {}).get('estimated_cost_usd', 0)
+                logger.info(f"Cost: ${cost:.6f}")
+                
+                return {
+                    "status": "success",
+                    "result": result,
+                    "text_length": text_length,
+                    "chinese_chars": chinese_chars,
+                    "english_chars": english_chars,
+                    "cost": cost
+                }
+            else:
+                error_msg = result.get("error", "Unknown error")
+                logger.error(f"Multi-language OCR failed: {error_msg}")
+                return {"status": "error", "error": error_msg}
+                
+        except Exception as e:
+            logger.error(f"Multi-language OCR failed with exception: {e}")
+            return {"status": "error", "error": str(e)}
+    
+    async def test_all_ocr_methods(self) -> Dict[str, Dict[str, Any]]:
+        """Test OCR functionality"""
+        logger.info("Starting SuryaOCR test using ISA Model Client...")
+        
+        results = {}
+        
+        # Test only the direct vision service (most comprehensive)
+        tests = [
+            ("suryaocr_extraction", self.test_direct_vision_service)
+        ]
+        
+        for test_name, test_func in tests:
+            logger.info(f"\n{'='*50}")
+            logger.info(f"Running test: {test_name}")
+            logger.info(f"{'='*50}")
+            
+            try:
+                result = await test_func()
+                results[test_name] = result
+                
+                if result.get("status") == "success":
+                    logger.info(f" {test_name} PASSED")
+                else:
+                    logger.error(f"L {test_name} FAILED: {result.get('error', 'Unknown error')}")
+                    
+            except Exception as e:
+                logger.error(f"L {test_name} FAILED with exception: {e}")
+                results[test_name] = {"status": "error", "error": str(e)}
+        
+        # Summary
+        logger.info(f"\n{'='*50}")
+        logger.info("TEST SUMMARY")
+        logger.info(f"{'='*50}")
+        
+        passed = sum(1 for r in results.values() if r.get("status") == "success")
+        total = len(results)
+        
+        logger.info(f"Passed: {passed}/{total}")
+        
+        for test_name, result in results.items():
+            status = " PASS" if result.get("status") == "success" else "L FAIL"
+            logger.info(f"{test_name}: {status}")
+        
+        return results
+    
+    async def get_service_health(self) -> Dict[str, Any]:
+        """Get health status of the client and services"""
+        logger.info("Checking service health...")
+        
+        try:
+            health = await self.client.health_check()
+            return health
+        except Exception as e:
+            logger.error(f"Health check failed: {e}")
+            return {"status": "error", "error": str(e)}
+
+async def main():
+    """Main test function"""
+    tester = OCRTester()
+    
+    # Get service health
+    logger.info("Checking service health...")
+    health = await tester.get_service_health()
+    logger.info(f"Service health: {health}")
+    
+    # Run all tests
+    results = await tester.test_all_ocr_methods()
+    
+    # Calculate total cost
+    total_cost = 0.0
+    for test_name, result in results.items():
+        if result.get("status") == "success":
+            cost = result.get("cost", 0.0)
+            total_cost += cost
+    
+    logger.info(f"\nTotal cost for all OCR tests: ${total_cost:.6f}")
+    
+    # Summary of text extraction results
+    logger.info(f"\n{'='*50}")
+    logger.info("TEXT EXTRACTION SUMMARY")
+    logger.info(f"{'='*50}")
+    
+    for test_name, result in results.items():
+        if result.get("status") == "success":
+            text_length = result.get("text_length", 0)
+            cost = result.get("cost", 0)
+            logger.info(f"{test_name}: {text_length} chars extracted, ${cost:.6f}")
+            
+            # Show language breakdown if available
+            if "chinese_chars" in result and "english_chars" in result:
+                logger.info(f"  - Chinese: {result['chinese_chars']} chars")
+                logger.info(f"  - English: {result['english_chars']} chars")
+    
+    return results
+
+if __name__ == "__main__":
+    # Run the tests
+    results = asyncio.run(main())

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']
+        }