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

isa_model/core/storage/hf_storage.py

@@ -1,419 +0,0 @@
-"""
-HuggingFace Hub Storage Implementation
-
-Provides storage capabilities using HuggingFace Hub as the backend.
-Supports uploading trained models, managing versions, and metadata.
-"""
-
-import os
-import json
-import logging
-from typing import Optional, Dict, Any, List
-from pathlib import Path
-import tempfile
-import shutil
-from datetime import datetime
-
-try:
-    from huggingface_hub import HfApi, create_repo, upload_folder, snapshot_download
-    from huggingface_hub.errors import HfHubHTTPError
-    HF_HUB_AVAILABLE = True
-except ImportError:
-    HF_HUB_AVAILABLE = False
-
-from ..models.model_storage import ModelStorage
-
-logger = logging.getLogger(__name__)
-
-
-class HuggingFaceStorage(ModelStorage):
-    """
-    HuggingFace Hub storage implementation for model management.
-    
-    This storage backend uploads models to HuggingFace Hub and manages
-    them using the repository system. Perfect for sharing trained models
-    and maintaining versions.
-    
-    Example:
-        ```python
-        from isa_model.core.storage import HuggingFaceStorage
-        
-        storage = HuggingFaceStorage(
-            username="xenobordom",
-            token=os.getenv("HF_TOKEN")  # Set in environment
-        )
-        
-        # Save a trained model to HuggingFace Hub
-        await storage.save_model(
-            model_id="gemma-4b-alpaca-v1",
-            model_path="./trained_models/gemma-4b",
-            metadata={
-                "base_model": "google/gemma-2-4b-it",
-                "dataset": "tatsu-lab/alpaca",
-                "training_method": "LoRA + Unsloth"
-            }
-        )
-        ```
-    """
-    
-    def __init__(self, 
-                 username: str = "xenobordom",
-                 token: Optional[str] = None,
-                 private: bool = False,
-                 local_cache_dir: str = "./models/hf_cache"):
-        """
-        Initialize HuggingFace storage.
-        
-        Args:
-            username: HuggingFace username (default: xenobordom)
-            token: HuggingFace API token (from env if not provided)
-            private: Whether to create private repositories
-            local_cache_dir: Local cache directory for downloaded models
-        """
-        if not HF_HUB_AVAILABLE:
-            raise ImportError("huggingface_hub is required. Install with: pip install huggingface_hub")
-        
-        self.username = username
-        self.token = token or os.getenv("HF_TOKEN")
-        self.private = private
-        self.local_cache_dir = Path(local_cache_dir)
-        self.local_cache_dir.mkdir(parents=True, exist_ok=True)
-        
-        if not self.token:
-            raise ValueError("HuggingFace token is required. Set HF_TOKEN environment variable or pass token parameter.")
-        
-        # Initialize HF API
-        self.api = HfApi(token=self.token)
-        
-        # Local metadata storage
-        self.metadata_file = self.local_cache_dir / "hf_models_metadata.json"
-        self._load_metadata()
-        
-        logger.info(f"HuggingFace storage initialized for user: {self.username}")
-        logger.info(f"Local cache directory: {self.local_cache_dir}")
-    
-    def _load_metadata(self):
-        """Load local metadata cache"""
-        if self.metadata_file.exists():
-            with open(self.metadata_file, 'r') as f:
-                self.metadata = json.load(f)
-        else:
-            self.metadata = {}
-            self._save_metadata()
-    
-    def _save_metadata(self):
-        """Save local metadata cache"""
-        with open(self.metadata_file, 'w') as f:
-            json.dump(self.metadata, f, indent=2)
-    
-    def _get_repo_id(self, model_id: str) -> str:
-        """Get full repository ID for a model"""
-        return f"{self.username}/{model_id}"
-    
-    async def save_model(self, model_id: str, model_path: str, metadata: Dict[str, Any]) -> bool:
-        """
-        Save model to HuggingFace Hub.
-        
-        Args:
-            model_id: Unique identifier for the model (will be repo name)
-            model_path: Local path to model files
-            metadata: Model metadata to include
-            
-        Returns:
-            True if successful, False otherwise
-        """
-        try:
-            repo_id = self._get_repo_id(model_id)
-            source_path = Path(model_path)
-            
-            logger.info(f"Uploading model {model_id} to HuggingFace Hub: {repo_id}")
-            
-            # Create repository if it doesn't exist
-            try:
-                create_repo(
-                    repo_id=repo_id,
-                    token=self.token,
-                    private=self.private,
-                    exist_ok=True
-                )
-                logger.info(f"Repository created/verified: {repo_id}")
-            except Exception as e:
-                logger.warning(f"Repository creation warning: {e}")
-            
-            # Prepare metadata for README
-            readme_content = self._generate_model_card(model_id, metadata)
-            
-            # Create temporary directory for upload preparation
-            with tempfile.TemporaryDirectory() as temp_dir:
-                temp_path = Path(temp_dir)
-                
-                # Copy model files
-                if source_path.is_file():
-                    shutil.copy2(source_path, temp_path / source_path.name)
-                else:
-                    # Copy entire directory
-                    for item in source_path.rglob("*"):
-                        if item.is_file():
-                            relative_path = item.relative_to(source_path)
-                            dest_path = temp_path / relative_path
-                            dest_path.parent.mkdir(parents=True, exist_ok=True)
-                            shutil.copy2(item, dest_path)
-                
-                # Add README.md
-                with open(temp_path / "README.md", 'w') as f:
-                    f.write(readme_content)
-                
-                # Add metadata.json
-                enhanced_metadata = {
-                    **metadata,
-                    "model_id": model_id,
-                    "repo_id": repo_id,
-                    "uploaded_at": datetime.now().isoformat(),
-                    "uploaded_by": self.username,
-                    "storage_backend": "huggingface_hub"
-                }
-                
-                with open(temp_path / "metadata.json", 'w') as f:
-                    json.dump(enhanced_metadata, f, indent=2)
-                
-                # Upload to HuggingFace Hub
-                upload_folder(
-                    folder_path=str(temp_path),
-                    repo_id=repo_id,
-                    token=self.token,
-                    commit_message=f"Upload {model_id} - {metadata.get('description', 'Model upload')}"
-                )
-            
-            # Update local metadata
-            self.metadata[model_id] = {
-                **enhanced_metadata,
-                "local_cache_path": str(self.local_cache_dir / model_id),
-                "repo_url": f"https://huggingface.co/{repo_id}"
-            }
-            self._save_metadata()
-            
-            logger.info(f"Model {model_id} uploaded successfully to {repo_id}")
-            return True
-            
-        except Exception as e:
-            logger.error(f"Failed to save model {model_id} to HuggingFace Hub: {e}")
-            return False
-    
-    async def load_model(self, model_id: str) -> Optional[Path]:
-        """
-        Load model from HuggingFace Hub.
-        
-        Args:
-            model_id: Model identifier
-            
-        Returns:
-            Path to local model files
-        """
-        try:
-            repo_id = self._get_repo_id(model_id)
-            local_path = self.local_cache_dir / model_id
-            
-            # Check if already cached
-            if local_path.exists() and model_id in self.metadata:
-                logger.info(f"Using cached model {model_id}")
-                return local_path
-            
-            logger.info(f"Downloading model {model_id} from HuggingFace Hub: {repo_id}")
-            
-            # Download from HuggingFace Hub
-            snapshot_download(
-                repo_id=repo_id,
-                local_dir=str(local_path),
-                token=self.token,
-                local_dir_use_symlinks=False
-            )
-            
-            # Load metadata if available
-            metadata_file = local_path / "metadata.json"
-            if metadata_file.exists():
-                with open(metadata_file, 'r') as f:
-                    metadata = json.load(f)
-                
-                self.metadata[model_id] = {
-                    **metadata,
-                    "local_cache_path": str(local_path),
-                    "last_downloaded": datetime.now().isoformat()
-                }
-                self._save_metadata()
-            
-            logger.info(f"Model {model_id} downloaded successfully")
-            return local_path
-            
-        except HfHubHTTPError as e:
-            if e.response.status_code == 404:
-                logger.error(f"Model {model_id} not found on HuggingFace Hub")
-            else:
-                logger.error(f"Failed to load model {model_id}: {e}")
-            return None
-        except Exception as e:
-            logger.error(f"Failed to load model {model_id}: {e}")
-            return None
-    
-    async def delete_model(self, model_id: str) -> bool:
-        """
-        Delete model from HuggingFace Hub and local cache.
-        
-        Args:
-            model_id: Model identifier
-            
-        Returns:
-            True if successful, False otherwise
-        """
-        try:
-            repo_id = self._get_repo_id(model_id)
-            
-            # Delete from HuggingFace Hub
-            try:
-                self.api.delete_repo(repo_id=repo_id, token=self.token)
-                logger.info(f"Deleted repository {repo_id} from HuggingFace Hub")
-            except Exception as e:
-                logger.warning(f"Failed to delete repository {repo_id}: {e}")
-            
-            # Delete local cache
-            local_path = self.local_cache_dir / model_id
-            if local_path.exists():
-                shutil.rmtree(local_path)
-                logger.info(f"Deleted local cache for {model_id}")
-            
-            # Remove from metadata
-            if model_id in self.metadata:
-                del self.metadata[model_id]
-                self._save_metadata()
-            
-            return True
-            
-        except Exception as e:
-            logger.error(f"Failed to delete model {model_id}: {e}")
-            return False
-    
-    async def get_metadata(self, model_id: str) -> Optional[Dict[str, Any]]:
-        """Get model metadata"""
-        return self.metadata.get(model_id)
-    
-    async def list_models(self) -> Dict[str, Dict[str, Any]]:
-        """List all models managed by this storage"""
-        return self.metadata.copy()
-    
-    def _generate_model_card(self, model_id: str, metadata: Dict[str, Any]) -> str:
-        """Generate a model card for HuggingFace Hub"""
-        base_model = metadata.get("base_model", "Unknown")
-        dataset = metadata.get("dataset", "Unknown")
-        training_method = metadata.get("training_method", "Unknown")
-        description = metadata.get("description", f"Fine-tuned {base_model}")
-        
-        model_card = f"""---
-license: apache-2.0
-base_model: {base_model}
-tags:
-- generated_from_trainer
-- isa-model
-- {training_method.lower().replace(' ', '-')}
-datasets:
-- {dataset}
-language:
-- en
-pipeline_tag: text-generation
----
-
-# {model_id}
-
-{description}
-
-## Model Details
-
-- **Base Model**: {base_model}
-- **Training Dataset**: {dataset}
-- **Training Method**: {training_method}
-- **Uploaded by**: {self.username}
-- **Framework**: ISA Model SDK
-
-## Training Details
-
-"""
-        
-        # Add training configuration if available
-        if "config" in metadata:
-            config = metadata["config"]
-            model_card += f"""
-### Training Configuration
-
-- **Epochs**: {config.get('num_epochs', 'Unknown')}
-- **Batch Size**: {config.get('batch_size', 'Unknown')}
-- **Learning Rate**: {config.get('learning_rate', 'Unknown')}
-- **LoRA**: {'Yes' if config.get('use_lora', False) else 'No'}
-"""
-            
-            if config.get('use_lora', False):
-                lora_config = config.get('lora_config', {})
-                model_card += f"""
-### LoRA Configuration
-
-- **LoRA Rank**: {lora_config.get('lora_rank', 'Unknown')}
-- **LoRA Alpha**: {lora_config.get('lora_alpha', 'Unknown')}
-- **LoRA Dropout**: {lora_config.get('lora_dropout', 'Unknown')}
-"""
-        
-        model_card += f"""
-
-## Usage
-
-```python
-from transformers import AutoTokenizer, AutoModelForCausalLM
-
-tokenizer = AutoTokenizer.from_pretrained("{self._get_repo_id(model_id)}")
-model = AutoModelForCausalLM.from_pretrained("{self._get_repo_id(model_id)}")
-
-# For inference
-inputs = tokenizer("Your prompt here", return_tensors="pt")
-outputs = model.generate(**inputs, max_length=100)
-response = tokenizer.decode(outputs[0], skip_special_tokens=True)
-print(response)
-```
-
-## ISA Model SDK
-
-This model was trained using the [ISA Model SDK](https://github.com/your-repo/isA_Model), 
-a comprehensive framework for training and deploying AI models.
-
-"""
-        
-        return model_card
-    
-    def get_public_url(self, model_id: str) -> str:
-        """Get public URL for a model on HuggingFace Hub"""
-        return f"https://huggingface.co/{self._get_repo_id(model_id)}"
-    
-    async def update_model_metadata(self, model_id: str, new_metadata: Dict[str, Any]) -> bool:
-        """Update model metadata on HuggingFace Hub"""
-        try:
-            if model_id not in self.metadata:
-                logger.error(f"Model {model_id} not found in metadata")
-                return False
-            
-            # Update local metadata
-            self.metadata[model_id].update(new_metadata)
-            self._save_metadata()
-            
-            # Update README on HuggingFace Hub
-            repo_id = self._get_repo_id(model_id)
-            readme_content = self._generate_model_card(model_id, self.metadata[model_id])
-            
-            self.api.upload_file(
-                path_or_fileobj=readme_content.encode('utf-8'),
-                path_in_repo="README.md",
-                repo_id=repo_id,
-                token=self.token,
-                commit_message=f"Update metadata for {model_id}"
-            )
-            
-            logger.info(f"Updated metadata for model {model_id}")
-            return True
-            
-        except Exception as e:
-            logger.error(f"Failed to update metadata for {model_id}: {e}")
-            return False

isa_model/deployment/local/__init__.py

@@ -1,31 +0,0 @@
-"""
-Local GPU deployment module
-
-This module provides local GPU model deployment capabilities including:
-- Direct GPU resource management
-- vLLM integration for high-performance inference
-- TensorRT-LLM native deployment (non-containerized)
-- HuggingFace Transformers direct deployment
-- Local service monitoring and health checks
-"""
-
-from .provider import LocalGPUProvider
-from .config import (
-    LocalGPUConfig, LocalServiceType, LocalBackend,
-    create_vllm_config, create_tensorrt_config, create_transformers_config,
-    create_vision_config, create_embedding_config
-)
-from .health_checker import LocalHealthChecker
-
-__all__ = [
-    'LocalGPUProvider',
-    'LocalGPUConfig', 
-    'LocalServiceType',
-    'LocalBackend',
-    'LocalHealthChecker',
-    'create_vllm_config',
-    'create_tensorrt_config', 
-    'create_transformers_config',
-    'create_vision_config',
-    'create_embedding_config'
-]

isa_model/deployment/local/config.py

@@ -1,248 +0,0 @@
-"""
-Local GPU deployment configuration
-
-Configuration classes for local GPU model deployment.
-"""
-
-from dataclasses import dataclass, field
-from typing import Dict, Any, Optional, List
-from enum import Enum
-from pathlib import Path
-
-
-class LocalServiceType(Enum):
-    """Local service types"""
-    LLM = "llm"
-    VISION = "vision" 
-    AUDIO = "audio"
-    EMBEDDING = "embedding"
-    IMAGE_GENERATION = "image_generation"
-
-
-class LocalBackend(Enum):
-    """Local inference backends"""
-    VLLM = "vllm"
-    TENSORRT_LLM = "tensorrt_llm"
-    TRANSFORMERS = "transformers"
-    ONNX = "onnxruntime"
-    OPENVINO = "openvino"
-
-
-@dataclass
-class LocalGPUConfig:
-    """Configuration for local GPU model deployment"""
-    
-    # Service identification
-    service_name: str
-    service_type: LocalServiceType
-    model_id: str
-    backend: LocalBackend = LocalBackend.TRANSFORMERS
-    
-    # GPU configuration
-    gpu_id: Optional[int] = None  # None = auto-select best GPU
-    gpu_memory_fraction: float = 0.9  # Fraction of GPU memory to use
-    enable_gpu: bool = True
-    
-    # Model configuration
-    model_precision: str = "float16"  # float32, float16, int8, int4
-    max_model_len: int = 2048
-    max_batch_size: int = 8
-    
-    # Performance settings
-    enable_chunked_prefill: bool = True
-    max_num_seqs: int = 256
-    tensor_parallel_size: int = 1
-    pipeline_parallel_size: int = 1
-    
-    # Memory optimization
-    enable_prefix_caching: bool = True
-    gpu_memory_utilization: float = 0.9
-    swap_space: int = 4  # GB
-    cpu_offload: bool = False
-    
-    # Quantization settings
-    quantization: Optional[str] = None  # awq, gptq, squeezellm, etc.
-    quantization_param_path: Optional[str] = None
-    
-    # Serving configuration
-    host: str = "127.0.0.1"
-    port: int = 8000
-    api_key: Optional[str] = None
-    served_model_name: Optional[str] = None
-    
-    # Advanced settings
-    trust_remote_code: bool = False
-    revision: Optional[str] = None
-    tokenizer_revision: Optional[str] = None
-    
-    # Specific backend configurations
-    vllm_args: Dict[str, Any] = field(default_factory=dict)
-    tensorrt_args: Dict[str, Any] = field(default_factory=dict)
-    transformers_args: Dict[str, Any] = field(default_factory=dict)
-    
-    # Environment and paths
-    model_cache_dir: Optional[str] = None
-    download_dir: Optional[str] = None
-    
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dictionary for serialization"""
-        return {
-            "service_name": self.service_name,
-            "service_type": self.service_type.value,
-            "model_id": self.model_id,
-            "backend": self.backend.value,
-            "gpu_id": self.gpu_id,
-            "gpu_memory_fraction": self.gpu_memory_fraction,
-            "enable_gpu": self.enable_gpu,
-            "model_precision": self.model_precision,
-            "max_model_len": self.max_model_len,
-            "max_batch_size": self.max_batch_size,
-            "enable_chunked_prefill": self.enable_chunked_prefill,
-            "max_num_seqs": self.max_num_seqs,
-            "tensor_parallel_size": self.tensor_parallel_size,
-            "pipeline_parallel_size": self.pipeline_parallel_size,
-            "enable_prefix_caching": self.enable_prefix_caching,
-            "gpu_memory_utilization": self.gpu_memory_utilization,
-            "swap_space": self.swap_space,
-            "cpu_offload": self.cpu_offload,
-            "quantization": self.quantization,
-            "quantization_param_path": self.quantization_param_path,
-            "host": self.host,
-            "port": self.port,
-            "api_key": self.api_key,
-            "served_model_name": self.served_model_name,
-            "trust_remote_code": self.trust_remote_code,
-            "revision": self.revision,
-            "tokenizer_revision": self.tokenizer_revision,
-            "vllm_args": self.vllm_args,
-            "tensorrt_args": self.tensorrt_args,
-            "transformers_args": self.transformers_args,
-            "model_cache_dir": self.model_cache_dir,
-            "download_dir": self.download_dir
-        }
-    
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "LocalGPUConfig":
-        """Create from dictionary"""
-        return cls(
-            service_name=data["service_name"],
-            service_type=LocalServiceType(data["service_type"]),
-            model_id=data["model_id"],
-            backend=LocalBackend(data.get("backend", "transformers")),
-            gpu_id=data.get("gpu_id"),
-            gpu_memory_fraction=data.get("gpu_memory_fraction", 0.9),
-            enable_gpu=data.get("enable_gpu", True),
-            model_precision=data.get("model_precision", "float16"),
-            max_model_len=data.get("max_model_len", 2048),
-            max_batch_size=data.get("max_batch_size", 8),
-            enable_chunked_prefill=data.get("enable_chunked_prefill", True),
-            max_num_seqs=data.get("max_num_seqs", 256),
-            tensor_parallel_size=data.get("tensor_parallel_size", 1),
-            pipeline_parallel_size=data.get("pipeline_parallel_size", 1),
-            enable_prefix_caching=data.get("enable_prefix_caching", True),
-            gpu_memory_utilization=data.get("gpu_memory_utilization", 0.9),
-            swap_space=data.get("swap_space", 4),
-            cpu_offload=data.get("cpu_offload", False),
-            quantization=data.get("quantization"),
-            quantization_param_path=data.get("quantization_param_path"),
-            host=data.get("host", "127.0.0.1"),
-            port=data.get("port", 8000),
-            api_key=data.get("api_key"),
-            served_model_name=data.get("served_model_name"),
-            trust_remote_code=data.get("trust_remote_code", False),
-            revision=data.get("revision"),
-            tokenizer_revision=data.get("tokenizer_revision"),
-            vllm_args=data.get("vllm_args", {}),
-            tensorrt_args=data.get("tensorrt_args", {}),
-            transformers_args=data.get("transformers_args", {}),
-            model_cache_dir=data.get("model_cache_dir"),
-            download_dir=data.get("download_dir")
-        )
-
-
-# Predefined configurations for common use cases
-def create_vllm_config(service_name: str, model_id: str,
-                       max_model_len: int = 2048,
-                       tensor_parallel_size: int = 1) -> LocalGPUConfig:
-    """Create optimized vLLM configuration"""
-    return LocalGPUConfig(
-        service_name=service_name,
-        service_type=LocalServiceType.LLM,
-        model_id=model_id,
-        backend=LocalBackend.VLLM,
-        max_model_len=max_model_len,
-        tensor_parallel_size=tensor_parallel_size,
-        enable_chunked_prefill=True,
-        enable_prefix_caching=True,
-        gpu_memory_utilization=0.9,
-        model_precision="float16"
-    )
-
-
-def create_tensorrt_config(service_name: str, model_id: str,
-                          max_batch_size: int = 8,
-                          precision: str = "float16") -> LocalGPUConfig:
-    """Create TensorRT-LLM configuration"""
-    return LocalGPUConfig(
-        service_name=service_name,
-        service_type=LocalServiceType.LLM,
-        model_id=model_id,
-        backend=LocalBackend.TENSORRT_LLM,
-        max_batch_size=max_batch_size,
-        model_precision=precision,
-        tensor_parallel_size=1,
-        tensorrt_args={
-            "enable_kv_cache_reuse": True,
-            "remove_input_padding": True,
-            "use_gpt_attention_plugin": True
-        }
-    )
-
-
-def create_transformers_config(service_name: str, model_id: str,
-                             precision: str = "float16",
-                             quantization: Optional[str] = None) -> LocalGPUConfig:
-    """Create HuggingFace Transformers configuration"""
-    return LocalGPUConfig(
-        service_name=service_name,
-        service_type=LocalServiceType.LLM,
-        model_id=model_id,
-        backend=LocalBackend.TRANSFORMERS,
-        model_precision=precision,
-        quantization=quantization,
-        max_batch_size=4,  # Lower for memory efficiency
-        transformers_args={
-            "device_map": "auto",
-            "torch_dtype": "auto",
-            "low_cpu_mem_usage": True
-        }
-    )
-
-
-def create_vision_config(service_name: str, model_id: str,
-                        backend: LocalBackend = LocalBackend.TRANSFORMERS) -> LocalGPUConfig:
-    """Create vision model configuration"""
-    return LocalGPUConfig(
-        service_name=service_name,
-        service_type=LocalServiceType.VISION,
-        model_id=model_id,
-        backend=backend,
-        max_batch_size=16,
-        model_precision="float16",
-        gpu_memory_utilization=0.8  # Lower for vision models
-    )
-
-
-def create_embedding_config(service_name: str, model_id: str,
-                           max_batch_size: int = 32) -> LocalGPUConfig:
-    """Create embedding model configuration"""
-    return LocalGPUConfig(
-        service_name=service_name,
-        service_type=LocalServiceType.EMBEDDING,
-        model_id=model_id,
-        backend=LocalBackend.TRANSFORMERS,
-        max_batch_size=max_batch_size,
-        model_precision="float16",
-        gpu_memory_utilization=0.7,  # Lower memory usage for embeddings
-        cpu_offload=False
-    )