Cosa è Fine Tuning

Cosa è Fine Tuning: La Guida Completa per Neofiti dell’AI e Machine Learning

Nel panorama dell’intelligenza artificiale e del machine learning, il fine tuning rappresenta una delle tecniche più potenti e versatili per adattare modelli pre-addestrati a compiti specifici. Per chi si avvicina per la prima volta al mondo dell’AI o per neolaureati in informatica, comprendere questa metodologia è fondamentale per sviluppare soluzioni efficaci e innovative.

Definizione Accademica del Fine Tuning

Il fine tuning è un processo di transfer learning che consiste nell’adattare un modello pre-addestrato, precedentemente allenato su grandi dataset generici, a un compito specifico attraverso un ulteriore addestramento su dati mirati e di dimensioni ridotte. Questa tecnica permette di sfruttare le conoscenze già acquisite dal modello per ottenere prestazioni superiori su task specifici.

Dal punto di vista tecnico, il fine tuning modifica selettivamente i parametri del modello pre-addestrato, permettendo di specializzare le rappresentazioni learned per il nuovo dominio applicativo, mantenendo al contempo la robustezza delle feature estratte durante il pre-training.

Cosa Consiste il Fine Tuning nel Deep Learning

Questo transfer learning opera su diversi livelli architetturali e può essere applicato in modalità differenti a seconda del contesto applicativo:

Architettura e Meccanismi

Nel deep learning, il fine tuning prevede tipicamente la sostituzione dell’ultimo layer del modello pre-addestrato con uno nuovo, dimensionato per il task specifico. Il target model copia tutti i design del modello con i loro parametri dal modello sorgente eccetto l’output layer. I layer precedenti vengono quindi riaddestrati con learning rate ridotti per preservare le feature di basso livello già apprese.

Strategie di Fine Tuning

1. Feature Extraction: Si congelano tutti i layer eccetto l’ultimo, utilizzando il modello pre-addestrato come feature extractor fisso.

2. Full Fine Tuning: Si riaddestrano tutti i parametri del modello con learning rate differenziati per layer.

3. Gradual Unfreezing: Si scongelano progressivamente i layer partendo dagli ultimi, permettendo un adattamento graduale.

4. Layer-wise Learning Rate: Si applicano learning rate decrescenti dai layer finali a quelli iniziali.

Caratteristiche Principali del Fine Tuning

Efficienza Computazionale

Il processo presenta vantaggi significativi in termini di efficienza computazionale. Rispetto al training da zero, richiede:

• Meno tempo di addestramento: Tipicamente 10-100 volte inferiore
• Meno dati: Anche dataset con centinaia di esempi possono essere sufficienti
• Meno risorse: GPU requirements ridotti significativamente

Transfer Learning Capabilities

Il fine tuning è diventato una parte essenziale del ciclo di sviluppo LLM, permettendo alle capacità linguistiche raw dei foundation models di essere adattate per una varietà di use cases. Questa capacità di transfer è particolarmente potente perché:

• Conserva conoscenze generali: Il modello mantiene rappresentazioni utili apprese su grandi dataset
• Specializza per domini: Adatta le rappresentazioni per task specifici
• Migliora generalizzazione: Riduce overfitting su piccoli dataset

Vantaggi vs Training da Zero

Aspetto	Fine Tuning	Training da Zero
Tempo di addestramento	Ore/Giorni	Settimane/Mesi
Dati richiesti	10²-10⁴ esempi	10⁵-10⁸ esempi
Costo computazionale	Basso	Molto alto
Prestazioni su piccoli dataset	Eccellenti	Spesso insufficienti
Controllo architetturale	Limitato	Completo

Passi per Applicare il Fine Tuning

1. Selezione del Modello Pre-addestrato

La scelta del modello base è cruciale e deve considerare:

• Dominio di applicazione: NLP (BERT, GPT), Computer Vision (ResNet, ViT), Multimodale (CLIP)
• Dimensioni del modello: Bilanciare performance e risorse computazionali
• Architettura: Compatibilità con il task target

2. Preparazione dei Dati

# Esempio di preparazione dati per fine tuning con HuggingFace
from transformers import AutoTokenizer
from torch.utils.data import Dataset, DataLoader
import torch

class CustomDataset(Dataset):
    def __init__(self, texts, labels, tokenizer, max_length=512):
        self.texts = texts
        self.labels = labels
        self.tokenizer = tokenizer
        self.max_length = max_length
    
    def __len__(self):
        return len(self.texts)
    
    def __getitem__(self, idx):
        text = str(self.texts[idx])
        label = self.labels[idx]
        
        # Tokenizzazione
        encoding = self.tokenizer(
            text,
            truncation=True,
            padding='max_length',
            max_length=self.max_length,
            return_tensors='pt'
        )
        
        return {
            'input_ids': encoding['input_ids'].flatten(),
            'attention_mask': encoding['attention_mask'].flatten(),
            'labels': torch.tensor(label, dtype=torch.long)
        }

3. Configurazione dell’Addestramento

from transformers import AutoModelForSequenceClassification, TrainingArguments, Trainer
import torch

# Configurazione hardware
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

# Caricamento modello pre-addestrato
model = AutoModelForSequenceClassification.from_pretrained(
    'bert-base-uncased',
    num_labels=2,  # Numero di classi del task
    dropout=0.1
)

# Configurazione parametri di training
training_args = TrainingArguments(
    output_dir='./results',
    num_train_epochs=3,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=64,
    learning_rate=2e-5,  # Learning rate ridotto per fine tuning
    weight_decay=0.01,
    logging_dir='./logs',
    logging_steps=10,
    evaluation_strategy="epoch",
    save_strategy="epoch",
    load_best_model_at_end=True,
    metric_for_best_model="accuracy",
    greater_is_better=True,
    warmup_steps=100,  # Warm-up per stabilizzare training
    gradient_checkpointing=True,  # Risparmio memoria
    dataloader_num_workers=4,
    fp16=True  # Mixed precision per efficienza
)

4. Implementazione del Training Loop

from sklearn.metrics import accuracy_score, precision_recall_fscore_support

def compute_metrics(eval_pred):
    predictions, labels = eval_pred
    predictions = np.argmax(predictions, axis=1)
    
    accuracy = accuracy_score(labels, predictions)
    precision, recall, f1, _ = precision_recall_fscore_support(
        labels, predictions, average='weighted'
    )
    
    return {
        'accuracy': accuracy,
        'f1': f1,
        'precision': precision,
        'recall': recall
    }

# Inizializzazione Trainer
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset,
    compute_metrics=compute_metrics
)

# Addestramento
trainer.train()

Esempio Pratico Semplice: Sentiment Analysis

Implementiamo un caso d’uso pratico per sentiment analysis utilizzando BERT:

import pandas as pd
from transformers import AutoTokenizer, AutoModelForSequenceClassification
from transformers import TrainingArguments, Trainer
import torch
import numpy as np

# Dataset di esempio
data = {
    'text': [
        "Questo prodotto è fantastico, lo consiglio!",
        "Servizio clienti pessimo, molto deluso",
        "Qualità eccellente, rapporto qualità prezzo ottimo",
        "Prodotto difettoso, chiedo rimborso"
    ],
    'label': [1, 0, 1, 0]  # 1: positivo, 0: negativo
}

df = pd.DataFrame(data)

# Tokenizer e modello
tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')
model = AutoModelForSequenceClassification.from_pretrained(
    'bert-base-uncased',
    num_labels=2
)

# Preparazione dataset
class SentimentDataset(torch.utils.data.Dataset):
    def __init__(self, texts, labels):
        self.texts = texts
        self.labels = labels
    
    def __len__(self):
        return len(self.texts)
    
    def __getitem__(self, idx):
        text = str(self.texts[idx])
        label = self.labels[idx]
        
        encoding = tokenizer(
            text,
            truncation=True,
            padding='max_length',
            max_length=128,
            return_tensors='pt'
        )
        
        return {
            'input_ids': encoding['input_ids'].flatten(),
            'attention_mask': encoding['attention_mask'].flatten(),
            'labels': torch.tensor(label, dtype=torch.long)
        }

# Creazione dataset
train_dataset = SentimentDataset(df['text'].tolist(), df['label'].tolist())

# Configurazione training
training_args = TrainingArguments(
    output_dir='./sentiment_model',
    num_train_epochs=3,
    per_device_train_batch_size=8,
    learning_rate=2e-5,
    weight_decay=0.01,
    logging_steps=10,
    save_steps=100,
    evaluation_strategy="no"
)

# Training
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
)

trainer.train()

# Salvataggio modello
model.save_pretrained('./sentiment_model_final')
tokenizer.save_pretrained('./sentiment_model_final')

Esempio Pratico Complesso: Computer Vision con Transfer Learning

Per un esempio più complesso, implementiamo fine tuning per classificazione di immagini mediche:

import torch
import torch.nn as nn
import torchvision.transforms as transforms
from torchvision import datasets, models
from torch.utils.data import DataLoader
import torch.optim as optim
from PIL import Image
import os

# Configurazione avanzata per medical imaging
class MedicalImageClassifier(nn.Module):
    def __init__(self, num_classes=3, pretrained=True):
        super(MedicalImageClassifier, self).__init__()
        
        # Caricamento ResNet50 pre-addestrato
        self.backbone = models.resnet50(pretrained=pretrained)
        
        # Freezing dei primi layer per preservare low-level features
        for param in list(self.backbone.parameters())[:-20]:
            param.requires_grad = False
        
        # Sostituzione classifier con architettura custom
        num_features = self.backbone.fc.in_features
        self.backbone.fc = nn.Sequential(
            nn.Dropout(0.5),
            nn.Linear(num_features, 512),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(512, 256),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(256, num_classes)
        )
        
        # Inizializzazione dei pesi
        self._initialize_weights()
    
    def _initialize_weights(self):
        for m in self.backbone.fc.modules():
            if isinstance(m, nn.Linear):
                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
                nn.init.constant_(m.bias, 0)
    
    def forward(self, x):
        return self.backbone(x)

# Data augmentation avanzata per imaging medico
train_transforms = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.RandomHorizontalFlip(p=0.5),
    transforms.RandomRotation(15),
    transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2),
    transforms.RandomAffine(degrees=0, translate=(0.1, 0.1)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])

val_transforms = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])

# Configurazione training avanzata
def train_medical_classifier(model, train_loader, val_loader, num_epochs=25):
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    model.to(device)
    
    # Configurazione optimizer con learning rate scheduling
    optimizer = optim.AdamW(model.parameters(), lr=1e-4, weight_decay=0.01)
    scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=num_epochs)
    
    # Loss function con class weighting per dataset sbilanciati
    criterion = nn.CrossEntropyLoss(weight=torch.tensor([0.8, 1.2, 1.0]).to(device))
    
    best_val_acc = 0.0
    training_history = {'train_loss': [], 'val_loss': [], 'val_acc': []}
    
    for epoch in range(num_epochs):
        # Training phase
        model.train()
        running_loss = 0.0
        
        for batch_idx, (data, targets) in enumerate(train_loader):
            data, targets = data.to(device), targets.to(device)
            
            optimizer.zero_grad()
            outputs = model(data)
            loss = criterion(outputs, targets)
            loss.backward()
            
            # Gradient clipping per stabilità
            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
            
            optimizer.step()
            running_loss += loss.item()
        
        # Validation phase
        model.eval()
        val_loss = 0.0
        correct = 0
        total = 0
        
        with torch.no_grad():
            for data, targets in val_loader:
                data, targets = data.to(device), targets.to(device)
                outputs = model(data)
                val_loss += criterion(outputs, targets).item()
                
                _, predicted = torch.max(outputs.data, 1)
                total += targets.size(0)
                correct += (predicted == targets).sum().item()
        
        val_acc = 100 * correct / total
        
        # Learning rate scheduling
        scheduler.step()
        
        # Logging
        epoch_train_loss = running_loss / len(train_loader)
        epoch_val_loss = val_loss / len(val_loader)
        
        training_history['train_loss'].append(epoch_train_loss)
        training_history['val_loss'].append(epoch_val_loss)
        training_history['val_acc'].append(val_acc)
        
        print(f'Epoch [{epoch+1}/{num_epochs}]')
        print(f'Train Loss: {epoch_train_loss:.4f}')
        print(f'Val Loss: {epoch_val_loss:.4f}, Val Acc: {val_acc:.2f}%')
        print(f'Learning Rate: {scheduler.get_last_lr()[0]:.2e}')
        
        # Model checkpointing
        if val_acc > best_val_acc:
            best_val_acc = val_acc
            torch.save({
                'epoch': epoch,
                'model_state_dict': model.state_dict(),
                'optimizer_state_dict': optimizer.state_dict(),
                'best_val_acc': best_val_acc,
                'training_history': training_history
            }, 'best_medical_model.pth')
    
    return model, training_history

# Utilizzo del modello
# model = MedicalImageClassifier(num_classes=3)
# trained_model, history = train_medical_classifier(model, train_loader, val_loader)

Best Practices per il Fine Tuning

Selezione del Learning Rate

Il learning rate è cruciale in questo caso. Le best practices includono:

• Learning rate ridotto: Tipicamente 1e-5 to 1e-4, molto inferiore al training da zero
• Differential learning rates: Layer più profondi con learning rate maggiore
• Warm-up scheduling: Incremento graduale del learning rate nelle prime epoch

Gestione dell’Overfitting

# Tecniche di regolarizzazione
training_args = TrainingArguments(
    # ... altri parametri
    weight_decay=0.01,           # L2 regularization
    dropout=0.1,                 # Dropout nelle head layers
    early_stopping_patience=3,   # Early stopping
    dataloader_num_workers=4,    # Efficienza I/O
    fp16=True,                   # Mixed precision
    gradient_checkpointing=True, # Memory efficiency
    max_grad_norm=1.0           # Gradient clipping
)

Monitoraggio delle Metriche

import wandb

# Integrazione con Weights & Biases per monitoring
wandb.init(project="fine-tuning-project")

def log_metrics(trainer, logs):
    wandb.log({
        "train_loss": logs.get("train_loss", 0),
        "eval_loss": logs.get("eval_loss", 0),
        "eval_accuracy": logs.get("eval_accuracy", 0),
        "learning_rate": trainer.optimizer.param_groups[0]['lr']
    })

# Callback per logging
class WandbCallback:
    def on_log(self, args, state, control, logs=None, **kwargs):
        if logs:
            wandb.log(logs, step=state.global_step)

Confronto Fine Tuning vs Training da Zero

Quando Utilizzare il Fine Tuning

Vantaggi:

• Dataset limitati: Quando si hanno meno di 10.000 esempi
• Risorse computazionali limitate: GPU consumer-grade
• Time-to-market: Necessità di deploy rapido
• Dominio simile: Task correlato al pre-training

Svantaggi:

• Controllo limitato: Architettura predefinita
• Bias del modello base: Può ereditare bias del pre-training
• Dimensioni fisse: Difficile modificare l’architettura

Quando Optare per Training da Zero

Vantaggi Training da Zero:

• Controllo completo: Architettura custom
• Dominio molto specifico: Task molto diverso dai dataset comuni
• Risorse abbondanti: Cluster di GPU disponibili
• Ricerca avanzata: Sperimentazione architettural

Formazione e Sviluppo Professionale

Per chi desidera approfondire le competenze nel fine tuning e nell’AI generativa, è fondamentale seguire un percorso di formazione strutturato e professionale. Le aziende moderne necessitano di team preparati per affrontare le sfide dell’implementazione AI.

Innovaformazione offre corsi specializzati in AI generativa specificamente progettati per le realtà aziendali. I loro programmi coprono:

• Fine tuning avanzato di modelli foundation
• Implementazione enterprise di soluzioni AI
• Best practices per deployment in produzione
• Ottimizzazione di pipeline di machine learning
• Gestione di progetti AI complessi

I corsi combinano teoria accademica con esperienza pratica, fornendo ai partecipanti gli strumenti necessari per guidare la trasformazione digitale nelle loro organizzazioni. Potete visionare il catalogo formativo per i Corsi AI Generativa o per i Corsi Big Data .

Conclusioni

Questo processo rappresenta una delle tecniche più potenti nel panorama del machine learning moderno. Esso migliora le prestazioni di un modello pre-addestrato per un use case specifico adattandolo a un task specifico. La sua capacità di combinare efficienza computazionale con prestazioni eccellenti lo rende indispensabile per applicazioni pratiche.

Le competenze nel fine tuning sono sempre più richieste nel mercato del lavoro tech, e la padronanza di strumenti come PyTorch e HuggingFace Transformers apre opportunità significative per i professionisti dell’AI.

Investire nella formazione specializzata, come quella offerta da Innovaformazione, permette di rimanere competitivi in un settore in rapida evoluzione e di contribuire efficacemente ai progetti di innovazione aziendale.

(fonte) (fonte) (fonte)

Per altri articoli di settore consigliamo di navigare sul nostro blog QUI.

INFO: info@innovaformazione.net – tel. 3471012275 (Dario Carrassi)