isa-model 0.1.0__py3-none-any.whl

isa_model/core/resource_manager.py

@@ -0,0 +1,202 @@
+import time
+import threading
+import logging
+from typing import Dict, List, Any, Optional
+import psutil
+try:
+    import torch
+    import nvidia_smi
+    HAS_GPU = torch.cuda.is_available()
+except ImportError:
+    HAS_GPU = False
+
+logger = logging.getLogger(__name__)
+
+class ResourceManager:
+    """
+    Monitors system resources and manages model loading/unloading
+    to prevent resource exhaustion.
+    """
+    
+    def __init__(self, model_registry, monitoring_interval=30):
+        self.registry = model_registry
+        self.monitoring_interval = monitoring_interval  # seconds
+        
+        self.max_memory_percent = 90  # Maximum memory usage percentage
+        self.max_gpu_memory_percent = 90  # Maximum GPU memory usage percentage
+        
+        self._stop_event = threading.Event()
+        self._monitor_thread = None
+        
+        # Track resource usage over time
+        self.resource_history = {
+            "timestamps": [],
+            "cpu_percent": [],
+            "memory_percent": [],
+            "gpu_utilization": [],
+            "gpu_memory_percent": []
+        }
+        
+        # Initialize GPU monitoring if available
+        if HAS_GPU:
+            try:
+                nvidia_smi.nvmlInit()
+                self.gpu_count = torch.cuda.device_count()
+                logger.info(f"Initialized GPU monitoring with {self.gpu_count} devices")
+            except Exception as e:
+                logger.warning(f"Failed to initialize NVIDIA SMI: {str(e)}")
+                self.gpu_count = 0
+        else:
+            self.gpu_count = 0
+            
+        logger.info("Initialized ResourceManager")
+    
+    def start_monitoring(self):
+        """Start the resource monitoring thread"""
+        if self._monitor_thread is not None and self._monitor_thread.is_alive():
+            logger.warning("Resource monitoring already running")
+            return
+            
+        self._stop_event.clear()
+        self._monitor_thread = threading.Thread(
+            target=self._monitor_resources,
+            daemon=True
+        )
+        self._monitor_thread.start()
+        logger.info("Started resource monitoring thread")
+    
+    def stop_monitoring(self):
+        """Stop the resource monitoring thread"""
+        if self._monitor_thread is not None:
+            self._stop_event.set()
+            self._monitor_thread.join(timeout=5)
+            self._monitor_thread = None
+            logger.info("Stopped resource monitoring thread")
+    
+    def _monitor_resources(self):
+        """Monitor system resources in a loop"""
+        while not self._stop_event.is_set():
+            try:
+                # Get current resource usage
+                cpu_percent = psutil.cpu_percent(interval=1)
+                memory = psutil.virtual_memory()
+                memory_percent = memory.percent
+                
+                # GPU monitoring
+                gpu_utilization = 0
+                gpu_memory_percent = 0
+                
+                if self.gpu_count > 0:
+                    gpu_util_sum = 0
+                    gpu_mem_percent_sum = 0
+                    
+                    for i in range(self.gpu_count):
+                        try:
+                            handle = nvidia_smi.nvmlDeviceGetHandleByIndex(i)
+                            util = nvidia_smi.nvmlDeviceGetUtilizationRates(handle)
+                            mem_info = nvidia_smi.nvmlDeviceGetMemoryInfo(handle)
+                            
+                            gpu_util_sum += util.gpu
+                            gpu_mem_percent = (mem_info.used / mem_info.total) * 100
+                            gpu_mem_percent_sum += gpu_mem_percent
+                        except Exception as e:
+                            logger.error(f"Error getting GPU {i} stats: {str(e)}")
+                    
+                    if self.gpu_count > 0:
+                        gpu_utilization = gpu_util_sum / self.gpu_count
+                        gpu_memory_percent = gpu_mem_percent_sum / self.gpu_count
+                
+                # Record history (keep last 60 samples)
+                now = time.time()
+                self.resource_history["timestamps"].append(now)
+                self.resource_history["cpu_percent"].append(cpu_percent)
+                self.resource_history["memory_percent"].append(memory_percent)
+                self.resource_history["gpu_utilization"].append(gpu_utilization)
+                self.resource_history["gpu_memory_percent"].append(gpu_memory_percent)
+                
+                # Trim history to last 60 samples
+                max_history = 60
+                if len(self.resource_history["timestamps"]) > max_history:
+                    for key in self.resource_history:
+                        self.resource_history[key] = self.resource_history[key][-max_history:]
+                
+                # Check if we need to unload models
+                self._check_resource_constraints(memory_percent, gpu_memory_percent)
+                
+                # Log current usage
+                logger.debug(
+                    f"Resource usage - CPU: {cpu_percent:.1f}%, Memory: {memory_percent:.1f}%, "
+                    f"GPU: {gpu_utilization:.1f}%, GPU Memory: {gpu_memory_percent:.1f}%"
+                )
+                
+                # Wait for next check
+                self._stop_event.wait(self.monitoring_interval)
+                
+            except Exception as e:
+                logger.error(f"Error in resource monitoring: {str(e)}")
+                # Wait a bit before retrying
+                self._stop_event.wait(5)
+    
+    def _check_resource_constraints(self, memory_percent, gpu_memory_percent):
+        """Check if we need to unload models due to resource constraints"""
+        # Check memory usage
+        if memory_percent > self.max_memory_percent:
+            logger.warning(
+                f"Memory usage ({memory_percent:.1f}%) exceeds threshold ({self.max_memory_percent}%). "
+                "Unloading least used model."
+            )
+            # This would trigger model unloading
+            # self.registry._evict_least_used_model()
+        
+        # Check GPU memory usage
+        if HAS_GPU and gpu_memory_percent > self.max_gpu_memory_percent:
+            logger.warning(
+                f"GPU memory usage ({gpu_memory_percent:.1f}%) exceeds threshold ({self.max_gpu_memory_percent}%). "
+                "Unloading least used model."
+            )
+            # This would trigger model unloading
+            # self.registry._evict_least_used_model()
+    
+    def get_resource_usage(self) -> Dict[str, Any]:
+        """Get current resource usage stats"""
+        try:
+            cpu_percent = psutil.cpu_percent(interval=0.1)
+            memory = psutil.virtual_memory()
+            memory_percent = memory.percent
+            
+            result = {
+                "cpu_percent": cpu_percent,
+                "memory_total_gb": memory.total / (1024**3),
+                "memory_available_gb": memory.available / (1024**3),
+                "memory_percent": memory_percent,
+                "gpus": []
+            }
+            
+            # GPU stats
+            if HAS_GPU:
+                for i in range(self.gpu_count):
+                    try:
+                        handle = nvidia_smi.nvmlDeviceGetHandleByIndex(i)
+                        name = nvidia_smi.nvmlDeviceGetName(handle)
+                        util = nvidia_smi.nvmlDeviceGetUtilizationRates(handle)
+                        mem_info = nvidia_smi.nvmlDeviceGetMemoryInfo(handle)
+                        temp = nvidia_smi.nvmlDeviceGetTemperature(
+                            handle, nvidia_smi.NVML_TEMPERATURE_GPU
+                        )
+                        
+                        result["gpus"].append({
+                            "index": i,
+                            "name": name,
+                            "utilization_percent": util.gpu,
+                            "memory_total_gb": mem_info.total / (1024**3),
+                            "memory_used_gb": mem_info.used / (1024**3),
+                            "memory_percent": (mem_info.used / mem_info.total) * 100,
+                            "temperature_c": temp
+                        })
+                    except Exception as e:
+                        logger.error(f"Error getting GPU {i} stats: {str(e)}")
+            
+            return result
+        except Exception as e:
+            logger.error(f"Error getting resource usage: {str(e)}")
+            return {"error": str(e)}

isa_model/deployment/mlflow_gateway/__init__.py

@@ -0,0 +1,8 @@
+"""
+MLflow Gateway module for IsA Model.
+Replaces the custom adapter with industry-standard MLflow Gateway.
+"""
+
+from .start_gateway import start_mlflow_gateway
+
+__all__ = ["start_mlflow_gateway"] 

isa_model/deployment/mlflow_gateway/start_gateway.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+"""
+MLflow Gateway starter script.
+Replaces the custom adapter with industry-standard MLflow Gateway.
+
+Usage:
+    python -m isa_model.deployment.mlflow_gateway.start_gateway
+"""
+
+import os
+import sys
+import logging
+import subprocess
+from pathlib import Path
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+
+def start_mlflow_gateway():
+    """Start MLflow Gateway with our configuration."""
+    
+    # Get the directory containing this script
+    script_dir = Path(__file__).parent
+    config_file = script_dir / "gateway_config.yaml"
+    
+    if not config_file.exists():
+        logger.error(f"Gateway config file not found: {config_file}")
+        sys.exit(1)
+    
+    # Set environment variables
+    os.environ["MLFLOW_GATEWAY_CONFIG_PATH"] = str(config_file)
+    
+    # MLflow Gateway command
+    cmd = [
+        "mlflow", "gateway", "start",
+        "--config-path", str(config_file),
+        "--host", "0.0.0.0",
+        "--port", "8000"
+    ]
+    
+    logger.info("🚀 Starting MLflow Gateway...")
+    logger.info(f"📁 Config file: {config_file}")
+    logger.info(f"🌐 Server: http://localhost:8000")
+    logger.info(f"📚 Docs: http://localhost:8000/docs")
+    
+    try:
+        # Start the gateway
+        subprocess.run(cmd, check=True)
+    except KeyboardInterrupt:
+        logger.info("MLflow Gateway stopped by user")
+    except subprocess.CalledProcessError as e:
+        logger.error(f"MLflow Gateway failed to start: {e}")
+        sys.exit(1)
+    except Exception as e:
+        logger.error(f"Unexpected error: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    start_mlflow_gateway() 

isa_model/deployment/unified_multimodal_client.py

@@ -0,0 +1,341 @@
+#!/usr/bin/env python3
+"""
+Unified Multimodal Client
+
+This client provides a unified interface to different model types and modalities,
+abstracting away the complexity of different backends and deployment strategies.
+
+Features:
+- Text generation (chat completion)
+- Image generation
+- Audio transcription
+- Embeddings
+
+Usage:
+    from isa_model.deployment.unified_multimodal_client import UnifiedClient
+    
+    client = UnifiedClient()
+    
+    # Text generation
+    response = client.chat_completion("What is MLflow?")
+    
+    # Image generation
+    image_data = client.generate_image("A beautiful mountain landscape")
+    
+    # Audio transcription
+    transcription = client.transcribe_audio(audio_base64)
+    
+    # Embeddings
+    embeddings = client.get_embeddings("This is a test sentence.")
+"""
+
+import os
+import json
+import base64
+import requests
+import tempfile
+from typing import List, Dict, Any, Optional, Union
+from dataclasses import dataclass
+from PIL import Image
+import io
+
+@dataclass
+class DeploymentConfig:
+    """Deployment configuration for a model type"""
+    name: str
+    endpoint: str
+    api_key: Optional[str] = None
+
+class UnifiedClient:
+    """Unified client for multimodal AI models"""
+    
+    def __init__(self, adapter_url: str = "http://localhost:8300"):
+        """Initialize the client with the adapter URL"""
+        self.adapter_url = adapter_url
+        
+        # Configure deployment endpoints - directly to multimodal adapter
+        self.deployments = {
+            "text": DeploymentConfig(
+                name="default",
+                endpoint=f"{adapter_url}/v1/chat/completions"
+            ),
+            "image": DeploymentConfig(
+                name="default",
+                endpoint=f"{adapter_url}/v1/images/generations"
+            ),
+            "audio": DeploymentConfig(
+                name="default",
+                endpoint=f"{adapter_url}/v1/audio/transcriptions"
+            ),
+            "embeddings": DeploymentConfig(
+                name="default",
+                endpoint=f"{adapter_url}/v1/embeddings"
+            )
+        }
+    
+    def _make_request(self, 
+                     deployment_type: str, 
+                     payload: Dict[str, Any],
+                     files: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Make a request to the specified deployment type"""
+        if deployment_type not in self.deployments:
+            raise ValueError(f"Unsupported deployment type: {deployment_type}")
+            
+        deployment = self.deployments[deployment_type]
+        
+        headers = {
+            "Content-Type": "application/json"
+        }
+        
+        if deployment.api_key:
+            headers["Authorization"] = f"Bearer {deployment.api_key}"
+            
+        try:
+            if files:
+                # For multipart/form-data requests
+                response = requests.post(
+                    deployment.endpoint,
+                    data=payload,
+                    files=files
+                )
+            else:
+                # Ensure model is included in the payload
+                if "model" not in payload:
+                    payload["model"] = deployment.name
+                
+                # For JSON requests
+                response = requests.post(
+                    deployment.endpoint,
+                    json=payload,
+                    headers=headers
+                )
+                
+            response.raise_for_status()
+            return response.json()
+            
+        except Exception as e:
+            print(f"Error calling {deployment_type} endpoint: {str(e)}")
+            print(f"Response: {response.text if 'response' in locals() else 'No response'}")
+            raise
+    
+    def chat_completion(self, 
+                       prompt: str, 
+                       system_prompt: Optional[str] = None,
+                       max_tokens: int = 100,
+                       temperature: float = 0.7) -> str:
+        """Generate a chat completion response"""
+        messages = []
+        
+        if system_prompt:
+            messages.append({
+                "role": "system",
+                "content": system_prompt
+            })
+            
+        messages.append({
+            "role": "user",
+            "content": prompt
+        })
+        
+        payload = {
+            "messages": messages,
+            "max_tokens": max_tokens,
+            "temperature": temperature
+        }
+        
+        response = self._make_request("text", payload)
+        
+        if "choices" in response and len(response["choices"]) > 0:
+            return response["choices"][0]["message"]["content"]
+        else:
+            return "Error: No response generated"
+    
+    def generate_image(self, 
+                      prompt: str, 
+                      n: int = 1,
+                      size: str = "1024x1024") -> str:
+        """Generate an image from a text prompt"""
+        payload = {
+            "prompt": prompt,
+            "n": n,
+            "size": size
+        }
+        
+        response = self._make_request("image", payload)
+        
+        if "data" in response and len(response["data"]) > 0:
+            # Return the base64 data URL
+            return response["data"][0]["url"]
+        else:
+            return "Error: No image generated"
+    
+    def save_image(self, image_data_url: str, output_path: str) -> None:
+        """Save a base64 image data URL to a file"""
+        if image_data_url.startswith("data:image"):
+            # Extract the base64 part from the data URL
+            base64_data = image_data_url.split(",")[1]
+            
+            # Decode the base64 data
+            image_data = base64.b64decode(base64_data)
+            
+            # Save the image
+            with open(output_path, "wb") as f:
+                f.write(image_data)
+                
+            print(f"Image saved to {output_path}")
+        else:
+            raise ValueError("Invalid image data URL format")
+    
+    def transcribe_audio(self, 
+                        audio_data: Union[str, bytes],
+                        language: str = "en") -> str:
+        """
+        Transcribe audio to text
+        
+        Parameters:
+        - audio_data: Either a base64 encoded string or raw bytes
+        - language: Language code
+        
+        Returns:
+        - Transcribed text
+        """
+        # Convert bytes to base64 if needed
+        if isinstance(audio_data, bytes):
+            audio_base64 = base64.b64encode(audio_data).decode("utf-8")
+        else:
+            # Assume it's already base64 encoded
+            audio_base64 = audio_data
+            
+        payload = {
+            "file": audio_base64,
+            "language": language
+        }
+        
+        response = self._make_request("audio", payload)
+        
+        if "text" in response:
+            return response["text"]
+        else:
+            return "Error: No transcription generated"
+    
+    def transcribe_audio_file(self, 
+                            file_path: str,
+                            language: str = "en") -> str:
+        """
+        Transcribe an audio file to text
+        
+        Parameters:
+        - file_path: Path to the audio file
+        - language: Language code
+        
+        Returns:
+        - Transcribed text
+        """
+        with open(file_path, "rb") as f:
+            audio_data = f.read()
+            
+        return self.transcribe_audio(audio_data, language)
+    
+    def get_embeddings(self, 
+                      text: Union[str, List[str]]) -> List[List[float]]:
+        """
+        Get embeddings for text or a list of texts
+        
+        Parameters:
+        - text: Either a single string or a list of strings
+        
+        Returns:
+        - List of embedding vectors
+        """
+        payload = {
+            "input": text
+        }
+        
+        response = self._make_request("embeddings", payload)
+        
+        if "data" in response:
+            return [item["embedding"] for item in response["data"]]
+        else:
+            return []
+    
+    def similarity(self, text1: str, text2: str) -> float:
+        """
+        Calculate the cosine similarity between two texts
+        
+        Parameters:
+        - text1: First text
+        - text2: Second text
+        
+        Returns:
+        - Cosine similarity (0-1)
+        """
+        import numpy as np
+        
+        # Get embeddings for both texts
+        embeddings = self.get_embeddings([text1, text2])
+        
+        if len(embeddings) != 2:
+            raise ValueError("Failed to get embeddings for both texts")
+            
+        # Calculate cosine similarity
+        embedding1 = np.array(embeddings[0])
+        embedding2 = np.array(embeddings[1])
+        
+        cos_sim = np.dot(embedding1, embedding2) / (np.linalg.norm(embedding1) * np.linalg.norm(embedding2))
+        return float(cos_sim)
+
+    def health_check(self) -> bool:
+        """Check if the adapter is healthy"""
+        try:
+            response = requests.get(f"{self.adapter_url}/health")
+            return response.status_code == 200
+        except Exception as e:
+            print(f"Health check failed: {str(e)}")
+            return False
+
+if __name__ == "__main__":
+    # Test the client
+    client = UnifiedClient()
+    
+    print("\n===== Unified Multimodal Client Demo =====")
+    
+    # Check health
+    if not client.health_check():
+        print("Adapter is not healthy. Make sure it's running.")
+        exit(1)
+    
+    # Test chat completion
+    print("\nTesting chat completion...")
+    response = client.chat_completion(
+        "What are the key benefits of MLflow?",
+        system_prompt="You are a helpful AI assistant specializing in machine learning.",
+        max_tokens=150
+    )
+    print(f"\nResponse: {response}")
+    
+    # Test embeddings
+    print("\nTesting embeddings...")
+    embeddings = client.get_embeddings("What is MLflow?")
+    print(f"Embedding dimensionality: {len(embeddings[0])}")
+    print(f"First 5 values: {embeddings[0][:5]}")
+    
+    # Test similarity
+    print("\nTesting similarity...")
+    similarity = client.similarity(
+        "MLflow is a platform for managing machine learning workflows.",
+        "MLflow helps data scientists track experiments and deploy models."
+    )
+    print(f"Similarity: {similarity:.4f}")
+    
+    # Test image generation
+    print("\nTesting image generation...")
+    image_url = client.generate_image("A beautiful mountain landscape")
+    print(f"Image URL: {image_url[:30]}...")
+    
+    # Test audio transcription
+    print("\nTesting audio transcription...")
+    dummy_audio = base64.b64encode(b"dummy audio data").decode("utf-8")
+    transcription = client.transcribe_audio(dummy_audio)
+    print(f"Transcription: {transcription}")
+    
+    print("\n===== Demo Complete =====") 

isa_model/inference/__init__.py

@@ -0,0 +1,11 @@
+"""
+Inference module for isA_Model
+
+File: isa_model/inference/__init__.py
+This module provides the main inference components for the IsA Model system.
+"""
+
+from .ai_factory import AIFactory
+from .base import ModelType, Capability, RoutingStrategy
+
+__all__ = ["AIFactory", "ModelType", "Capability", "RoutingStrategy"]