L’alba dei Denoisers modelli di apprendimento automatico multi-output per l’imputazione dei dati tabulari

'L'alba dei modelli Denoisers multi-output per l'imputazione dei dati tabulari'

La gestione dei valori mancanti nei dati tabulari è un problema fondamentale nella scienza dei dati. Se i valori mancanti non possono essere ignorati o omessi per qualsiasi motivo, possiamo provare a imputarli, cioè sostituire i valori mancanti con altri valori. Ci sono alcuni approcci semplici (ma semplicistici) all’imputazione e alcuni più avanzati (più accurati ma complessi e potenzialmente intensivi in termini di risorse). Questo articolo presenta un nuovo approccio all’imputazione dei dati tabulari che cerca di raggiungere un equilibrio tra semplicità e utilità.

In particolare, vedremo come il concetto di denoising (tipicamente associato ai dati non strutturati) possa essere utilizzato per trasformare rapidamente quasi qualsiasi algoritmo di apprendimento automatico multi-output in un imputatore di dati tabulari adatto all’uso pratico. Inizieremo coprendo alcuni concetti di base relativi al denoising, all’imputazione e agli algoritmi multi-output, per poi approfondire i dettagli su come trasformare gli algoritmi multi-output in imputatori utilizzando il denoising. Successivamente, daremo uno sguardo breve a come questo nuovo approccio può essere applicato nella pratica con un esempio tratto dall’industria. Infine, discuteremo la futura rilevanza dell’imputazione di dati tabulari basata sul denoising nell’era dell’intelligenza artificiale generativa e dei modelli di base. Per facilità di spiegazione, gli esempi di codice saranno mostrati solo in Python, anche se l’approccio concettuale stesso è indipendente dal linguaggio.

Dal Denoising all’Imputazione

Il denoising riguarda la rimozione del rumore dai dati. Gli algoritmi di denoising prendono in input dati rumorosi, effettuano un’elaborazione intelligente per ridurre il rumore il più possibile e restituiscono i dati de-noised. I casi d’uso tipici per il denoising includono la rimozione del rumore dai dati audio e la nitidezza delle immagini sfocate. Gli algoritmi di denoising possono essere costruiti utilizzando diversi approcci, che vanno dai filtri gaussiani e mediani agli autoencoder.

Sebbene il concetto di denoising tenda ad essere principalmente associato a casi d’uso che coinvolgono dati non strutturati (ad esempio, audio, immagini), l’imputazione di dati tabulari strutturati è un concetto strettamente correlato. Ci sono molti modi per sostituire (o imputare) i valori mancanti nei dati tabulari. Ad esempio, i dati potrebbero essere semplicemente sostituiti da zeri (o un valore equivalente nel contesto dato), oppure da una statistica della riga o colonna rilevante per i dati numerici (ad esempio, media, mediana, moda, minimo, massimo) — ma facendo questo si potrebbero distorcere i dati e, se utilizzato come passaggio di pre-elaborazione in un flusso di lavoro di formazione di apprendimento automatico, tale imputazione semplicistica potrebbe influire negativamente sulle prestazioni predictive. Altri approcci come K Nearest Neighbors (KNN) o association rule mining potrebbero funzionare meglio, ma poiché non hanno la nozione di formazione e lavorano direttamente sui dati di test, possono avere problemi di velocità quando la dimensione dei dati di test diventa grande; questo è particolarmente problematico per i casi d’uso che richiedono un’elaborazione online rapida.

• Lavorare con i dataset di Hugging Face
• Mantenere la Qualità dei Dati nei Sistemi di Apprendimento Automatico
• Le competenze che aiutano i data scientist a crescere

Ora, potremmo semplicemente addestrare un modello di apprendimento automatico che imposti la feature con i valori mancanti come output e utilizzi il resto delle feature come predittori (o input). Se abbiamo diverse feature con valori mancanti, la creazione di modelli a singolo output per ciascuna di esse potrebbe essere complicata, per non parlare del fatto che potrebbe essere costoso, quindi potremmo provare a creare un modello multi-output che preveda i valori mancanti per tutte le feature interessate contemporaneamente. In modo cruciale, se i valori mancanti possono essere considerati rumore, potremmo essere in grado di applicare concetti di denoising per imputare i dati tabulari — e questa è l’idea chiave su cui ci baseremo nelle sezioni seguenti.

Algoritmi di Apprendimento Automatico Multi-Output

Come suggerisce il nome, gli algoritmi multi-output (o multi-target) possono essere utilizzati per addestrare modelli per la previsione di più output/target contemporaneamente. Il sito web di Scikit-learn fornisce una grande panoramica degli algoritmi multi-output per classificazione e regressione (vedi qui ).

Mentre alcuni algoritmi di apprendimento automatico consentono la modellazione multi-output “out-of-the-box”, altri potrebbero supportare nativamente solo la modellazione a singolo output. Biblioteche come Scikit-learn offrono modi per sfruttare algoritmi a singolo output per la modellazione multi-output fornendo wrapper che implementano le funzioni usuali come fit e predict, e applicando queste a modelli a singolo output separati in modo indipendente sotto il cofano. Il seguente esempio di codice mostra come incapsulare l’implementazione di una regressione del vettore di supporto lineare (Linear SVR) in Scikit-learn, che nativamente supporta solo la modellazione a singolo output, in un regressore multi-output utilizzando il wrapper MultiOutputRegressor.

from sklearn.datasets import make_regressionfrom sklearn.svm import LinearSVRfrom sklearn.multioutput import MultiOutputRegressor# Costruisci un dataset di provaRANDOM_STATE = 100xs, ys = make_regression(    n_samples=2000, n_features=7, n_informative=5,     n_targets=3, random_state=RANDOM_STATE, noise=0.2)# Incapsula il Linear SVR per abilitare la modellazione multi-outputwrapped_model = MultiOutputRegressor(    LinearSVR(random_state=RANDOM_STATE)).fit(xs, ys)

Mentre una tale strategia di avvolgimento ci permette almeno di utilizzare algoritmi a singola uscita in casi di utilizzo a multi-uscita, potrebbe non tener conto delle correlazioni o delle dipendenze tra le caratteristiche di uscita (cioè se un insieme di caratteristiche di uscita previste ha senso nel suo complesso). Al contrario, alcuni algoritmi di ML che supportano nativamente la modellazione a multi-uscita sembrano tener conto delle relazioni tra le uscite. Ad esempio, quando un albero decisionale in Scikit-learn viene utilizzato per modellare n uscite basate su alcuni dati di input, tutti i valori di uscita n sono memorizzati nelle foglie e vengono utilizzati criteri di divisione che considerano tutti i valori di uscita n come un insieme, ad esempio, facendo la media su di essi (vedi qui). Il seguente codice di esempio mostra come costruire un regressore ad albero decisionale a multi-uscita: noterai che, superficialmente, i passaggi sono abbastanza simili a quelli mostrati in precedenza per l’addestramento del Linear SVR con un wrapper.

from sklearn.datasets import make_regressionfrom sklearn.tree import DecisionTreeRegressor# Costruisci un dataset giocattoloRANDOM_STATE = 100xs, ys = make_regression(    n_samples=2000, n_features=7, n_informative=5,     n_targets=3, random_state=RANDOM_STATE, noise=0.2)# Addestra un modello a multi-uscita direttamente utilizzando un albero decisionalemodel = DecisionTreeRegressor(random_state=RANDOM_STATE).fit(xs, ys)

Addestramento di Modelli di Machine Learning Multi-Output come Denoiser per l’Imputazione di Dati Tabulari

Ora che abbiamo coperto le basi del denoising, dell’imputazione e degli algoritmi di ML multi-uscita, siamo pronti per mettere insieme tutti questi blocchi di costruzione. In generale, l’addestramento di modelli di ML multi-uscita per imputare dati tabulari utilizzando il denoising consiste nei seguenti passaggi. Si noti che, a differenza degli esempi di codice nella sezione precedente, non differenzieremo esplicitamente tra predittori e target nel seguente: questo perché, nel contesto dell’imputazione di dati tabulari, le caratteristiche possono fungere da predittori se sono presenti nei dati e da target se sono mancanti.

Passo 1: Creare set di dati di addestramento e di convalida

Suddividere i dati in un set di addestramento e un set di convalida, ad esempio utilizzando un rapporto di divisione 80:20. Chiamiamo questi set df_training e df_validation , rispettivamente.

Passo 2: Creare copie rumorose/mascherate dei set di addestramento e di convalida

Fare una copia di df_training e df_validation e aggiungere rumore ai dati in queste copie, ad esempio, mascherando casualmente i valori. Chiamiamo le copie mascherate df_training_masked e df_validation_masked , rispettivamente. La scelta della funzione di mascheramento può influire sull’accuratezza predittiva dell’imputatore che viene addestrato alla fine, quindi esamineremo alcune strategie di mascheramento nella prossima sezione. Inoltre, se la dimensione di df_training è piccola, potrebbe avere senso campionare in modo più accurato le righe con un fattore k , in modo che se df_training ha n righe e m colonne, allora il dataset df_training_masked campionato in modo più accurato avrà n*k righe (e m colonne come prima).

Passo 3: Addestrare un modello multi-uscita come imputatore basato sul denoising

Scegli un algoritmo multi-uscita a tua scelta e addestra un modello che predice i dati di addestramento originali utilizzando la copia rumorosa/mascherata. Concettualmente, faresti qualcosa del genere model.fit(predictors = df_training_masked, targets = df_training) .

Passo 4: Applicare l’imputatore al dataset di convalida mascherato

Passare df_validation_masked al modello addestrato per prevedere df_validation . Concettualmente, questo assomiglierà a qualcosa del genere df_validation_imputed = model.predict(df_validation_masked) . Si noti che alcune funzioni di adattamento possono prendere direttamente i dataset di convalida come argomenti per calcolare l’errore di convalida durante il processo di adattamento (ad esempio, per le reti neurali in TensorFlow) – se è così, ricorda di utilizzare il set di convalida rumoroso/mascherato ( df_validation_masked ) per i predittori e il set di convalida originale ( df_validation ) per i target durante il calcolo dell’errore di convalida.

Passo 5: Valutare l’accuratezza dell’imputazione per il dataset di convalida

Valutare l’accuratezza dell’imputazione confrontando df_validation_imputed (quello che il modello ha previsto) con df_validation (la verità di riferimento). La valutazione può essere fatta per colonna (per determinare l’accuratezza dell’imputazione per caratteristica) o per riga (per verificare l’accuratezza per istanza di previsione). Per evitare di ottenere risultati di accuratezza gonfiati per colonna, è possibile filtrare le righe in cui il valore della colonna da prevedere non è mascherato in df_validation_masked prima di calcolare l’accuratezza.

Infine, sperimenta con i passaggi sopra per ottimizzare il modello (ad esempio, utilizza un’altra strategia di mascheramento o scegli un diverso algoritmo di machine learning multi-output).

Il seguente codice mostra un esempio di come i Passaggi 1-5 potrebbero essere implementati.

import pandas as pd
import numpy as np
from sklearn.datasets import make_classification
from sklearn.tree import DecisionTreeClassifier

# Costruisci un dataset di esempio
RANDOM_STATE = 100
data = make_classification(n_samples=2000, n_features=7, n_classes=1, random_state=RANDOM_STATE, class_sep=2, n_informative=3)
df = pd.DataFrame(data[0]).applymap(lambda x: int(abs(x)))

###### Passo 1: Crea set di dati di addestramento e di validazione #####
TRAIN_TEST_SPLIT_FRAC = 0.8
n = int(df.shape[0]*TRAIN_TEST_SPLIT_FRAC)
df_training, df_validation = df.iloc[:n, :], df.iloc[n:, :].reset_index(drop=True)

###### Passo 2: Crea copie rumorose/mascherate dei set di dati di addestramento e di validazione #####
# Esempio di mascheramento casuale in cui ogni decisione di mascherare un valore è considerata come un lancio di una moneta (evento Bernoulli)
def random_masking(value): 
    return -1 if np.random.binomial(n=1, p=0.5) else value

df_training_masked = df_training.applymap(random_masking)
df_validation_masked = df_validation.applymap(random_masking)

###### Passo 3: Addestra un modello multi-output da utilizzare come imputatore basato su denoising #####
# Nota che i dati mascherati vengono utilizzati per modellare i dati originali
model = DecisionTreeClassifier(random_state=RANDOM_STATE).fit(X=df_training_masked, y=df_training)

###### Passo 4: Applica l'imputatore al set di dati di validazione mascherato #####
df_validation_imputed = pd.DataFrame(model.predict(df_validation_masked))

###### Passo 5: Valuta l'accuratezza dell'imputazione sul set di dati di validazione #####
# Verifica la metrica di accuratezza di base top-1, tenendo conto dei risultati sovrastimati
feature_accuracy_dict = {}
for i in range(df_validation_masked.shape[1]):
    # Ottieni la lista degli indici di riga in cui la feature i è stata mascherata, cioè che doveva essere imputata
    masked_indexes = df_validation_masked.index[df_validation_masked[i] == -1]
    # Calcola l'accuratezza dell'imputazione solo per quelle righe per la feature i
    feature_accuracy_dict[i] = (df_validation_imputed.iloc[masked_indexes, i] == df_validation.iloc[masked_indexes, i]).mean()

print(feature_accuracy_dict)

Strategie di mascheramento dei dati

In generale, potrebbero essere impiegate diverse strategie per mascherare i dati di addestramento e di validazione. A livello generale, possiamo distinguere tra tre strategie di mascheramento: esaustivo, casuale e basato sul dominio.

Mascheramento esaustivo

Questa strategia prevede la generazione di tutte le possibili combinazioni di mascheramento per ogni riga nel dataset. Supponiamo di avere un dataset con n righe e m colonne. Allora il mascheramento esaustivo espanderebbe ogni riga in al massimo 2^ m righe, una per ogni combinazione di mascheramento dei m valori nella riga; il numero totale massimo di combinazioni per la riga è equivalente alla somma della riga m nel triangolo di Pascal, anche se possiamo scegliere di omettere alcune combinazioni che non sono utili per un determinato caso d’uso (ad esempio, la combinazione in cui tutti i valori sono mascherati). Il dataset mascherato finale avrebbe quindi al massimo n *(2^ m ) righe e m colonne. Sebbene la strategia esaustiva abbia il vantaggio di essere molto completa, potrebbe non essere molto praticabile nei casi in cui m sia grande, poiché il dataset mascherato risultante potrebbe essere troppo grande per la maggior parte dei computer da gestire facilmente oggi. Ad esempio, se il dataset originale ha solo 1000 righe e 50 colonne, il dataset mascherato in modo esaustivo avrebbe circa 10¹⁸ righe (cioè un quintilione di righe).

Mascheramento casuale

Come suggerisce il nome, questa strategia funziona mascherando i valori utilizzando una qualche funzione casuale. In una semplice implementazione, ad esempio, la decisione di mascherare ogni valore nel dataset potrebbe essere considerata come eventi di Bernoulli indipendenti con probabilità p di mascheramento. Il vantaggio ovvio della strategia di mascheramento casuale è che, a differenza del mascheramento esaustivo, la dimensione dei dati mascherati sarà gestibile. Tuttavia, specialmente per i piccoli dataset, al fine di ottenere un’accuratezza di imputazione sufficientemente alta, potrebbe essere necessario campionare maggiormente le righe del dataset di addestramento prima di applicare il mascheramento casuale in modo che più combinazioni di mascheramento siano riflesse nel dataset mascherato risultante.

Mascheramento basato sul dominio

Questa strategia mira ad applicare il mascheramento in modo da approssimare il modello di valori mancanti nella vita reale, cioè all’interno del dominio o del caso d’uso in cui verrà utilizzato l’imputatore. Per individuare questi modelli, può essere utile analizzare dati quantitativi osservazionali, nonché incorporare conoscenze da esperti del dominio.

Applicazioni pratiche

Gli imputatori basati sulla denoising, come quelli discussi in questo articolo, possono offrire un “via di mezzo” pragmatico nella pratica, dove altri approcci potrebbero essere troppo semplicistici o troppo complessi e dispendiosi in termini di risorse. Oltre al loro utilizzo nella pulizia dei dati come passaggio di pre-elaborazione in flussi di lavoro di apprendimento automatico più ampi, l’imputazione basata sulla denoising dei dati tabulari può essere potenzialmente utilizzata per guidare la funzionalità principale del prodotto in determinati casi d’uso pratici.

Un esempio di ciò è la compilazione assistita dall’IA dei moduli online nell’industria. Con la crescente digitalizzazione di vari processi aziendali, i moduli cartacei vengono sostituiti da versioni digitali online. Processi come l’invio di una domanda di lavoro, la creazione di una richiesta di acquisto, la prenotazione di un viaggio aziendale e la registrazione a eventi tipicamente comportano la compilazione di un modulo online di qualche tipo. Completare manualmente un tale modulo può essere noioso, richiedere molto tempo e potenzialmente soggetto a errori, soprattutto se il modulo ha molti campi da compilare. Tuttavia, con l’aiuto di un assistente IA, il compito di compilare un modulo online può essere reso molto più facile, veloce e accurato, fornendo raccomandazioni di input agli utenti in base alle informazioni contestuali disponibili. Ad esempio, quando un utente inizia a compilare alcuni campi nel modulo, l’assistente IA potrebbe inferire i valori più probabili per i campi rimanenti e suggerirli in tempo reale all’utente. Un caso d’uso del genere può essere facilmente formulato come un problema di imputazione basata sulla denoising, con output multipli, in cui i dati rumorosi/mascherati sono dati dallo stato attuale del modulo (con alcuni campi compilati e altri vuoti/mancanti) e l’obiettivo è prevedere i campi mancanti. Il modello può essere adattato secondo necessità per soddisfare vari requisiti del caso d’uso, inclusa l’accuratezza predittiva e il tempo di risposta end-to-end (percepito dall’utente).

Rilevanza nell’era dell’IA generativa e dei modelli di base

Con i recenti progressi nell’IA generativa e nei modelli di base – e la crescente consapevolezza del loro potenziale, anche tra il pubblico non tecnico, da quando ChatGPT è emerso sulla scena alla fine del 2022 – è lecito chiedersi quale rilevanza avranno gli imputatori basati sulla denoising in futuro. Ad esempio, i grandi modelli di linguaggio (LLM) potrebbero presumibilmente gestire compiti di imputazione per dati tabulari. Dopotutto, prevedere i token mancanti nelle frasi è un obiettivo di apprendimento tipico utilizzato per addestrare i LLM come il Bidirectional Encoder Representations from Transformers (BERT).

Tuttavia, è improbabile che gli imputatori basati sulla denoising – o altri approcci più semplici all’imputazione di dati tabulari che esistono oggi, per quella materia – diventeranno obsoleti nell’era dell’IA generativa e dei modelli di base nel prossimo futuro. Le ragioni di ciò possono essere apprezzate considerando la situazione alla fine degli anni 2010, momento in cui le reti neurali erano diventate opzioni tecnicamente fattibili ed economicamente sostenibili per diversi casi d’uso che in precedenza si basavano su algoritmi più semplici come le regressioni logistiche, gli alberi decisionali e le foreste casuali. Mentre le reti neurali hanno effettivamente sostituito questi altri algoritmi per alcuni casi d’uso di fascia alta in cui erano disponibili dati di addestramento sufficientemente ampi e il costo di addestramento e mantenimento delle reti neurali era considerato giustificabile, molti altri casi d’uso sono rimasti invariati. In effetti, la crescente facilità di accesso a risorse di archiviazione e calcolo più economiche che ha favorito l’adozione delle reti neurali ha beneficiato anche gli altri algoritmi più semplici. Da questo punto di vista, considerazioni come il costo, la complessità, la necessità di spiegabilità, i tempi di risposta rapidi per i casi d’uso in tempo reale e la minaccia di dipendere da un potenziale oligopolio di fornitori esterni di modelli preaddestrati, sembrano indicare un futuro in cui le innovazioni pragmatiche come gli imputatori basati sulla denoising per dati tabulari trovino un modo per coesistere in modo significativo con l’IA generativa e i modelli di base anziché essere sostituiti da essi.