isa-model 0.2.0__py3-none-any.whl → 0.2.9__py3-none-any.whl

isa_model/training/engine/llama_factory/config.py

@@ -1,115 +0,0 @@
-"""
-Configuration classes for LlamaFactory training and RL.
-"""
-
-from dataclasses import dataclass, field
-from typing import Dict, List, Optional, Union
-from enum import Enum
-import os
-from pathlib import Path
-
-
-class TrainingStrategy(str, Enum):
-    """Training strategies supported by LlamaFactory."""
-    
-    SUPERVISED_FINETUNING = "sft"
-    REINFORCEMENT_LEARNING = "rl"
-    PREFERENCE_OPTIMIZATION = "dpo"
-    PREFERENCE_PAIRWISE = "ppo"
-
-
-class DatasetFormat(str, Enum):
-    """Dataset formats supported by LlamaFactory."""
-    
-    ALPACA = "alpaca"
-    SHAREGPT = "sharegpt"
-    CUSTOM = "custom"
-
-
-@dataclass
-class LlamaFactoryConfig:
-    """Base configuration for LlamaFactory trainers."""
-    
-    model_path: str
-    output_dir: str = field(default_factory=lambda: os.path.join(os.getcwd(), "outputs"))
-    
-    # Training parameters
-    batch_size: int = 8
-    num_epochs: int = 3
-    learning_rate: float = 2e-5
-    weight_decay: float = 0.01
-    lr_scheduler_type: str = "cosine"
-    warmup_ratio: float = 0.1
-    
-    # Model parameters
-    lora_rank: int = 8
-    lora_alpha: int = 16
-    lora_dropout: float = 0.05
-    use_lora: bool = True
-    
-    # Data processing
-    max_length: int = 1024
-    dataset_format: DatasetFormat = DatasetFormat.ALPACA
-    
-    # Logging
-    log_with: str = "mlflow"
-    logging_steps: int = 10
-    
-    def to_dict(self) -> Dict:
-        """Convert config to dictionary for LlamaFactory CLI."""
-        return {k: v.value if isinstance(v, Enum) else v 
-                for k, v in self.__dict__.items()}
-
-
-@dataclass
-class SFTConfig(LlamaFactoryConfig):
-    """Configuration for supervised fine-tuning."""
-    
-    strategy: TrainingStrategy = TrainingStrategy.SUPERVISED_FINETUNING
-    train_file: str = ""
-    val_file: Optional[str] = None
-    
-    # SFT specific settings
-    cutoff_len: int = 1024
-    normalize_data: bool = True
-    
-
-@dataclass
-class RLConfig(LlamaFactoryConfig):
-    """Configuration for reinforcement learning."""
-    
-    strategy: TrainingStrategy = TrainingStrategy.REINFORCEMENT_LEARNING
-    reward_model: str = ""
-    train_file: str = ""
-    
-    # RL specific settings
-    kl_coef: float = 0.1
-    top_k: int = 0
-    top_p: float = 1.0
-    temperature: float = 1.0
-    
-
-@dataclass
-class DPOConfig(LlamaFactoryConfig):
-    """Configuration for direct preference optimization."""
-    
-    strategy: TrainingStrategy = TrainingStrategy.PREFERENCE_OPTIMIZATION
-    train_file: str = ""
-    val_file: Optional[str] = None
-    
-    # DPO specific settings
-    beta: float = 0.1
-    reference_model: Optional[str] = None
-    
-
-def create_default_config(strategy: TrainingStrategy, model_path: str) -> LlamaFactoryConfig:
-    """Create a default configuration based on the training strategy."""
-    
-    if strategy == TrainingStrategy.SUPERVISED_FINETUNING:
-        return SFTConfig(model_path=model_path)
-    elif strategy == TrainingStrategy.REINFORCEMENT_LEARNING:
-        return RLConfig(model_path=model_path)
-    elif strategy == TrainingStrategy.PREFERENCE_OPTIMIZATION:
-        return DPOConfig(model_path=model_path)
-    else:
-        raise ValueError(f"Unsupported strategy: {strategy}") 

isa_model/training/engine/llama_factory/data_adapter.py

@@ -1,284 +0,0 @@
-"""
-Data adapters for LlamaFactory training.
-"""
-
-import os
-import json
-import logging
-from typing import Dict, List, Any, Optional, Union
-
-from .config import DatasetFormat
-
-logger = logging.getLogger(__name__)
-
-
-class DataAdapter:
-    """
-    Base class for adapting datasets to LlamaFactory format.
-    
-    This class handles converting data from various formats into
-    the specific format expected by LlamaFactory.
-    
-    Example:
-        ```python
-        # Create a custom adapter
-        adapter = CustomAdapter()
-        
-        # Convert data
-        converted_path = adapter.convert_data(
-            input_file="path/to/source_data.json",
-            output_file="path/to/converted_data.json"
-        )
-        ```
-    """
-    
-    def __init__(self, format_type: DatasetFormat = DatasetFormat.ALPACA):
-        """
-        Initialize the data adapter.
-        
-        Args:
-            format_type: The target format to convert to
-        """
-        self.format_type = format_type
-        
-    def convert_data(self, input_file: str, output_file: Optional[str] = None) -> str:
-        """
-        Convert data from input format to LlamaFactory format.
-        
-        Args:
-            input_file: Path to the input data file
-            output_file: Path to save the converted data
-            
-        Returns:
-            Path to the converted data file
-        """
-        if output_file is None:
-            dirname = os.path.dirname(input_file)
-            basename = os.path.basename(input_file)
-            name, ext = os.path.splitext(basename)
-            output_file = os.path.join(dirname, f"{name}_converted{ext}")
-            
-        data = self._load_data(input_file)
-        converted_data = self._convert_data(data)
-        self._save_data(converted_data, output_file)
-        
-        return output_file
-        
-    def _load_data(self, input_file: str) -> Any:
-        """
-        Load data from the input file.
-        
-        Args:
-            input_file: Path to the input file
-            
-        Returns:
-            Loaded data
-        """
-        with open(input_file, 'r', encoding='utf-8') as f:
-            return json.load(f)
-            
-    def _save_data(self, data: Any, output_file: str) -> None:
-        """
-        Save data to the output file.
-        
-        Args:
-            data: Data to save
-            output_file: Path to save the data
-        """
-        with open(output_file, 'w', encoding='utf-8') as f:
-            json.dump(data, f, ensure_ascii=False, indent=2)
-            
-    def _convert_data(self, data: Any) -> List[Dict[str, Any]]:
-        """
-        Convert data to the target format.
-        
-        Args:
-            data: Input data
-            
-        Returns:
-            Converted data
-        """
-        raise NotImplementedError("Subclasses must implement this method")
-
-
-class AlpacaAdapter(DataAdapter):
-    """
-    Adapter for Alpaca format data.
-    
-    Example:
-        ```python
-        adapter = AlpacaAdapter()
-        converted_path = adapter.convert_data("custom_data.json")
-        ```
-    """
-    
-    def __init__(self):
-        """Initialize the Alpaca adapter."""
-        super().__init__(DatasetFormat.ALPACA)
-        
-    def _convert_data(self, data: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
-        """
-        Convert data to Alpaca format.
-        
-        Expected output format:
-        [
-            {
-                "instruction": "Task description",
-                "input": "Optional input (context)",
-                "output": "Expected output"
-            },
-            ...
-        ]
-        
-        Args:
-            data: Input data
-            
-        Returns:
-            Converted data in Alpaca format
-        """
-        result = []
-        
-        for item in data:
-            if isinstance(item, dict):
-                # If already in the expected format, just add to result
-                if all(k in item for k in ["instruction", "output"]):
-                    alpaca_item = {
-                        "instruction": item["instruction"],
-                        "input": item.get("input", ""),
-                        "output": item["output"]
-                    }
-                    result.append(alpaca_item)
-                # Otherwise, try to convert from common formats
-                elif "prompt" in item and "response" in item:
-                    alpaca_item = {
-                        "instruction": item["prompt"],
-                        "input": "",
-                        "output": item["response"]
-                    }
-                    result.append(alpaca_item)
-                elif "question" in item and "answer" in item:
-                    alpaca_item = {
-                        "instruction": item["question"],
-                        "input": "",
-                        "output": item["answer"]
-                    }
-                    result.append(alpaca_item)
-                else:
-                    logger.warning(f"Could not convert item: {item}")
-        
-        return result
-
-
-class ShareGPTAdapter(DataAdapter):
-    """
-    Adapter for ShareGPT format data.
-    
-    Example:
-        ```python
-        adapter = ShareGPTAdapter()
-        converted_path = adapter.convert_data("sharegpt_data.json")
-        ```
-    """
-    
-    def __init__(self):
-        """Initialize the ShareGPT adapter."""
-        super().__init__(DatasetFormat.SHAREGPT)
-        
-    def _convert_data(self, data: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
-        """
-        Convert data to ShareGPT format.
-        
-        Expected output format:
-        [
-            {
-                "conversations": [
-                    {"from": "human", "value": "Human message"},
-                    {"from": "gpt", "value": "Assistant response"},
-                    ...
-                ]
-            },
-            ...
-        ]
-        
-        Args:
-            data: Input data
-            
-        Returns:
-            Converted data in ShareGPT format
-        """
-        result = []
-        
-        for item in data:
-            if isinstance(item, dict):
-                conversations = []
-                
-                # Handle different input formats
-                
-                # If already in conversations format
-                if "conversations" in item and isinstance(item["conversations"], list):
-                    # Make sure format is correct
-                    for conv in item["conversations"]:
-                        if "from" in conv and "value" in conv:
-                            # Normalize role names
-                            role = conv["from"].lower()
-                            if role in ["user", "human"]:
-                                role = "human"
-                            elif role in ["assistant", "gpt", "ai"]:
-                                role = "gpt"
-                            else:
-                                logger.warning(f"Unknown role: {role}, skipping message")
-                                continue
-                                
-                            conversations.append({
-                                "from": role,
-                                "value": conv["value"]
-                            })
-                    
-                # If in QA format
-                elif "question" in item and "answer" in item:
-                    conversations = [
-                        {"from": "human", "value": item["question"]},
-                        {"from": "gpt", "value": item["answer"]}
-                    ]
-                
-                # If in prompt/response format
-                elif "prompt" in item and "response" in item:
-                    conversations = [
-                        {"from": "human", "value": item["prompt"]},
-                        {"from": "gpt", "value": item["response"]}
-                    ]
-                    
-                if conversations:
-                    result.append({"conversations": conversations})
-        
-        return result
-
-
-class DataAdapterFactory:
-    """
-    Factory for creating data adapters.
-    
-    Example:
-        ```python
-        # Create an adapter based on format
-        adapter = DataAdapterFactory.create_adapter(DatasetFormat.ALPACA)
-        ```
-    """
-    
-    @staticmethod
-    def create_adapter(format_type: DatasetFormat) -> DataAdapter:
-        """
-        Create a data adapter for the specified format.
-        
-        Args:
-            format_type: The dataset format
-            
-        Returns:
-            A data adapter instance
-        """
-        if format_type == DatasetFormat.ALPACA:
-            return AlpacaAdapter()
-        elif format_type == DatasetFormat.SHAREGPT:
-            return ShareGPTAdapter()
-        else:
-            raise ValueError(f"Unsupported format type: {format_type}") 

isa_model/training/engine/llama_factory/examples/__init__.py

@@ -1,6 +0,0 @@
-"""
-Example scripts for LlamaFactory fine-tuning and reinforcement learning.
-
-This package contains example scripts that demonstrate how to use
-the LlamaFactory engine for various tasks such as fine-tuning and RLHF.
-""" 

isa_model/training/engine/llama_factory/examples/finetune_with_tracking.py

@@ -1,185 +0,0 @@
-"""
-Example of fine-tuning with LlamaFactory and MLflow tracking.
-
-This example demonstrates how to use LlamaFactory for fine-tuning
-and the MLflow tracking system to monitor and log the process.
-"""
-
-import os
-import argparse
-import logging
-from typing import Dict, Any
-
-from app.services.ai.models.training.engine.llama_factory import (
-    LlamaFactory,
-    DatasetFormat,
-    TrainingStrategy
-)
-from app.services.ai.models.mlops import (
-    TrainingTracker,
-    ModelStage
-)
-
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger(__name__)
-
-
-def parse_args():
-    """Parse command line arguments."""
-    parser = argparse.ArgumentParser(description="Fine-tune with LlamaFactory and MLflow tracking")
-    
-    parser.add_argument(
-        "--model_path",
-        type=str,
-        required=True,
-        help="Path or name of the base model"
-    )
-    parser.add_argument(
-        "--train_data",
-        type=str,
-        required=True,
-        help="Path to the training data"
-    )
-    parser.add_argument(
-        "--val_data",
-        type=str,
-        help="Path to the validation data"
-    )
-    parser.add_argument(
-        "--output_dir",
-        type=str,
-        default="outputs",
-        help="Directory to save outputs"
-    )
-    parser.add_argument(
-        "--dataset_format",
-        type=str,
-        choices=["alpaca", "sharegpt", "custom"],
-        default="alpaca",
-        help="Format of the dataset"
-    )
-    parser.add_argument(
-        "--use_lora",
-        action="store_true",
-        help="Whether to use LoRA for training"
-    )
-    parser.add_argument(
-        "--batch_size",
-        type=int,
-        default=8,
-        help="Training batch size"
-    )
-    parser.add_argument(
-        "--num_epochs",
-        type=int,
-        default=3,
-        help="Number of training epochs"
-    )
-    parser.add_argument(
-        "--learning_rate",
-        type=float,
-        default=2e-5,
-        help="Learning rate"
-    )
-    parser.add_argument(
-        "--max_length",
-        type=int,
-        default=1024,
-        help="Maximum sequence length"
-    )
-    parser.add_argument(
-        "--lora_rank",
-        type=int,
-        default=8,
-        help="LoRA rank parameter"
-    )
-    parser.add_argument(
-        "--tracking_uri",
-        type=str,
-        help="URI for MLflow tracking server"
-    )
-    parser.add_argument(
-        "--register_model",
-        action="store_true",
-        help="Whether to register the model in the registry"
-    )
-    
-    return parser.parse_args()
-
-
-def main():
-    """Run the fine-tuning process with tracking."""
-    args = parse_args()
-    
-    # Map dataset format string to enum
-    dataset_format_map = {
-        "alpaca": DatasetFormat.ALPACA,
-        "sharegpt": DatasetFormat.SHAREGPT,
-        "custom": DatasetFormat.CUSTOM
-    }
-    dataset_format = dataset_format_map[args.dataset_format]
-    
-    # Create output directory
-    os.makedirs(args.output_dir, exist_ok=True)
-    
-    # Initialize LlamaFactory
-    factory = LlamaFactory(base_output_dir=args.output_dir)
-    
-    # Initialize training tracker
-    tracker = TrainingTracker(tracking_uri=args.tracking_uri)
-    
-    # Get model name from path
-    model_name = os.path.basename(args.model_path)
-    
-    # Set up training parameters
-    train_params = {
-        "model_path": args.model_path,
-        "train_data": args.train_data,
-        "val_data": args.val_data,
-        "output_dir": None,  # Will be set by factory
-        "dataset_format": dataset_format,
-        "use_lora": args.use_lora,
-        "batch_size": args.batch_size,
-        "num_epochs": args.num_epochs,
-        "learning_rate": args.learning_rate,
-        "max_length": args.max_length,
-        "lora_rank": args.lora_rank
-    }
-    
-    # Track the training run with MLflow
-    with tracker.track_training_run(
-        model_name=model_name,
-        training_params=train_params,
-        description=f"Fine-tuning {model_name} with LlamaFactory"
-    ) as run_info:
-        # Run the fine-tuning
-        try:
-            model_path = factory.finetune(**train_params)
-            
-            # Log success
-            tracker.log_metrics({"success": 1.0})
-            logger.info(f"Fine-tuning completed successfully. Model saved to {model_path}")
-            
-            # Register the model if requested
-            if args.register_model:
-                version = tracker.register_trained_model(
-                    model_path=model_path,
-                    description=f"Fine-tuned {model_name}",
-                    stage=ModelStage.STAGING
-                )
-                logger.info(f"Model registered as version {version}")
-                
-        except Exception as e:
-            # Log failure
-            tracker.log_metrics({"success": 0.0})
-            logger.error(f"Fine-tuning failed: {e}")
-            raise
-
-
-if __name__ == "__main__":
-    main()