isa-model 0.0.1__py3-none-any.whl → 0.0.2__py3-none-any.whl

isa_model/training/factory.py

@@ -0,0 +1,393 @@
+"""
+Unified Training Factory for ISA Model Framework
+
+This factory provides a single interface for all training operations:
+- LLM fine-tuning (SFT, DPO, RLHF)
+- Image model training (Flux, LoRA)
+- Model evaluation and benchmarking
+"""
+
+import os
+import logging
+from typing import Optional, Dict, Any, Union, List
+from pathlib import Path
+import datetime
+
+from .engine.llama_factory import LlamaFactory, TrainingStrategy, DatasetFormat
+from .engine.llama_factory.config import SFTConfig, RLConfig, DPOConfig
+
+logger = logging.getLogger(__name__)
+
+
+class TrainingFactory:
+    """
+    Unified factory for all AI model training operations.
+    
+    This class provides simplified interfaces for:
+    - LLM training using LlamaFactory
+    - Image model training using Flux/LoRA
+    - Model evaluation and benchmarking
+    
+    Example usage for fine-tuning Gemma 3:4B:
+        ```python
+        from isa_model.training import TrainingFactory
+        
+        factory = TrainingFactory()
+        
+        # Fine-tune with your dataset
+        model_path = factory.finetune_llm(
+            model_name="google/gemma-2-4b-it",
+            dataset_path="path/to/your/data.json",
+            training_type="sft",
+            use_lora=True,
+            num_epochs=3,
+            batch_size=4,
+            learning_rate=2e-5
+        )
+        
+        # Train with DPO for preference optimization
+        dpo_model = factory.train_with_preferences(
+            model_path=model_path,
+            preference_data="path/to/preferences.json",
+            beta=0.1
+        )
+        ```
+    """
+    
+    def __init__(self, base_output_dir: Optional[str] = None):
+        """
+        Initialize the training factory.
+        
+        Args:
+            base_output_dir: Base directory for all training outputs
+        """
+        self.base_output_dir = base_output_dir or os.path.join(os.getcwd(), "training_outputs")
+        os.makedirs(self.base_output_dir, exist_ok=True)
+        
+        # Initialize sub-factories
+        self.llm_factory = LlamaFactory(base_output_dir=os.path.join(self.base_output_dir, "llm"))
+        
+        logger.info(f"TrainingFactory initialized with output dir: {self.base_output_dir}")
+    
+    def _get_output_dir(self, model_name: str, training_type: str) -> str:
+        """Generate timestamped output directory."""
+        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+        safe_model_name = model_name.replace("/", "_").replace(":", "_")
+        return os.path.join(self.base_output_dir, f"{safe_model_name}_{training_type}_{timestamp}")
+    
+    # =================
+    # LLM Training Methods
+    # =================
+    
+    def finetune_llm(
+        self,
+        model_name: str,
+        dataset_path: str,
+        training_type: str = "sft",
+        output_dir: Optional[str] = None,
+        dataset_format: str = "alpaca",
+        use_lora: bool = True,
+        batch_size: int = 4,
+        num_epochs: int = 3,
+        learning_rate: float = 2e-5,
+        max_length: int = 1024,
+        lora_rank: int = 8,
+        lora_alpha: int = 16,
+        val_dataset_path: Optional[str] = None,
+        **kwargs
+    ) -> str:
+        """
+        Fine-tune an LLM model.
+        
+        Args:
+            model_name: Model identifier (e.g., "google/gemma-2-4b-it", "meta-llama/Llama-2-7b-hf")
+            dataset_path: Path to training dataset
+            training_type: Type of training ("sft", "dpo", "rlhf")
+            output_dir: Custom output directory
+            dataset_format: Dataset format ("alpaca", "sharegpt", "custom")
+            use_lora: Whether to use LoRA for efficient training
+            batch_size: Training batch size
+            num_epochs: Number of training epochs
+            learning_rate: Learning rate
+            max_length: Maximum sequence length
+            lora_rank: LoRA rank parameter
+            lora_alpha: LoRA alpha parameter
+            val_dataset_path: Path to validation dataset (optional)
+            **kwargs: Additional training parameters
+            
+        Returns:
+            Path to the trained model
+            
+        Example:
+            ```python
+            # Fine-tune Gemma 3:4B with your dataset
+            model_path = factory.finetune_llm(
+                model_name="google/gemma-2-4b-it",
+                dataset_path="my_training_data.json",
+                training_type="sft",
+                use_lora=True,
+                num_epochs=3,
+                batch_size=4
+            )
+            ```
+        """
+        if not output_dir:
+            output_dir = self._get_output_dir(model_name, training_type)
+        
+        # Convert format string to enum
+        format_map = {
+            "alpaca": DatasetFormat.ALPACA,
+            "sharegpt": DatasetFormat.SHAREGPT,
+            "custom": DatasetFormat.CUSTOM
+        }
+        dataset_format_enum = format_map.get(dataset_format, DatasetFormat.ALPACA)
+        
+        if training_type.lower() == "sft":
+            return self.llm_factory.finetune(
+                model_path=model_name,
+                train_data=dataset_path,
+                val_data=val_dataset_path,
+                output_dir=output_dir,
+                dataset_format=dataset_format_enum,
+                use_lora=use_lora,
+                batch_size=batch_size,
+                num_epochs=num_epochs,
+                learning_rate=learning_rate,
+                max_length=max_length,
+                lora_rank=lora_rank,
+                lora_alpha=lora_alpha,
+                **kwargs
+            )
+        else:
+            raise ValueError(f"Training type '{training_type}' not supported yet. Use 'sft' for now.")
+    
+    def train_with_preferences(
+        self,
+        model_path: str,
+        preference_data: str,
+        output_dir: Optional[str] = None,
+        reference_model: Optional[str] = None,
+        beta: float = 0.1,
+        use_lora: bool = True,
+        batch_size: int = 4,
+        num_epochs: int = 3,
+        learning_rate: float = 5e-6,
+        val_data: Optional[str] = None,
+        **kwargs
+    ) -> str:
+        """
+        Train model with preference data using DPO.
+        
+        Args:
+            model_path: Path to the base model
+            preference_data: Path to preference dataset
+            output_dir: Custom output directory
+            reference_model: Reference model for DPO (optional)
+            beta: DPO beta parameter
+            use_lora: Whether to use LoRA
+            batch_size: Training batch size
+            num_epochs: Number of epochs
+            learning_rate: Learning rate
+            val_data: Validation data path
+            **kwargs: Additional parameters
+            
+        Returns:
+            Path to the trained model
+        """
+        if not output_dir:
+            model_name = os.path.basename(model_path)
+            output_dir = self._get_output_dir(model_name, "dpo")
+        
+        return self.llm_factory.dpo(
+            model_path=model_path,
+            train_data=preference_data,
+            val_data=val_data,
+            reference_model=reference_model,
+            output_dir=output_dir,
+            use_lora=use_lora,
+            batch_size=batch_size,
+            num_epochs=num_epochs,
+            learning_rate=learning_rate,
+            beta=beta,
+            **kwargs
+        )
+    
+    def train_reward_model(
+        self,
+        model_path: str,
+        reward_data: str,
+        output_dir: Optional[str] = None,
+        use_lora: bool = True,
+        batch_size: int = 8,
+        num_epochs: int = 3,
+        learning_rate: float = 1e-5,
+        val_data: Optional[str] = None,
+        **kwargs
+    ) -> str:
+        """
+        Train a reward model for RLHF.
+        
+        Args:
+            model_path: Base model path
+            reward_data: Reward training data
+            output_dir: Output directory
+            use_lora: Whether to use LoRA
+            batch_size: Batch size
+            num_epochs: Number of epochs
+            learning_rate: Learning rate
+            val_data: Validation data
+            **kwargs: Additional parameters
+            
+        Returns:
+            Path to trained reward model
+        """
+        if not output_dir:
+            model_name = os.path.basename(model_path)
+            output_dir = self._get_output_dir(model_name, "reward")
+        
+        return self.llm_factory.train_reward_model(
+            model_path=model_path,
+            train_data=reward_data,
+            val_data=val_data,
+            output_dir=output_dir,
+            use_lora=use_lora,
+            batch_size=batch_size,
+            num_epochs=num_epochs,
+            learning_rate=learning_rate,
+            **kwargs
+        )
+    
+    # =================
+    # Image Model Training Methods
+    # =================
+    
+    def train_image_model(
+        self,
+        model_type: str = "flux",
+        training_images_dir: str = "",
+        output_dir: Optional[str] = None,
+        use_lora: bool = True,
+        num_epochs: int = 1000,
+        batch_size: int = 1,
+        learning_rate: float = 1e-4,
+        **kwargs
+    ) -> str:
+        """
+        Train an image generation model.
+        
+        Args:
+            model_type: Type of model ("flux", "lora")
+            training_images_dir: Directory containing training images
+            output_dir: Output directory
+            use_lora: Whether to use LoRA
+            num_epochs: Training epochs
+            batch_size: Batch size
+            learning_rate: Learning rate
+            **kwargs: Additional parameters
+            
+        Returns:
+            Path to trained model
+        """
+        if not output_dir:
+            output_dir = self._get_output_dir("image_model", model_type)
+        
+        # TODO: Implement image model training
+        logger.warning("Image model training not fully implemented yet")
+        return output_dir
+    
+    # =================
+    # Utility Methods
+    # =================
+    
+    def get_training_status(self, output_dir: str) -> Dict[str, Any]:
+        """
+        Get training status from output directory.
+        
+        Args:
+            output_dir: Training output directory
+            
+        Returns:
+            Dictionary with training status information
+        """
+        status = {
+            "output_dir": output_dir,
+            "exists": os.path.exists(output_dir),
+            "files": []
+        }
+        
+        if status["exists"]:
+            status["files"] = os.listdir(output_dir)
+            
+        return status
+    
+    def list_trained_models(self) -> List[Dict[str, Any]]:
+        """
+        List all trained models in the output directory.
+        
+        Returns:
+            List of model information dictionaries
+        """
+        models = []
+        
+        if os.path.exists(self.base_output_dir):
+            for item in os.listdir(self.base_output_dir):
+                item_path = os.path.join(self.base_output_dir, item)
+                if os.path.isdir(item_path):
+                    models.append({
+                        "name": item,
+                        "path": item_path,
+                        "created": datetime.datetime.fromtimestamp(
+                            os.path.getctime(item_path)
+                        ).isoformat()
+                    })
+        
+        return sorted(models, key=lambda x: x["created"], reverse=True)
+
+
+# Convenience functions for quick access
+def finetune_gemma(
+    dataset_path: str,
+    model_size: str = "4b",
+    output_dir: Optional[str] = None,
+    **kwargs
+) -> str:
+    """
+    Quick function to fine-tune Gemma models.
+    
+    Args:
+        dataset_path: Path to training dataset
+        model_size: Model size ("2b", "4b", "7b")
+        output_dir: Output directory
+        **kwargs: Additional training parameters
+        
+    Returns:
+        Path to fine-tuned model
+        
+    Example:
+        ```python
+        from isa_model.training import finetune_gemma
+        
+        model_path = finetune_gemma(
+            dataset_path="my_data.json",
+            model_size="4b",
+            num_epochs=3,
+            batch_size=4
+        )
+        ```
+    """
+    factory = TrainingFactory()
+    
+    model_map = {
+        "2b": "google/gemma-2-2b-it",
+        "4b": "google/gemma-2-4b-it", 
+        "7b": "google/gemma-2-7b-it"
+    }
+    
+    model_name = model_map.get(model_size, "google/gemma-2-4b-it")
+    
+    return factory.finetune_llm(
+        model_name=model_name,
+        dataset_path=dataset_path,
+        output_dir=output_dir,
+        **kwargs
+    ) 

{isa_model-0.0.1.dist-info → isa_model-0.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isa-model
-Version: 0.0.1
+Version: 0.0.2
 Summary: Unified AI model serving framework
 Author-email: isA_Model Contributors <your.email@example.com>
 License-Expression: MIT

{isa_model-0.0.1.dist-info → isa_model-0.0.2.dist-info}/RECORD

@@ -13,6 +13,10 @@ isa_model/deployment/gpu_fp16_ds8/scripts/download_model.py,sha256=E6iSAgBu3OGfK
 isa_model/deployment/gpu_int8_ds8/app/server.py,sha256=lwWxdnR2DNEd0vIGQyfabKtDSUzSHVQsy3Z_AJejpVg,2102
 isa_model/deployment/gpu_int8_ds8/scripts/test_client.py,sha256=aCULgRYzEQj_ELUK1bmPgN99yvFgNR5C0O3gc8S32pg,1421
 isa_model/deployment/gpu_int8_ds8/scripts/test_client_os.py,sha256=XXrneTCHUeh1LNRcu-YtZQ5B4pNawlrxC-cTWmJU2A8,936
+isa_model/eval/__init__.py,sha256=3sM7qLSIL_RMKcsmkCYcjOjv9ozuk16r7pnl4F-XeNA,1197
+isa_model/eval/benchmarks.py,sha256=_L4Vwj2hwf2yhqoleIASO9z5e3LRCClCVEVCQbGt0I8,16885
+isa_model/eval/factory.py,sha256=JmGRLTYPtZLqKwy8o1Z9NHUHX6mkRDw13ac_Qin_VrE,19529
+isa_model/eval/metrics.py,sha256=mYeGwSa9PkgY0p-vadAscvak-pLrVfCSrsmAodVpgNQ,22584
 isa_model/inference/__init__.py,sha256=usfuQJ4zYY2RRtHkE-V6LuJ5aN7WJogtPUj9Qmy4Wvw,318
 isa_model/inference/ai_factory.py,sha256=mF-Pj8FUCsOvSG0IIg1OVMhDwXnpxIbZQJWVYWfjv2s,14660
 isa_model/inference/base.py,sha256=qwOddnSGI0GUdD6qIdGBPQpkW7UjU3Y-zaZvu70B4WA,1278
@@ -50,6 +54,8 @@ isa_model/scripts/mlflow_manager.py,sha256=7xMN0_wELr1jcALuTW9WeWirRkPZPlE2LlFfZ
 isa_model/scripts/model_registry.py,sha256=7rycPkVk8WHUO3LJaHfdyy5Yq8qmd_4WkGk4wKan-2w,14279
 isa_model/scripts/start_mlflow.py,sha256=3AGKBzByjzbZ56I8w0IOfYnp3V6EU2Lv9NtX9maSqL8,2571
 isa_model/scripts/training_tracker.py,sha256=cnXPi8ip2OK76-aWAOgC-dKx90PqZLEnP6UbHso7Fwc,8080
+isa_model/training/__init__.py,sha256=RQDQ0m8p9YXBXgyyFxADeRA_-m18-wgNyWpjJhJfudU,950
+isa_model/training/factory.py,sha256=iX-OkKRud09F2VfGXKKKj3w9d26kh9Po4FKvxTqmFiI,12581
 isa_model/training/engine/llama_factory/__init__.py,sha256=WCqmUHTidASN4owGDOPSnKeLdG1gbK1MXQrRAzjP0z4,969
 isa_model/training/engine/llama_factory/config.py,sha256=3OvjuXs9IyfcY52pB1SpXSOe0VwmKZvsmy8VK9Ig6Ss,3178
 isa_model/training/engine/llama_factory/data_adapter.py,sha256=krqLp6Jy-IFQ6_M8O3FCtU-qqzUFJ65aNHpVq9C4Zyk,8865
@@ -79,8 +85,8 @@ isa_model/training/llm_model/annotation/tests/test_annotation_flow.py,sha256=DXY
 isa_model/training/llm_model/annotation/tests/test_minio copy.py,sha256=EI-PlH5xttAZF14Z_xn6LjgIJBkvP2qjLcvbX2hc0RM,3946
 isa_model/training/llm_model/annotation/tests/test_minio_upload.py,sha256=fL1eMubwR6L9lYc3zEwlWU9yjJuTsIYi93i0l9QUjm0,1109
 isa_model/training/llm_model/annotation/views/annotation_controller.py,sha256=3VzJ52yI-YIpcaAAXy2qac7sr4hTnFdtn-ZEKTt4IkM,5792
-isa_model-0.0.1.dist-info/licenses/LICENSE,sha256=nNPdMBBVrQz3f7AgKFZuyQgdar9d90Vdw51es-P72Dw,1084
-isa_model-0.0.1.dist-info/METADATA,sha256=rNFm9b9gkD38nhWJRj1RoPaSHbdQs8c2HwiqOCpd65w,8105
-isa_model-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-isa_model-0.0.1.dist-info/top_level.txt,sha256=eHSy_Xb3kNkh2kK11mi1mZh0Wz91AQ5b8k2KFYO-rE8,10
-isa_model-0.0.1.dist-info/RECORD,,
+isa_model-0.0.2.dist-info/licenses/LICENSE,sha256=nNPdMBBVrQz3f7AgKFZuyQgdar9d90Vdw51es-P72Dw,1084
+isa_model-0.0.2.dist-info/METADATA,sha256=b-uD5aD32VND8BtZp0BaVUheGI_JhbyZLp57VNBjQuQ,8105
+isa_model-0.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+isa_model-0.0.2.dist-info/top_level.txt,sha256=eHSy_Xb3kNkh2kK11mi1mZh0Wz91AQ5b8k2KFYO-rE8,10
+isa_model-0.0.2.dist-info/RECORD,,