Comprehensive comparison for AI Model Training technology in AI applications

import torch
import torch.nn as nn
from torch.utils.data import Dataset, DataLoader
from transformers import AutoModelForSequenceClassification, AutoTokenizer
from torch.optim import AdamW
from torch.cuda.amp import autocast, GradScaler
import logging
from typing import List, Dict, Tuple
import json

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class CustomerSentimentDataset(Dataset):
    """Dataset for customer review sentiment classification"""
    def __init__(self, reviews: List[str], labels: List[int], tokenizer, max_length: int = 512):
        self.reviews = reviews
        self.labels = labels
        self.tokenizer = tokenizer
        self.max_length = max_length
    
    def __len__(self):
        return len(self.reviews)
    
    def __getitem__(self, idx: int) -> Dict[str, torch.Tensor]:
        encoding = self.tokenizer(
            self.reviews[idx],
            max_length=self.max_length,
            padding='max_length',
            truncation=True,
            return_tensors='pt'
        )
        return {
            'input_ids': encoding['input_ids'].flatten(),
            'attention_mask': encoding['attention_mask'].flatten(),
            'labels': torch.tensor(self.labels[idx], dtype=torch.long)
        }

class FullFineTuner:
    """Full fine-tuning implementation for production sentiment analysis"""
    def __init__(self, model_name: str = 'bert-base-uncased', num_labels: int = 3, device: str = None):
        self.device = device or ('cuda' if torch.cuda.is_available() else 'cpu')
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.model = AutoModelForSequenceClassification.from_pretrained(
            model_name,
            num_labels=num_labels
        ).to(self.device)
        self.scaler = GradScaler()
        logger.info(f"Model loaded on {self.device}")
    
    def train_epoch(self, dataloader: DataLoader, optimizer: torch.optim.Optimizer, epoch: int) -> float:
        """Train for one epoch with mixed precision and error handling"""
        self.model.train()
        total_loss = 0.0
        
        for batch_idx, batch in enumerate(dataloader):
            try:
                input_ids = batch['input_ids'].to(self.device)
                attention_mask = batch['attention_mask'].to(self.device)
                labels = batch['labels'].to(self.device)
                
                optimizer.zero_grad()
                
                with autocast():
                    outputs = self.model(
                        input_ids=input_ids,
                        attention_mask=attention_mask,
                        labels=labels
                    )
                    loss = outputs.loss
                
                self.scaler.scale(loss).backward()
                self.scaler.unscale_(optimizer)
                torch.nn.utils.clip_grad_norm_(self.model.parameters(), max_norm=1.0)
                self.scaler.step(optimizer)
                self.scaler.update()
                
                total_loss += loss.item()
                
                if batch_idx % 50 == 0:
                    logger.info(f"Epoch {epoch}, Batch {batch_idx}, Loss: {loss.item():.4f}")
            
            except RuntimeError as e:
                logger.error(f"Error in batch {batch_idx}: {str(e)}")
                continue
        
        return total_loss / len(dataloader)
    
    def full_fine_tune(self, train_data: Tuple[List[str], List[int]], 
                       epochs: int = 3, batch_size: int = 16, lr: float = 2e-5) -> Dict:
        """Execute full fine-tuning with all parameters trainable"""
        reviews, labels = train_data
        dataset = CustomerSentimentDataset(reviews, labels, self.tokenizer)
        dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)
        
        # All parameters are trainable in full fine-tuning
        optimizer = AdamW(self.model.parameters(), lr=lr, weight_decay=0.01)
        
        training_stats = {'epochs': [], 'losses': []}
        
        for epoch in range(epochs):
            avg_loss = self.train_epoch(dataloader, optimizer, epoch)
            training_stats['epochs'].append(epoch)
            training_stats['losses'].append(avg_loss)
            logger.info(f"Epoch {epoch} completed. Average Loss: {avg_loss:.4f}")
        
        return training_stats
    
    def save_model(self, path: str):
        """Save fine-tuned model and tokenizer"""
        self.model.save_pretrained(path)
        self.tokenizer.save_pretrained(path)
        logger.info(f"Model saved to {path}")

# Example usage
if __name__ == "__main__":
    # Sample training data
    reviews = [
        "This product exceeded my expectations! Absolutely love it.",
        "Terrible quality. Broke after one day of use.",
        "It's okay, nothing special but does the job."
    ] * 100
    labels = [2, 0, 1] * 100  # 0: negative, 1: neutral, 2: positive
    
    finetuner = FullFineTuner(num_labels=3)
    stats = finetuner.full_fine_tune((reviews, labels), epochs=3, batch_size=8)
    finetuner.save_model('./models/sentiment_model')
    
    logger.info(f"Training completed: {json.dumps(stats, indent=2)}")