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

isa_model/training/engine/llama_factory/rl.py

@@ -1,254 +0,0 @@
-"""
-LlamaFactory reinforcement learning implementation.
-"""
-
-import os
-import json
-import logging
-import subprocess
-from typing import Dict, List, Optional, Union, Any, Tuple
-
-from .config import (
-    LlamaFactoryConfig,
-    RLConfig,
-    DPOConfig,
-    TrainingStrategy
-)
-
-logger = logging.getLogger(__name__)
-
-
-class LlamaFactoryRL:
-    """
-    Reinforcement Learning class for LlamaFactory.
-    
-    This class provides methods to train language models using reinforcement
-    learning approaches such as RLHF (PPO) and DPO.
-    
-    Example:
-        ```python
-        # Create RL configuration
-        config = RLConfig(
-            model_path="meta-llama/Llama-2-7b-hf",
-            reward_model="reward-model-path",
-            train_file="path/to/data.json",
-            batch_size=8
-        )
-        
-        # Initialize and run RL training
-        rl_trainer = LlamaFactoryRL(config)
-        rl_trainer.train()
-        ```
-        
-    For DPO:
-        ```python
-        # Create DPO configuration
-        config = DPOConfig(
-            model_path="meta-llama/Llama-2-7b-hf",
-            train_file="path/to/preferences.json",
-            reference_model="meta-llama/Llama-2-7b-hf",  # Optional
-            batch_size=4
-        )
-        
-        # Initialize and run DPO training
-        dpo_trainer = LlamaFactoryRL(config)
-        dpo_trainer.train()
-        ```
-    """
-    
-    def __init__(self, config: Union[RLConfig, DPOConfig]):
-        """
-        Initialize the LlamaFactory RL trainer.
-        
-        Args:
-            config: Configuration for RL training
-        """
-        self.config = config
-        self._validate_config()
-        self.output_dir = config.output_dir
-        os.makedirs(self.output_dir, exist_ok=True)
-        
-    def _validate_config(self) -> None:
-        """Validate configuration parameters."""
-        if not self.config.model_path:
-            raise ValueError("Model path must be specified")
-            
-        if isinstance(self.config, RLConfig):
-            if not self.config.reward_model:
-                raise ValueError("Reward model must be specified for RLHF")
-            if not self.config.train_file:
-                raise ValueError("Training file must be specified for RLHF")
-                
-        if isinstance(self.config, DPOConfig) and not self.config.train_file:
-            raise ValueError("Training file must be specified for DPO")
-    
-    def _prepare_training_args(self) -> Dict[str, Any]:
-        """
-        Prepare training arguments for LlamaFactory CLI.
-        
-        Returns:
-            Dictionary of training arguments
-        """
-        base_args = self.config.to_dict()
-        
-        # Add stage-specific args
-        if self.config.strategy == TrainingStrategy.REINFORCEMENT_LEARNING:
-            base_args["stage"] = "rm" if self._is_reward_model_training() else "ppo"
-        elif self.config.strategy == TrainingStrategy.PREFERENCE_OPTIMIZATION:
-            base_args["stage"] = "dpo"
-            
-        # Handle LoRA settings
-        if self.config.use_lora:
-            base_args["lora_target"] = "q_proj,v_proj"
-            
-        return base_args
-    
-    def _is_reward_model_training(self) -> bool:
-        """
-        Check if we're training a reward model for RLHF.
-        
-        Returns:
-            True if reward model training, False otherwise
-        """
-        # This is a placeholder. In a real implementation, 
-        # you'd have a separate flag in the config
-        return False
-        
-    def _save_training_args(self, args: Dict[str, Any]) -> str:
-        """
-        Save training arguments to a JSON file.
-        
-        Args:
-            args: Training arguments
-            
-        Returns:
-            Path to the saved JSON file
-        """
-        args_file = os.path.join(self.output_dir, "train_args.json")
-        with open(args_file, "w") as f:
-            json.dump(args, f, indent=2)
-        return args_file
-    
-    def _build_command(self, args_file: str) -> List[str]:
-        """
-        Build the command to run LlamaFactory.
-        
-        Args:
-            args_file: Path to the arguments file
-            
-        Returns:
-            Command list for subprocess
-        """
-        cmd_module = "llmtuner.cli.ppo"
-        if self.config.strategy == TrainingStrategy.PREFERENCE_OPTIMIZATION:
-            cmd_module = "llmtuner.cli.dpo"
-        elif self._is_reward_model_training():
-            cmd_module = "llmtuner.cli.rm"
-            
-        return [
-            "python", "-m", cmd_module,
-            "--cfg_file", args_file
-        ]
-    
-    def train(self) -> str:
-        """
-        Run the RL training process.
-        
-        Returns:
-            Path to the output directory with trained model
-        """
-        args = self._prepare_training_args()
-        args_file = self._save_training_args(args)
-        
-        cmd = self._build_command(args_file)
-        logger.info(f"Running command: {' '.join(cmd)}")
-        
-        try:
-            subprocess.run(
-                cmd,
-                check=True,
-                text=True,
-                stderr=subprocess.STDOUT
-            )
-            logger.info(f"RL training completed successfully. Model saved to {self.output_dir}")
-            return self.output_dir
-        except subprocess.CalledProcessError as e:
-            logger.error(f"RL training failed with error: {e}")
-            raise RuntimeError(f"LlamaFactory RL training failed: {e}")
-    
-    def train_reward_model(self) -> str:
-        """
-        Train a reward model for RLHF.
-        
-        Returns:
-            Path to the trained reward model
-        """
-        # Create temporary config for reward model training
-        reward_config = RLConfig(
-            model_path=self.config.model_path,
-            output_dir=os.path.join(self.output_dir, "reward_model"),
-            train_file=self.config.train_file,
-            batch_size=self.config.batch_size,
-            num_epochs=self.config.num_epochs,
-            learning_rate=self.config.learning_rate
-        )
-        
-        # Set as reward model training
-        # In a real implementation, you'd have a proper flag in the config
-        self.config = reward_config
-        
-        args = self._prepare_training_args()
-        args_file = self._save_training_args(args)
-        
-        cmd = [
-            "python", "-m", "llmtuner.cli.rm",
-            "--cfg_file", args_file
-        ]
-        
-        logger.info(f"Running command: {' '.join(cmd)}")
-        
-        try:
-            subprocess.run(
-                cmd,
-                check=True,
-                text=True,
-                stderr=subprocess.STDOUT
-            )
-            logger.info(f"Reward model training completed successfully. Model saved to {reward_config.output_dir}")
-            return reward_config.output_dir
-        except subprocess.CalledProcessError as e:
-            logger.error(f"Reward model training failed with error: {e}")
-            raise RuntimeError(f"LlamaFactory reward model training failed: {e}")
-            
-    def export_model(self, output_path: Optional[str] = None) -> str:
-        """
-        Export the trained model.
-        
-        Args:
-            output_path: Path to save the exported model
-            
-        Returns:
-            Path to the exported model
-        """
-        if output_path is None:
-            output_path = os.path.join(self.output_dir, "exported")
-            
-        os.makedirs(output_path, exist_ok=True)
-        
-        # If using LoRA, need to merge weights
-        if self.config.use_lora:
-            cmd = [
-                "python", "-m", "llmtuner.cli.merge",
-                "--model_name_or_path", self.config.model_path,
-                "--adapter_name_or_path", self.output_dir,
-                "--output_dir", output_path
-            ]
-            
-            subprocess.run(cmd, check=True, text=True)
-            logger.info(f"Model exported successfully to {output_path}")
-        else:
-            # Just copy the model
-            import shutil
-            shutil.copytree(self.output_dir, output_path, dirs_exist_ok=True)
-            
-        return output_path 

isa_model/training/engine/llama_factory/trainer.py

@@ -1,171 +0,0 @@
-"""
-LlamaFactory training implementation.
-"""
-
-import os
-import json
-import logging
-import subprocess
-from typing import Dict, List, Optional, Union, Any
-
-from .config import (
-    LlamaFactoryConfig,
-    SFTConfig,
-    TrainingStrategy,
-    DatasetFormat
-)
-
-logger = logging.getLogger(__name__)
-
-
-class LlamaFactoryTrainer:
-    """
-    Trainer class for LlamaFactory fine-tuning operations.
-    
-    This class provides methods to fine-tune language models using LlamaFactory.
-    It supports supervised fine-tuning (SFT) and manages the execution of the
-    training process.
-    
-    Example:
-        ```python
-        # Create configuration
-        config = SFTConfig(
-            model_path="meta-llama/Llama-2-7b-hf",
-            train_file="path/to/data.json",
-            batch_size=8,
-            num_epochs=3
-        )
-        
-        # Initialize and run trainer
-        trainer = LlamaFactoryTrainer(config)
-        trainer.train()
-        ```
-    """
-    
-    def __init__(self, config: LlamaFactoryConfig):
-        """
-        Initialize the LlamaFactory trainer.
-        
-        Args:
-            config: Configuration for training
-        """
-        self.config = config
-        self._validate_config()
-        self.output_dir = config.output_dir
-        os.makedirs(self.output_dir, exist_ok=True)
-        
-    def _validate_config(self) -> None:
-        """Validate configuration parameters."""
-        if not self.config.model_path:
-            raise ValueError("Model path must be specified")
-            
-        if isinstance(self.config, SFTConfig) and not self.config.train_file:
-            raise ValueError("Training file must be specified for SFT")
-    
-    def _prepare_training_args(self) -> Dict[str, Any]:
-        """
-        Prepare training arguments for LlamaFactory CLI.
-        
-        Returns:
-            Dictionary of training arguments
-        """
-        base_args = self.config.to_dict()
-        
-        # Add stage-specific args
-        if self.config.strategy == TrainingStrategy.SUPERVISED_FINETUNING:
-            base_args["stage"] = "sft"
-        
-        # Handle LoRA settings
-        if self.config.use_lora:
-            base_args["lora_target"] = "q_proj,v_proj"
-            
-        return base_args
-    
-    def _save_training_args(self, args: Dict[str, Any]) -> str:
-        """
-        Save training arguments to a JSON file.
-        
-        Args:
-            args: Training arguments
-            
-        Returns:
-            Path to the saved JSON file
-        """
-        args_file = os.path.join(self.output_dir, "train_args.json")
-        with open(args_file, "w") as f:
-            json.dump(args, f, indent=2)
-        return args_file
-    
-    def _build_command(self, args_file: str) -> List[str]:
-        """
-        Build the command to run LlamaFactory.
-        
-        Args:
-            args_file: Path to the arguments file
-            
-        Returns:
-            Command list for subprocess
-        """
-        return [
-            "python", "-m", "llmtuner.cli.sft",
-            "--cfg_file", args_file
-        ]
-    
-    def train(self) -> str:
-        """
-        Run the training process.
-        
-        Returns:
-            Path to the output directory with trained model
-        """
-        args = self._prepare_training_args()
-        args_file = self._save_training_args(args)
-        
-        cmd = self._build_command(args_file)
-        logger.info(f"Running command: {' '.join(cmd)}")
-        
-        try:
-            subprocess.run(
-                cmd,
-                check=True,
-                text=True,
-                stderr=subprocess.STDOUT
-            )
-            logger.info(f"Training completed successfully. Model saved to {self.output_dir}")
-            return self.output_dir
-        except subprocess.CalledProcessError as e:
-            logger.error(f"Training failed with error: {e}")
-            raise RuntimeError(f"LlamaFactory training failed: {e}")
-            
-    def export_model(self, output_path: Optional[str] = None) -> str:
-        """
-        Export the trained model.
-        
-        Args:
-            output_path: Path to save the exported model
-            
-        Returns:
-            Path to the exported model
-        """
-        if output_path is None:
-            output_path = os.path.join(self.output_dir, "exported")
-            
-        os.makedirs(output_path, exist_ok=True)
-        
-        # If using LoRA, need to merge weights
-        if self.config.use_lora:
-            cmd = [
-                "python", "-m", "llmtuner.cli.merge",
-                "--model_name_or_path", self.config.model_path,
-                "--adapter_name_or_path", self.output_dir,
-                "--output_dir", output_path
-            ]
-            
-            subprocess.run(cmd, check=True, text=True)
-            logger.info(f"Model exported successfully to {output_path}")
-        else:
-            # Just copy the model
-            import shutil
-            shutil.copytree(self.output_dir, output_path, dirs_exist_ok=True)
-            
-        return output_path 

isa_model/training/image_model/configs/create_config.py

@@ -1,37 +0,0 @@
-import json
-
-config = {
-    "general": {
-        "enable_bucket": True,
-        "min_bucket_reso": 256,
-        "max_bucket_reso": 1024,
-        "batch_size_per_device": 4,
-        "train_batch_size": 4,
-        "epoch": 100,
-        "save_every_n_epochs": 10,
-        "save_model_as": "safetensors",
-        "mixed_precision": "fp16",
-        "seed": 42,
-        "num_cpu_threads_per_process": 8
-    },
-    "model": {
-        "pretrained_model_name_or_path": "runwayml/stable-diffusion-v1-5",
-        "v2": False,
-        "v_parameterization": False
-    },
-    "optimizer": {
-        "learning_rate": 1e-5,
-        "lr_scheduler": "cosine_with_restarts",
-        "lr_warmup_steps": 100,
-        "optimizer_type": "AdamW8bit"
-    },
-    "dataset": {
-        "resolution": 512,
-        "center_crop": False,
-        "random_crop": False,
-        "flip_aug": True
-    }
-}
-
-with open("training_config.json", "w") as f:
-    json.dump(config, f, indent=2) 

isa_model/training/image_model/configs/create_flux_config.py

@@ -1,26 +0,0 @@
-import json
-from pathlib import Path
-
-# Get the project root directory
-project_root = Path(__file__).parents[4]  # Go up 4 levels from configs folder
-
-flux_config = {
-    "pretrained_model_name_or_path": "/home/Ubuntu/Downloads/flux1-dev.safetensors",
-    # Update train_data_dir to your processed images
-    "train_data_dir": str(project_root / "app/services/training/image_model/raw_data/training_images_processed"),
-    "output_dir": "/home/Ubuntu/apps/StableSwarmUI/Models/diffusion_models",
-    "output_name": "demi_flux_v1",
-    "save_model_as": "safetensors",
-    "learning_rate": 4e-6,
-    "train_batch_size": 1,
-    "epoch": 200,
-    "save_every_n_epochs": 25,
-    "mixed_precision": "bf16",
-    "num_cpu_threads_per_process": 2,
-    "flux1_t5xxl": "/home/Ubuntu/Downloads/t5xxl_fp16.safetensors",
-    "flux1_clip_l": "/home/Ubuntu/Downloads/clip_l.safetensors",
-}
-
-config_path = Path(__file__).parent / "flux_config.json"
-with open(config_path, "w") as f:
-    json.dump(flux_config, f, indent=2) 

isa_model/training/image_model/configs/create_lora_config.py

@@ -1,21 +0,0 @@
-import json
-
-lora_config = {
-    "pretrained_model_name_or_path": "/home/Ubuntu/Downloads/flux1-dev.safetensors",
-    "train_data_dir": "/home/Ubuntu/Downloads/training_imgs",
-    "output_dir": "/home/Ubuntu/apps/StableSwarmUI/Models/lora",
-    "output_name": "demi_lora_v1",
-    "save_model_as": "safetensors",
-    "learning_rate": 1e-4,
-    "train_batch_size": 1,
-    "epoch": 100,
-    "save_every_n_epochs": 10,
-    "mixed_precision": "bf16",
-    "num_cpu_threads_per_process": 2,
-    "flux1_checkbox": True,
-    "flux1_t5xxl": "/home/Ubuntu/Downloads/t5xxl_fp16.safetensors",
-    "flux1_clip_l": "/home/Ubuntu/Downloads/clip_l.safetensors",
-}
-
-with open("lora_config.json", "w") as f:
-    json.dump(lora_config, f, indent=2) 

isa_model/training/image_model/prepare_massed_compute.py

@@ -1,97 +0,0 @@
-import os
-import shutil
-from pathlib import Path
-
-def prepare_massed_package():
-    # Get current directory and create desktop folder structure
-    project_root = Path(__file__).parent
-    desktop_dir = Path.home() / "Desktop" / "massed_training"
-    
-    # Create necessary directories
-    desktop_dir.mkdir(parents=True, exist_ok=True)
-    training_dir = desktop_dir / "training_imgs"
-    training_dir.mkdir(exist_ok=True)
-    
-    # Copy processed images and captions
-    processed_images_dir = project_root / "raw_data/training_images_processed"
-    for img_file in processed_images_dir.glob("*.jpg"):
-        shutil.copy2(img_file, training_dir)
-        # Copy or create corresponding caption file
-        caption_file = img_file.with_suffix(".txt")
-        if caption_file.exists():
-            shutil.copy2(caption_file, training_dir)
-        else:
-            with open(training_dir / f"{img_file.stem}.txt", "w") as f:
-                f.write("a photo of demi person, (high quality, photorealistic:1.2), professional portrait")
-    
-    # Create Kohya FLUX setup script
-    kohya_script = """#!/bin/bash
-cd /home/Ubuntu/apps/kohya_ss
-
-git pull
-
-git checkout sd3-flux.1
-
-source venv/bin/activate
-
-./setup.sh
-
-git submodule update --init --recursive
-
-pip uninstall xformers --yes
-
-pip install torch==2.5.1+cu124 torchvision --index-url https://download.pytorch.org/whl/cu124
-
-pip install xformers==0.0.28.post3 --index-url https://download.pytorch.org/whl/cu124
-
-./gui.sh --listen=0.0.0.0 --inbrowser --noverify
-
-# Keep the terminal open
-read -p "Press Enter to continue..."
-"""
-    
-    # Create Models download script
-    models_script = """#!/bin/bash
-pip install huggingface_hub
-
-pip install ipywidgets
-pip install hf_transfer
-export HF_HUB_ENABLE_HF_TRANSFER=1
-
-python3 Download_Train_Models.py --dir /home/Ubuntu/Downloads
-"""
-    
-    # Write scripts
-    with open(desktop_dir / "Massed_Compute_Kohya_FLUX.sh", "w", newline='\n') as f:
-        f.write(kohya_script)
-    
-    with open(desktop_dir / "Massed_Compute_Download_Models.sh", "w", newline='\n') as f:
-        f.write(models_script)
-    
-    # Make scripts executable
-    os.chmod(desktop_dir / "Massed_Compute_Kohya_FLUX.sh", 0o755)
-    os.chmod(desktop_dir / "Massed_Compute_Download_Models.sh", 0o755)
-    
-    print(f"""
-Package prepared in: {desktop_dir}
-
-Next steps:
-1. Upload the entire '{desktop_dir.name}' folder to your Massed Compute instance
-2. In Massed Compute terminal:
-   cd ~/Desktop/massed_training
-   chmod +x Massed_Compute_Kohya_FLUX.sh
-   ./Massed_Compute_Kohya_FLUX.sh
-
-3. In a new terminal:
-   cd ~/Desktop/massed_training
-   chmod +x Massed_Compute_Download_Models.sh
-   ./Massed_Compute_Download_Models.sh
-
-4. When Kohya GUI opens (http://0.0.0.0:7860/):
-   - Go to the Training tab
-   - Set training data directory to: /home/Ubuntu/Desktop/massed_training/training_imgs
-   - Use the settings from the Flux tutorial
-    """)
-
-if __name__ == "__main__":
-    prepare_massed_package() 

isa_model/training/image_model/prepare_upload.py

@@ -1,17 +0,0 @@
-import shutil
-import os
-
-def prepare_training_package():
-    # Create a directory for all training materials
-    os.makedirs("training_package", exist_ok=True)
-    
-    # Copy training data
-    shutil.copytree("training_data", "training_package/training_data", dirs_exist_ok=True)
-    
-    # Copy config
-    shutil.copy("training_config.json", "training_package/training_config.json")
-    
-    # Create zip file
-    shutil.make_archive("demi_training", "zip", "training_package")
-
-prepare_training_package() 

isa_model/training/image_model/raw_data/create_captions.py

@@ -1,16 +0,0 @@
-import os
-from pathlib import Path
-
-def create_captions(image_dir):
-    """Create a caption file for each image with a basic description"""
-    image_dir = Path(image_dir)
-    
-    for image_file in image_dir.glob("*.jpg"):
-        caption_file = image_dir / f"{image_file.stem}.txt"
-        
-        # Create a basic caption - you can modify this
-        with open(caption_file, "w") as f:
-            f.write("a photo of demi")
-
-# Use the function
-create_captions("training_data/demi") 

isa_model/training/image_model/raw_data/create_lora_captions.py

@@ -1,20 +0,0 @@
-from pathlib import Path
-
-def create_lora_captions(image_dir):
-    """Create detailed captions for LoRA training"""
-    image_dir = Path(image_dir)
-    
-    # LoRA-specific caption with trigger word
-    caption_text = (
-        "a photo of demi person, (high quality, photorealistic:1.2), "
-        "professional portrait, detailed facial features, "
-        "natural lighting, sharp focus, clear skin texture"
-    )
-    
-    for image_file in image_dir.glob("*.jpg"):
-        caption_file = image_dir / f"{image_file.stem}.txt"
-        with open(caption_file, "w") as f:
-            f.write(caption_text)
-
-# Use the function
-create_lora_captions("/home/Ubuntu/Downloads/training_imgs")