Impara Raccolta e Preprocessamento dei Dati

Scorri per mostrare il menu

L'addestramento di modelli generativi richiede non solo una buona architettura e funzioni di perdita adeguate, ma anche dati puliti, ben strutturati e diversificati. Questa sezione presenta dataset di alta qualità nei domini della visione, del testo e dell'audio, fornisce tecniche di pre-processing dettagliate adatte alle moderne pipeline generative e discute strategie robuste di suddivisione dei dati con strumenti pratici.

Raccolta dei dati

La raccolta dei dati per la modellazione generativa dipende dal dominio, dalla disponibilità delle fonti, dalla scala e dalle licenze. Per i dati di testo e visione, le fonti comuni includono dataset aperti, contenuti estratti e repository strutturati (ad esempio archivi accademici, social media o piattaforme di e-commerce).

Tecniche di Web Scraping

Quando i dataset non sono facilmente disponibili, i dati possono essere raccolti dal web utilizzando strumenti di scraping. Il web scraping consente di estrarre informazioni in modo programmato dalle pagine HTML. Si tratta di un approccio potente per raccogliere dati reali e non strutturati quando le API non sono disponibili. Tuttavia, lo scraping comporta responsabilità sia tecniche che etiche.

Le metodologie di scraping generalmente includono:

Invio di richieste HTTP per recuperare le pagine web. Questo permette di accedere al contenuto HTML grezzo di una pagina;
Parsing del contenuto HTML per estrarre dati strutturati. Strumenti come BeautifulSoup convertono HTML non strutturato in tag ed elementi accessibili;
Navigazione di pagine dinamiche tramite automazione del browser. I siti web ricchi di JavaScript richiedono strumenti come Selenium per rendere completamente il contenuto;
Memorizzazione dei dati estratti in formati utilizzabili come CSV o JSON. Questo garantisce la compatibilità con le successive fasi di preprocessamento e addestramento del modello.

Di seguito sono riportate due strategie comuni di scraping:

Scraping di Testo con BeautifulSoup

BeautifulSoup è una libreria Python utilizzata per il parsing di pagine HTML statiche.


              1234567891011
            
import requests
from bs4 import BeautifulSoup

url = "https://docs.python.org/3/"
response = requests.get(url)
soup = BeautifulSoup(response.text, "html.parser")

# Extract paragraphs
paragraphs = [p.text for p in soup.find_all('p')]
text = "\n".join(paragraphs)
print(text)

Estrazione di immagini con Selenium

Selenium automatizza un browser per estrarre contenuti da pagine generate tramite JavaScript.


              123456789101112131415161718
            
# INSTALL SELENIUM
# THIS CODE DOWNLOAD IMAGES (I NEED JUST VIZUALIZATION)

from selenium import webdriver
import time
import urllib.request

url = "https://example.com/gallery"
driver = webdriver.Chrome()
driver.get(url)
time.sleep(2)

images = driver.find_elements("tag name", "img")
for idx, img in enumerate(images):
    src = img.get_attribute('src')
    if src:
        urllib.request.urlretrieve(src, f"image_{idx}.jpg")
driver.quit()

Nota

Verificare sempre i termini di servizio di un sito web prima di effettuare scraping. Utilizzare frequenze di richiesta moderate e rispettare il file robots.txt. Uno scraping improprio può comportare il blocco dell'indirizzo IP o conseguenze legali.

Nei contesti GenAI, il web scraping è spesso un passaggio preliminare per la creazione di dataset di pre-addestramento, in particolare per domini specifici o lingue a bassa disponibilità di risorse. Strumenti come Scrapy, playwright o API browserless sono frequentemente utilizzati anche per attività su larga scala.

Tecniche di Preprocessing

Il preprocessing dei dati deve essere adattato alla modalità, al tipo di modello e ai vincoli di qualità. Per la modellazione generativa a livello produttivo, le pipeline includono spesso trasformazioni specifiche del dominio, adattamento della risoluzione e filtraggio basato sul contenuto.

Preprocessing delle Immagini

Ridimensionamento: adattamento della risoluzione del dataset all'input del modello (ad esempio, 64x64 per i primi GAN, 512x512 per i modelli di diffusione);

from PIL import Image

img = Image.open("example.jpg")
resized = img.resize((256, 256))
resized.save("resized.jpg")

Normalizzazione: scala i valori dei pixel su un intervallo standard, tipicamente [−1, 1] o [0, 1];

from torchvision import transforms

transform = transforms.Compose([
    transforms.Resize((256, 256)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.5]*3, std=[0.5]*3)  # RGB to [-1, 1]
])

Gestione dello Spazio Colore: garantire la coerenza cromatica — conversione in RGB o scala di grigi. Per la generazione condizionata, mantenere i canali alfa se presenti;

from PIL import Image

img = Image.open("example.png").convert("RGB")
img.save("rgb_image.jpg")

Aumento dei dati: introduce variazioni durante l'addestramento tramite trasformazioni.

import albumentations as A
from albumentations.pytorch import ToTensorV2

transform = A.Compose([
    A.RandomResizedCrop(256, 256),
    A.HorizontalFlip(),
    A.ColorJitter(),
    A.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)),
    ToTensorV2(),
])

Preprocessing del testo

Pulizia: rimuove caratteri speciali, spazi bianchi in eccesso e rumore;


              12345
            
import re
text = "Example   text — with  symbols!"
cleaned = re.sub(r"[^\w\s]", "", text)
cleaned = re.sub(r"\s+", " ", cleaned).strip()
print(cleaned)

r"[^\w\s]":
- \w: corrisponde a qualsiasi carattere alfanumerico (lettere A-Z, a-z, cifre 0-9) e underscore _;
- \s: corrisponde a qualsiasi carattere di spazio bianco (spazi, tabulazioni, ritorni a capo);
- [^...]: una classe di caratteri negata—corrisponde a tutto ciò che non è elencato all'interno;
- Significato: questo pattern corrisponde a tutti i caratteri tranne lettere, cifre, underscore e spazi bianchi. Quindi rimuove punteggiatura e simboli (come —, !, ecc.).
r"\s+":
- \s: corrisponde a qualsiasi carattere di spazio bianco;
- +: corrisponde a uno o più del token precedente;
- Significato: questo sostituisce più caratteri di spazio bianco consecutivi con uno spazio singolo.
.strip(): rimuove gli spazi bianchi iniziali e finali dalla stringa pulita finale.

Per ulteriori informazioni sulla sintassi RegEx, consultare la documentazione.

Conversione in minuscolo: standardizza il testo in minuscolo per coerenza. Applicare selettivamente, poiché modelli come BERT sono case-sensitive o meno;


              12
            
text = "This Is A Sentence."
print(text.lower())

Tokenizzazione: suddivide il testo in token o sottoparole per la modellazione;


              1234
            
from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("gpt2")
encodings = tokenizer(["Example text."], padding="max_length", truncation=True, max_length=128, return_tensors="pt")

Stemming/Lemmatizzazione: raro nelle pipeline di deep learning ma utilizzato nei tradizionali flussi NLP o nei filtri di pre-addestramento;


              1234
            
from nltk.stem import PorterStemmer
  
stemmer = PorterStemmer()
print(stemmer.stem("running"))

Padding/Troncamento: vedere l'esempio sopra con max_length.


              1234
            
from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("gpt2")
inputs = tokenizer("Short text.", max_length=10, padding="max_length", truncation=True, return_tensors="pt")

Nota

Costruzione di pipeline di pre-processing modulari con attenzione alla riproducibilità. Utilizzo di DVC, wandb artifacts o huggingface/datasets con streaming + caching.

Strategie di suddivisione dei dati

Una suddivisione efficace dei dati è essenziale per la generalizzazione, soprattutto nel modeling generativo dove l'overfitting alle modalità o la memorizzazione sono comuni.

Suddivisione Train/Validation/Test

Rapporti convenzionali: 80/10/10 o 70/15/15 a seconda della dimensione del dataset;
Suddivisione consapevole del contenuto: suddividere in modo stratificato per classe (vision), argomento (testo).
Caso d'uso:
- Training: ottimizzazione del modello;
- Validation: guida il checkpointing, l'early stopping e la regolazione delle metriche (ad es. FID);
- Test: completamente escluso fino al benchmarking finale del modello.

Esempio con train_test_split:

from sklearn.model_selection import train_test_split

# Example: splitting an image dataset (paths or features)
train_paths, val_paths = train_test_split(image_paths, test_size=0.1, random_state=42)
train_paths, test_paths = train_test_split(train_paths, test_size=0.111, random_state=42)  # 0.111 to get ~10% test

Per i Datasets di Hugging Face:

from datasets import load_dataset

dataset = load_dataset("wikitext", "wikitext-2-raw-v1")
split_dataset = dataset["train"].train_test_split(test_size=0.2, seed=42)
train_val = split_dataset["train"].train_test_split(test_size=0.1, seed=42)

train_set = train_val["train"]
val_set = train_val["test"]
test_set = split_dataset["test"]

Cross-Validation e Bootstrapping

Per domini a bassa risorsa o zero-shot, utilizzare K-fold CV (ad esempio, K=5 o 10);
Nei modelli di diffusione, utilizzare FID/LPIPS bootstrappati per valutare la stabilità della generazione;
L'ispezione visiva o percettiva deve accompagnare la validazione numerica.

Esempio di configurazione K-fold:

from sklearn.model_selection import KFold
import numpy as np

kf = KFold(n_splits=5, shuffle=True, random_state=42)
for fold, (train_idx, val_idx) in enumerate(kf.split(data)):
    print(f"Fold {fold}: Train indices {train_idx[:5]}, Val indices {val_idx[:5]}")

Dataset Comunemente Utilizzati

La scelta del dataset appropriato dipende dalla modalità, dalla scala dei dati, dalle licenze e dallo specifico obiettivo generativo (ad esempio, generazione incondizionata, sintesi condizionata o trasferimento di stile).

Dataset per Computer Vision

CIFAR-10: 60.000 immagini RGB a bassa risoluzione 32×32 suddivise in 10 classi. Leggero, ideale per prototipazione rapida, unit test e benchmarking di training loop per GAN di immagini;
CelebA: oltre 200.000 volti di celebrità allineati e annotati con 40 attributi binari. Utilizzato frequentemente per generazione condizionata da attributi, editing facciale con mantenimento dell'identità e modelli encoder-decoder;
LSUN: dataset di scene su larga scala contenente milioni di immagini in categorie come camere da letto, chiese e sale da pranzo. Fondamentale per la sintesi ad alta risoluzione e l'addestramento progressivo di GAN;
ImageNet: oltre 14 milioni di immagini di alta qualità etichettate in 20.000 classi. Utilizzato principalmente per transfer learning, pretraining di modelli di diffusione e come dataset base per generazione guidata dallo stile.

Dataset Testuali

WikiText: articoli Wikipedia puliti (WikiText-2: 2 milioni di token, WikiText-103: oltre 100 milioni). Utile per la valutazione del language modeling e il fine-tuning di modelli decoder-only come GPT;
BookCorpus: oltre 11.000 romanzi gratuiti. Fondamentale per la generazione narrativa, transformer a lungo contesto e pretraining di modelli fondamentali (ad esempio, BERT, GPT-2);
Common Crawl / C4: dati web multilingue su scala petabyte. C4 è una variante deduplicata e filtrata, curata per l'addestramento di modelli linguistici di alta qualità (ad esempio, T5);
The Pile: 825GB di dati eterogenei (libri, ArXiv, StackExchange, GitHub, ecc.). Progettato per addestrare modelli in stile GPT in modo competitivo con i LLM di OpenAI.

Riepilogo

Selezione dei dataset basata su qualità, licenza, scala e allineamento con gli obiettivi generativi;
Applicazione di pipeline di pre-elaborazione specifiche per ogni modalità utilizzando strumenti robusti e di livello produttivo;
Adozione di strategie rigorose di suddivisione per garantire la riproducibilità, evitare contaminazioni e consentire una valutazione equa.