Comprehensive comparison for AI technology in Fine-tuning applications

import modal
import os
from typing import Dict, List, Optional
import json

# Define the Modal app and GPU configuration
app = modal.App("llm-finetuning-production")

# Create a custom image with required dependencies
image = (
    modal.Image.debian_slim(python_version="3.11")
    .pip_install(
        "torch==2.1.0",
        "transformers==4.36.0",
        "datasets==2.16.0",
        "peft==0.7.0",
        "accelerate==0.25.0",
        "bitsandbytes==0.41.3",
        "wandb==0.16.1"
    )
)

# Create a persistent volume for model checkpoints
volume = modal.Volume.from_name("finetuning-checkpoints", create_if_missing=True)

@app.function(
    image=image,
    gpu="A100",
    timeout=7200,
    volumes={"/checkpoints": volume},
    secrets=[modal.Secret.from_name("huggingface-secret"), modal.Secret.from_name("wandb-secret")]
)
def finetune_model(
    dataset_name: str,
    model_name: str = "meta-llama/Llama-2-7b-hf",
    num_epochs: int = 3,
    learning_rate: float = 2e-4,
    batch_size: int = 4
) -> Dict[str, str]:
    """Fine-tune a language model using LoRA on a custom dataset."""
    from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer
    from datasets import load_dataset
    from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
    import torch
    import wandb
    
    try:
        # Initialize wandb for experiment tracking
        wandb.init(project="modal-finetuning", name=f"{model_name.split('/')[-1]}-{dataset_name}")
        
        # Load tokenizer and model
        tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
        tokenizer.pad_token = tokenizer.eos_token
        
        model = AutoModelForCausalLM.from_pretrained(
            model_name,
            load_in_8bit=True,
            device_map="auto",
            torch_dtype=torch.float16
        )
        
        # Prepare model for LoRA training
        model = prepare_model_for_kbit_training(model)
        
        # Configure LoRA parameters
        lora_config = LoraConfig(
            r=16,
            lora_alpha=32,
            target_modules=["q_proj", "v_proj"],
            lora_dropout=0.05,
            bias="none",
            task_type="CAUSAL_LM"
        )
        
        model = get_peft_model(model, lora_config)
        
        # Load and preprocess dataset
        dataset = load_dataset(dataset_name, split="train")
        
        def tokenize_function(examples):
            return tokenizer(examples["text"], truncation=True, max_length=512, padding="max_length")
        
        tokenized_dataset = dataset.map(tokenize_function, batched=True, remove_columns=dataset.column_names)
        
        # Define training arguments
        output_dir = f"/checkpoints/{model_name.split('/')[-1]}-{dataset_name}"
        training_args = TrainingArguments(
            output_dir=output_dir,
            num_train_epochs=num_epochs,
            per_device_train_batch_size=batch_size,
            learning_rate=learning_rate,
            fp16=True,
            save_strategy="epoch",
            logging_steps=10,
            report_to="wandb",
            gradient_accumulation_steps=4,
            warmup_steps=100
        )
        
        # Initialize trainer
        trainer = Trainer(
            model=model,
            args=training_args,
            train_dataset=tokenized_dataset
        )
        
        # Start training
        trainer.train()
        
        # Save final model
        final_model_path = f"{output_dir}/final"
        trainer.save_model(final_model_path)
        volume.commit()
        
        wandb.finish()
        
        return {
            "status": "success",
            "model_path": final_model_path,
            "message": f"Model fine-tuned successfully on {dataset_name}"
        }
    
    except Exception as e:
        wandb.finish()
        return {
            "status": "error",
            "error": str(e),
            "message": "Fine-tuning failed"
        }

@app.local_entrypoint()
def main(dataset: str = "imdb", model: str = "meta-llama/Llama-2-7b-hf"):
    """Entry point for triggering fine-tuning job."""
    result = finetune_model.remote(dataset_name=dataset, model_name=model)
    print(json.dumps(result, indent=2))