Preprocessing dei dati: guida completa con esempi in Python

Le fasi del preprocessing dei dati

Il preprocessing dei dati comprende diverse fasi, ognuna delle quali affronta sfide specifiche legate a qualità, struttura e rilevanza dei dati. 

Vediamo questi passaggi chiave, che in genere seguono il seguente ordine: 

Fase 1: Pulizia dei dati

La pulizia dei dati è il processo di identificazione e correzione di errori o incoerenze nei dati per garantirne accuratezza e completezza. L’obiettivo è affrontare problemi che possono alterare l’analisi o le prestazioni del modello.

Per esempio: 

• Gestione dei valori mancanti: uso di strategie come imputazione con media/moda, eliminazione o modelli predittivi per riempire o rimuovere i dati mancanti.
• Rimozione dei duplicati: eliminazione dei record duplicati per garantire che ogni voce sia unica e pertinente.
• Correzione di formati incoerenti: standardizzazione dei formati (ad es. formati di data, maiuscole/minuscole delle stringhe) per mantenere la coerenza.

Ecco come appare in Python:

# Creating a manual dataset
data = pd.DataFrame({
    'name': ['John', 'Jane', 'Jack', 'John', None],
    'age': [28, 34, None, 28, 22],
    'purchase_amount': [100.5, None, 85.3, 100.5, 50.0],
    'date_of_purchase': ['2023/12/01', '2023/12/02', '2023/12/01', '2023/12/01', '2023/12/03']
	})

# Handling missing values using mean imputation for 'age' and 'purchase_amount'
imputer = SimpleImputer(strategy='mean')
data[['age', 'purchase_amount']] = imputer.fit_transform(data[['age', 'purchase_amount']])

# Removing duplicate rows
data = data.drop_duplicates()

# Correcting inconsistent date formats
data['date_of_purchase'] = pd.to_datetime(data['date_of_purchase'], errors='coerce')

print(data)

Output del codice sopra 

Fase 2: Integrazione dei dati

L’integrazione dei dati comporta la combinazione di dati provenienti da più fonti per creare un dataset unificato. Questo è spesso necessario quando i dati sono raccolti da diversi sistemi sorgente.

Alcune tecniche utilizzate nell’integrazione dei dati includono: 

• Schema matching: allineare campi e strutture dati di fonti diverse per garantire la coerenza.
• Deduplicazione dei dati: identificare e rimuovere le voci duplicate tra più dataset.

Per esempio, supponiamo di avere dati sui clienti da più database. Ecco come li uniremmo in una singola vista: 

# Creating two manual datasets
data1 = pd.DataFrame({
    'customer_id': [1, 2, 3],
    'name': ['John', 'Jane', 'Jack'],
    'age': [28, 34, 29]
})

data2 = pd.DataFrame({
    'customer_id': [1, 3, 4],
    'purchase_amount': [100.5, 85.3, 45.0],
    'purchase_date': ['2023-12-01', '2023-12-02', '2023-12-03']
})

# Merging datasets on a common key 'customer_id'
merged_data = pd.merge(data1, data2, on='customer_id', how='inner')

print(merged_data)

Output del codice sopra

Fase 3: Trasformazione dei dati

La trasformazione dei dati converte i dati in formati adatti all’analisi, al machine learning o al data mining. 

Per esempio:

• Scaling e normalizzazione: adeguare i valori numerici a una scala comune è spesso necessario per algoritmi che si basano su metriche di distanza.
• Codifica delle variabili categoriche: conversione dei dati categorici in valori numerici usando tecniche di one-hot o label encoding.
• Feature engineering ed estrazione: creazione di nuove feature o selezione di quelle importanti per migliorare le prestazioni del modello.

Ecco come si presenta in Python, usando scikit-learn: 

from sklearn.preprocessing import StandardScaler, OneHotEncoder

# Creating a manual dataset
data = pd.DataFrame({
    'category': ['A', 'B', 'A', 'C', 'B'],
    'numeric_column': [10, 15, 10, 20, 15]
	})

# Scaling numeric data
scaler = StandardScaler()
data['scaled_numeric_column'] = scaler.fit_transform(data[['numeric_column']])

# Encoding categorical variables using one-hot encoding
encoder = OneHotEncoder(sparse_output=False)
encoded_data = pd.DataFrame(encoder.fit_transform(data[['category']]),
                            columns=encoder.get_feature_names_out(['category']))

# Concatenating the encoded data with the original dataset
data = pd.concat([data, encoded_data], axis=1)

print(data)

Output del codice sopra

Fase 4: Riduzione dei dati

La riduzione dei dati semplifica il dataset riducendo il numero di feature o di record, preservando al contempo le informazioni essenziali. Questo aiuta ad accelerare analisi e training dei modelli senza sacrificare l’accuratezza.

Le tecniche di riduzione dei dati includono: 

• Selezione delle feature: scelta delle feature più importanti che contribuiscono all’analisi o alle prestazioni del modello.
• Principal Component Analysis (PCA): una tecnica di riduzione della dimensionalità che trasforma i dati in uno spazio a dimensionalità inferiore.
• Metodi di campionamento: riduzione della dimensione del dataset selezionando campioni rappresentativi, utile per la gestione di dataset di grandi dimensioni.

Ed ecco come implementare la riduzione della dimensionalità in Python:

from sklearn.decomposition import PCA
from sklearn.feature_selection import SelectKBest, chi2

# Creating a manual dataset
data = pd.DataFrame({
    'feature1': [10, 20, 30, 40, 50],
    'feature2': [1, 2, 3, 4, 5],
    'feature3': [100, 200, 300, 400, 500],
    'target': [0, 1, 0, 1, 0]
	})

# Feature selection using SelectKBest
selector = SelectKBest(chi2, k=2)
selected_features = selector.fit_transform(data[['feature1', 'feature2', 'feature3']], data['target'])

# Printing selected features
print("Selected features (SelectKBest):")
print(selected_features)

# Dimensionality reduction using PCA
pca = PCA(n_components=2)
pca_data = pca.fit_transform(data[['feature1', 'feature2', 'feature3']])

# Printing PCA results
print("PCA reduced data:")
print(pca_data)

Output del codice sopra 

Tecniche comuni di preprocessing con esempi

Abbiamo stabilito che il preprocessing dei dati grezzi è essenziale per garantire che siano adatti all’analisi o ai modelli di machine learning. Abbiamo anche visto le fasi coinvolte nel processo. 

In questa sezione, esploreremo varie tecniche per gestire problemi comuni durante la fase di preprocessing. Inoltre, vedremo la data augmentation, una tecnica utile per creare dati sintetici in contesti specifici come dataset di immagini o di testo.

Gestione dei dati mancanti

I dati mancanti possono influire negativamente sulle prestazioni di un modello di machine learning o di un’analisi. Esistono diverse strategie per gestire in modo efficace i valori mancanti:

• Imputazione: questa tecnica consiste nel riempire i valori mancanti con una stima calcolata, come media, mediana o moda dei dati disponibili. Metodi avanzati includono la modellazione predittiva, in cui i valori mancanti vengono previsti in base alle relazioni presenti nei dati.

# Note: This is dummy code and not expected to run on its own
from sklearn.impute import SimpleImputer

imputer = SimpleImputer(strategy='mean')  # Replace 'mean' with 'median' or 'most_frequent' if needed
data['column_with_missing'] = imputer.fit_transform(data[['column_with_missing']])

• Eliminazione: rimuovere righe o colonne con valori mancanti è una soluzione semplice. Va però usata con cautela perché può portare a perdita di dati preziosi, soprattutto se molte voci sono mancanti.

data.dropna(inplace=True)  # Removes rows with any missing values

• Modellazione dei valori mancanti: nei casi in cui lo schema dei dati mancanti è più complesso, modelli di machine learning possono prevedere i valori mancanti sulla base del resto del dataset. Questo può migliorare l’accuratezza incorporando le relazioni tra le variabili.

Rilevamento e rimozione degli outlier

Gli outlier sono valori estremi che si discostano significativamente dal resto dei dati e, come i valori mancanti, possono alterare analisi e prestazioni dei modelli. Esistono diverse tecniche per individuare e gestire gli outlier:

• Metodo Z-Score: misura di quante deviazioni standard un punto dati si trova rispetto alla media. I punti oltre una certa soglia (ad es. ±3 deviazioni standard) possono essere considerati outlier.

# Note: this is dummy code. 
# It won’t work unless a data with a column named “column” is imported

from scipy import stats 
z_scores = stats.zscore(data['column']) outliers = abs(z_scores) > 3 # Identifying outliers

• Intervallo interquartile (IQR): l’IQR è l’intervallo tra il primo quartile (Q1) e il terzo quartile (Q3). I valori oltre 1,5 volte l’IQR sopra Q3 o sotto Q1 sono considerati outlier.

Q1 = data['column'].quantile(0.25)
Q3 = data['column'].quantile(0.75)
IQR = Q3 - Q1
outliers = (data['column'] < (Q1 - 1.5 * IQR)) | (data['column'] > (Q3 + 1.5 * IQR))

• Tecniche visive: metodi di visualizzazione come box plot, scatter plot o istogrammi possono aiutare a rilevare outlier in un dataset. Una volta identificati, gli outlier possono essere rimossi o trasformati, a seconda della loro influenza sull’analisi.

Codifica dei dati

Quando si lavora con dati categorici, è necessario codificarli per convertirli in rappresentazioni numeriche che gli algoritmi di machine learning possano elaborare. Tra le tecniche comuni di codifica ci sono:

• One-hot encoding: come già menzionato, questo metodo crea colonne binarie per ogni categoria.

from sklearn.preprocessing import OneHotEncoder
encoder = OneHotEncoder(sparse_output=False)
encoded_data = encoder.fit_transform(data[['categorical_column']])

• Label encoding: assegna un valore numerico univoco a ogni categoria. Tuttavia, questo metodo può introdurre una relazione ordinale indesiderata tra categorie che non hanno un ordine naturale.

from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
data['encoded_column'] = le.fit_transform(data['categorical_column'])

• Ordinal encoding: viene usato quando le variabili categoriche hanno un ordine intrinseco, come basso, medio e alto. Ogni categoria è mappata a un intero corrispondente che riflette il suo rango.

from sklearn.preprocessing import OrdinalEncoder
oe = OrdinalEncoder(categories=[['low', 'medium', 'high']])
data['ordinal_column'] = oe.fit_transform(data[['ordinal_column']])

Scaling e normalizzazione dei dati

Scaling e normalizzazione assicurano che le feature numeriche siano su una scala simile, particolarmente importante per algoritmi che si basano su metriche di distanza (ad es. k-nearest neighbors, SVM).

• Min-max scaling: scala i dati in un intervallo specificato, tipicamente da 0 a 1. È utile quando tutte le feature devono avere la stessa scala.

from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
data[['scaled_column']] = scaler.fit_transform(data[['numeric_column']])

• Standardizzazione (normalizzazione Z-Score): scala i dati in modo che la media diventi 0 e la deviazione standard 1, aiutando i modelli a funzionare meglio con feature distribuite normalmente.

from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
data[['standardized_column']] = scaler.fit_transform(data[['numeric_column']])

Data augmentation

La data augmentation è una tecnica per aumentare artificialmente la dimensione di un dataset creando nuovi esempi sintetici. È particolarmente utile per dataset di immagini o di testo nei modelli di deep learning, dove sono necessarie grandi quantità di dati per prestazioni robuste.

• Image augmentation: tecniche come rotazione, ribaltamento, scaling o aggiunta di rumore alle immagini aiutano a creare variazioni che migliorano la capacità di generalizzazione del modello.

from tensorflow.keras.preprocessing.image import ImageDataGenerator

datagen = ImageDataGenerator(
    rotation_range=40,
    width_shift_range=0.2,
    height_shift_range=0.2,
    shear_range=0.2,
    zoom_range=0.2,
    horizontal_flip=True,
    fill_mode='nearest')

augmented_images = datagen.flow_from_directory('image_directory', target_size=(150, 150))

• Text augmentation: per i dati testuali, i metodi di augmentation includono sostituzione di sinonimi, inserimenti casuali e back-translation, in cui una frase viene tradotta in un’altra lingua e poi di nuovo nella lingua originale, introducendo variazioni.

import nlpaug.augmenter.word as naw
# install nlpaug here: https://github.com/makcedward/nlpaug 

aug = naw.SynonymAug(aug_src='wordnet')
augmented_text = aug.augment("This is a sample text for augmentation.")

Strumenti per il preprocessing dei dati

Sebbene tu possa implementare l’elaborazione dei dati con puro codice Python, sono stati sviluppati potenti strumenti per gestire varie attività e rendere l’intero processo più efficiente. Eccone alcuni esempi: 

Librerie Python

Esistono parecchie librerie specializzate per il preprocessing in Python. Ecco tre delle più popolari: 

• Pandas: la libreria più usata in Python per la manipolazione e pulizia dei dati. Fornisce strutture dati flessibili, principalmente DataFrame e Series, che ti permettono di gestire e manipolare dati strutturati in modo efficiente. Pandas supporta operazioni come gestione dei dati mancanti, unione di dataset, filtraggio e reshaping.

import pandas as pd

# Load a sample dataset
data = pd.DataFrame({
    'name': ['John', 'Jane', 'Jack'],
    'age': [28, 31, 34]
})

print(data)

Output del codice sopra 

• NumPy: una libreria fondamentale per il calcolo numerico. Supporta array e matrici di grandi dimensioni e multi-dimensionali e funzioni matematiche per operare su questi array. NumPy è spesso la base per molte librerie di elaborazione dati di livello superiore, come Pandas.

import numpy as np

# Create an array and perform element-wise operations
array = np.array([1, 2, 3, 4])
squared_array = np.square(array)

print(squared_array)

Output del codice sopra

• Scikit-learn: ampiamente utilizzata per attività di machine learning, offre anche numerose utilità di preprocessing, come scaling, encoding e trasformazione dei dati. Il suo modulo di preprocessing contiene strumenti per gestire dati categorici, scalare dati numerici, estrarre feature e altro.

from sklearn.preprocessing import StandardScaler 

# Standardize data 
data = [[10, 2], [15, 5], [20, 3]] 
scaler = StandardScaler() 
scaled_data = scaler.fit_transform(data)
print(scaled_data)

Output del codice sopra

Piattaforme cloud

I sistemi on-premise potrebbero non essere in grado di gestire efficacemente grandi dataset. In tali situazioni, le piattaforme cloud offrono soluzioni scalabili ed efficienti che ti permettono di elaborare enormi quantità di dati su sistemi distribuiti. 

Alcuni strumenti di piattaforme cloud da considerare includono: 

• AWS Glue: un servizio ETL completamente gestito da Amazon Web Services. Rileva e organizza i dati in automatico e li prepara per l’analisi. Glue supporta la catalogazione dei dati e può connettersi a servizi AWS come S3 e Redshift.
• Azure Data Factory: un servizio di integrazione dati basato su cloud di Microsoft. Supporta la creazione di pipeline ETL ed ELT per grandi volumi di dati. Azure Data Factory consente agli utenti di spostare i dati tra vari servizi, pre-processarli tramite trasformazioni e orchestrare workflow tramite un’interfaccia visiva.

Strumenti di automazione

Automatizzare i passaggi ripetitivi del preprocessing può far risparmiare tempo e ridurre gli errori, soprattutto quando si lavora con modelli di machine learning e grandi dataset. Ecco alcuni strumenti che offrono pipeline di preprocessing integrate: 

• Piattaforme AutoML: AutoML è l’acronimo di Automated Machine Learning (e significa proprio ciò che suggerisce il nome). In altre parole, queste piattaforme automatizzano varie fasi del workflow di machine learning. Piattaforme come AutoML di Google, Azure AutoML di Microsoft e AutoML di H2O.ai offrono pipeline automatizzate che gestiscono attività come selezione delle feature, trasformazione dei dati e scelta del modello con il minimo intervento dell’utente.
• Pipeline di preprocessing in scikit-learn: scikit-learn fornisce la classe Pipeline, che aiuta a razionalizzare e automatizzare i passaggi di preprocessing. Ti consente di concatenare più operazioni di preprocessing in un unico workflow eseguibile, assicurando che i passaggi vengano applicati in modo coerente:

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.compose import ColumnTransformer

# Example Pipeline combining different preprocessing tasks
numeric_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='mean')),
    ('scaler', StandardScaler())
])

categorical_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='most_frequent')),
    ('encoder', OneHotEncoder())
])

preprocessor = ColumnTransformer(transformers=[
    ('num', numeric_transformer, ['age']),
    ('cat', categorical_transformer, ['category'])
])

preprocessed_data = preprocessor.fit_transform(data)

Best practice per il preprocessing dei dati

È essenziale seguire le best practice per massimizzare l’efficacia delle attività di preprocessing. Detto ciò, ecco alcune pratiche che ti invito a considerare: 

Comprendere i dati

Prima di iniziare il preprocessing, è importante comprendere a fondo il dataset. Conduci un’analisi esplorativa dei dati per identificare la struttura dei dati a disposizione. In particolare, quello che vuoi capire è: 

• Feature chiave 
• Anomalie potenziali
• Relazioni 

Senza comprendere prima le caratteristiche del dataset, è abbastanza probabile che tu applichi metodi di preprocessing errati, alterando i dati. 

Automatizzare i passaggi ripetitivi

Il preprocessing spesso include attività ripetitive. Automatizzare questi compiti costruendo pipeline garantisce coerenza ed efficienza e riduce la probabilità di errori manuali. Per snellire i workflow, sfrutta le pipeline in strumenti come scikit-learn o piattaforme cloud.

Documentare i passaggi di preprocessing

Una documentazione chiara aiuta a raggiungere due obiettivi:

• Riproducibilità
• Comprensione (per te in un secondo momento o per altri nel tuo team).

Ogni decisione, trasformazione o passaggio di filtro dovrebbe essere registrato, inclusa la motivazione. Questo migliorerà notevolmente la collaborazione tra i membri del team e ti aiuterà a riprendere i progetti da dove li avevi lasciati. 

Miglioramenti iterativi

Il preprocessing dei dati non è un’attività una tantum: dovrebbe essere un processo iterativo. Man mano che i modelli evolvono e forniscono feedback sulle prestazioni, usa queste informazioni per rivedere e perfezionare i passaggi di preprocessing, poiché può portare a risultati migliori. Per esempio, il feature engineering può far emergere nuove feature utili, oppure una migliore taratura della gestione degli outlier può migliorare l’accuratezza del modello: usa questo feedback per aggiornare i passaggi di preprocessing. 

Conclusione

Il preprocessing dei dati svolge un ruolo cruciale nel successo di qualsiasi progetto data-driven. Un preprocessing corretto trasforma i dati grezzi in un formato pulito e strutturato, aiutando modelli e analisi a produrre insight più accurati e significativi. 

In questo articolo ho condiviso varie tecniche per aiutarti a implementare il preprocessing dei dati. Tuttavia, la cosa più importante da ricordare è che non si tratta di uno sforzo una tantum, ma di un processo iterativo! Un perfezionamento continuo porta a prestazioni migliori del modello e a decisioni più informate. Un dataset ben preparato è la base di qualsiasi iniziativa di AI di successo.

Per continuare a imparare, ti consiglio di dare un’occhiata a queste risorse eccellenti:

• Cleaning Data in Python
• Cleaning Data in R
• Cleaning Data with PySpark
• Data Cleaning Checklist
• Data Quality Dimensions Cheat Sheet