1. Panoramica
In questo lab, importerai direttamente un set di dati BigQuery e addestrerai un modello di rilevamento delle frodi con TensorFlow Enterprise su Google Cloud AI Platform.
Cosa imparerai
Al termine del corso sarai in grado di:
- Analizzare i dati su BigQuery
- Importare dati utilizzando il connettore BigQuery in TensorFlow Enterprise
- Crea un modello di deep learning per rilevare le frodi con un set di dati sbilanciato
2. Analizza i dati in BigQuery
Per eseguire questo codelab, devi avere un progetto Google Cloud Platform con la fatturazione abilitata. Per creare un progetto, segui le istruzioni riportate qui.
Passaggio 1: accedi al set di dati pubblico BigQuery
Segui questo link per accedere ai set di dati pubblici BigQuery nella console Google Cloud.
Nell'albero delle risorse nell'angolo in basso a sinistra, vedrai un elenco di set di dati. Scorri i set di dati disponibili finché non trovi ml-datasets, quindi seleziona la tabella ulb-fraud-detection al suo interno:
Fai clic su ciascuna scheda per scoprire di più sul set di dati:
- La scheda Schema descrive i tipi di dati.
- La scheda Dettagli spiega che si tratta di un set di dati sbilanciato con 284.407 transazioni, di cui 492 fraudolente.
- La scheda Anteprima mostra i record del set di dati.
Passaggio 2: esegui una query sulla tabella
La scheda Dettagli ci dice questo sui dati:
- Tempo è il numero di secondi tra la prima transazione nel set di dati e l'ora della transazione selezionata.
- V1-V28 sono colonne che sono state trasformate tramite una tecnica di riduzione della dimensionalità chiamata PCA che ha anonimizzato i dati.
- Importo è l'importo della transazione.
Diamo un'occhiata più da vicino facendo clic su Query su tabella per eseguire una query:
Aggiorna l'istruzione per aggiungere un asterisco (*) per visualizzare tutte le colonne e fai clic su Esegui.
SELECT * FROM `bigquery-public-data.ml_datasets.ulb_fraud_detection` LIMIT 1000
Passaggio 3: analizza i dati
BigQuery fornisce una serie di funzioni statistiche. Diamo un'occhiata a come i dati sono correlati alla variabile target Classe.
SELECT CORR(Time,Class) as TimeCorr, CORR(V1,Class) as V1Corr, CORR(V2,Class) as V2Corr, CORR(Amount,Class) as AmountCorr FROM `bigquery-public-data.ml_datasets.ulb_fraud_detection`
La correlazione fornirà un intervallo da -1 (correlazione negativa) a 1 (correlazione positiva), con 0 che indica l'indipendenza.
Tieni presente che V1 e V2 hanno una leggera correlazione con la nostra variabile target (rispettivamente circa -0,1 e 0,1).
Non vediamo molta correlazione con Time. Una correlazione leggermente negativa potrebbe indicare che nel set di dati si verificano meno transazioni fraudolente nel tempo.
Importo ha una correlazione ancora più bassa, il che indica che le transazioni fraudolente sono leggermente più probabili per importi più elevati.
Passaggio 4: calcola i valori medi per il ridimensionamento delle caratteristiche
La normalizzazione dei valori delle caratteristiche può aiutare una rete neurale a convergere più rapidamente. Un sistema comune è quello di centrare i valori intorno a 0 con una deviazione standard di 1. La seguente query recupererà i valori medi. Il salvataggio del risultato non è necessario, in quanto avremo uno snippet di codice per questo in un secondo momento.
Noterai anche che la query include una clausola WHERE interessante. Lo descriveremo nella sezione successiva, quando parleremo di come suddividere i dati tra i set di addestramento e test.
SELECT
AVG(Time), AVG(V1), AVG(V2), AVG(V3), AVG(V4), AVG(V5), AVG(V6), AVG(V7), AVG(V8),
AVG(V9), AVG(V10),AVG(V11), AVG(V12), AVG(V13), AVG(V14), AVG(V15), AVG(V16),
AVG(V17), AVG(V18), AVG(V19), AVG(V20), AVG(V21), AVG(V22), AVG(V23), AVG(V24),
AVG(V25), AVG(V26), AVG(V27),AVG(V28), AVG(Amount)
FROM
`bigquery-public-data.ml_datasets.ulb_fraud_detection`
WHERE
MOD(ABS(FARM_FINGERPRINT(CONCAT(SAFE_CAST(Time AS STRING),
SAFE_CAST(Amount AS STRING)))),10) < 8
Passaggio 5: dividi i dati
È prassi comune utilizzare tre set di dati durante la creazione di un modello di machine learning:
- Addestramento: utilizzato per creare il modello modificando iterativamente i parametri
- Convalida: utilizzata per valutare se il modello è in overfitting verificando i dati indipendenti durante il processo di addestramento
- Test: utilizzato dopo la creazione del modello per valutarne l'accuratezza
In questo codelab, utilizzeremo una suddivisione di addestramento/convalida/test di 80/10/10.
Inseriremo ogni set di dati in una tabella separata in BigQuery. Il primo passaggio consiste nel creare un "set di dati" BigQuery, ovvero un contenitore per le tabelle correlate. Con il progetto selezionato, seleziona Crea set di dati.
Poi, crea un set di dati denominato tfe_codelab che contenga le tabelle di addestramento, convalida e test.
Ora eseguiamo tre query per l'addestramento, il test e la convalida e salviamo i dati nel nuovo set di dati tfe_codelab.
Nell'editor delle query, esegui una query per generare i dati di addestramento:
SELECT *
FROM `bigquery-public-data.ml_datasets.ulb_fraud_detection`
WHERE MOD(ABS(FARM_FINGERPRINT(CONCAT(SAFE_CAST(Time AS STRING),SAFE_CAST(Amount AS STRING)))),10) < 8
Al termine della query, salva i risultati in una tabella BigQuery.
All'interno del set di dati tfe_codelab che hai appena creato, assegna alla tabella il nome ulb_fraud_detection_train e salva i dati.
La clausola WHERE suddivide innanzitutto i dati calcolando un hash su alcune colonne. Poi, seleziona le righe in cui il resto dell'hash diviso per 10 è inferiore a 80, ottenendo l'80%.
Ora ripetiamo la stessa procedura per i set di convalida e di test con query simili che selezionano il 10% dei dati ciascuno.
Convalida
SELECT *
FROM `bigquery-public-data.ml_datasets.ulb_fraud_detection`
WHERE MOD(ABS(FARM_FINGERPRINT(CONCAT(SAFE_CAST(Time AS STRING),SAFE_CAST(Amount AS STRING)))),10) = 8
Salva i risultati di questa query in una tabella denominata ulb_fraud_detection_val.
Test
SELECT *
FROM `bigquery-public-data.ml_datasets.ulb_fraud_detection`
WHERE MOD(ABS(FARM_FINGERPRINT(CONCAT(SAFE_CAST(Time AS STRING),SAFE_CAST(Amount AS STRING)))),10) = 9
Salva i risultati di questa query in una tabella denominata ulb_fraud_detection_test.
3. Configura l'ambiente del blocco note
Ora che abbiamo esaminato una breve introduzione ai dati, configuriamo l'ambiente di sviluppo del modello.
Passaggio 1: attiva le API
Il connettore BigQuery utilizza l'API BigQuery Storage. Cerca l'API BigQuery Storage nella console e abilita l'API se è attualmente disabilitata.
Passaggio 2: crea un'istanza di AI Platform Notebooks
Vai alla sezione AI Platform Notebooks della tua console Cloud e fai clic su Nuova istanza. Poi seleziona il tipo di istanza TensorFlow Enterprise 1.x più recente senza GPU:
Utilizza le opzioni predefinite e poi fai clic su Crea. Una volta creata l'istanza, seleziona Apri JupyterLab:
Poi, crea un notebook Python 3 da JupyterLab:
4. Importare record da BigQuery
Passaggio 1: importa i pacchetti Python
Nella prima cella del notebook, aggiungi le seguenti importazioni ed esegui la cella. Puoi eseguirlo premendo il pulsante Freccia destra nel menu in alto o premendo Comando-Invio:
import tensorflow as tf
import tensorflow.keras as keras
import tensorflow.keras.layers as layers
from tensorflow_io.bigquery import BigQueryClient
import functools
tf.enable_eager_execution()
Passaggio 2: definisci le costanti
Definiamo ora alcune costanti da utilizzare nel progetto. Modifica GCP_PROJECT_ID con l'ID progetto effettivo che stai utilizzando. Esegui le nuove celle man mano che le crei.
GCP_PROJECT_ID = '<YOUR_PROJECT_ID>'
DATASET_GCP_PROJECT_ID = GCP_PROJECT_ID # A copy of the data is saved in the user project
DATASET_ID = 'tfe_codelab'
TRAIN_TABLE_ID = 'ulb_fraud_detection_train'
VAL_TABLE_ID = 'ulb_fraud_detection_val'
TEST_TABLE_ID = 'ulb_fraud_detection_test'
FEATURES = ['Time','V1','V2','V3','V4','V5','V6','V7','V8','V9','V10','V11','V12','V13','V14','V15','V16','V17','V18','V19','V20','V21','V22','V23','V24','V25','V26','V27','V28','Amount']
LABEL='Class'
DTYPES=[tf.float64] * len(FEATURES) + [tf.int64]
Passaggio 3: definisci le funzioni di assistenza
Ora definiamo un paio di funzioni. read_session() legge i dati da una tabella BigQuery. extract_labels() è una funzione helper per separare la colonna delle etichette dal resto, in modo che il set di dati sia nel formato previsto da keras.model_fit() in un secondo momento.
client = BigQueryClient()
def read_session(TABLE_ID):
return client.read_session(
"projects/" + GCP_PROJECT_ID, DATASET_GCP_PROJECT_ID, TABLE_ID, DATASET_ID,
FEATURES + [LABEL], DTYPES, requested_streams=2
)
def extract_labels(input_dict):
features = dict(input_dict)
label = tf.cast(features.pop(LABEL), tf.float64)
return (features, label)
Passaggio 4: importa i dati
Infine, creiamo ogni set di dati e stampiamo il primo batch dal set di dati di addestramento. Tieni presente che abbiamo definito un BATCH_SIZE di 32. Si tratta di un parametro importante che influirà sulla velocità e sull'accuratezza dell'addestramento.
BATCH_SIZE = 32
raw_train_data = read_session(TRAIN_TABLE_ID).parallel_read_rows().map(extract_labels).batch(BATCH_SIZE)
raw_val_data = read_session(VAL_TABLE_ID).parallel_read_rows().map(extract_labels).batch(BATCH_SIZE)
raw_test_data = read_session(TEST_TABLE_ID).parallel_read_rows().map(extract_labels).batch(BATCH_SIZE)
next(iter(raw_train_data)) # Print first batch
5. Crea il modello
Passaggio 1: pre-elabora i dati
Creiamo colonne delle caratteristiche per ogni caratteristica del set di dati. In questo set di dati specifico, tutte le colonne sono di tipo numeric_column,ma esistono diversi altri tipi di colonne (ad es. categorical_column).
Come abbiamo detto in precedenza, normalizzeremo anche i dati in modo che siano centrati sullo zero, in modo che la rete converga più rapidamente. Abbiamo precalcolato le medie di ogni funzionalità da utilizzare in questo calcolo.
MEANS = [94816.7387536405, 0.0011219465482001268, -0.0021445914636999603, -0.002317402958335562,
-0.002525792169927835, -0.002136576923287782, -3.7586818983702984, 8.135919975738768E-4,
-0.0015535579268265718, 0.001436137140461279, -0.0012193712736681508, -4.5364970422902533E-4,
-4.6175444671576083E-4, 9.92177789685366E-4, 0.002366229151475428, 6.710217226762278E-4,
0.0010325807119864225, 2.557260815835395E-4, -2.0804190062322664E-4, -5.057391100818653E-4,
-3.452114767842334E-6, 1.0145936326270006E-4, 3.839214074518535E-4, 2.2061197469126577E-4,
-1.5601580596677608E-4, -8.235017846415852E-4, -7.298316615408554E-4, -6.898459943652376E-5,
4.724125688297753E-5, 88.73235686453587]
def norm_data(mean, data):
data = tf.cast(data, tf.float32) * 1/(2*mean)
return tf.reshape(data, [-1, 1])
numeric_columns = []
for i, feature in enumerate(FEATURES):
num_col = tf.feature_column.numeric_column(feature, normalizer_fn=functools.partial(norm_data, MEANS[i]))
numeric_columns.append(num_col)
numeric_columns
Passaggio 2: crea il modello
Ora siamo pronti per creare un modello. Inseriremo le colonne appena create nella rete. Poi compileremo il modello. Stiamo includendo la metrica AUC precisione/richiamo, che è utile per i set di dati sbilanciati.
model = keras.Sequential([
tf.keras.layers.DenseFeatures(numeric_columns),
layers.Dense(64, activation='relu'),
layers.Dense(64, activation='relu'),
layers.Dense(1, activation='sigmoid')
])
model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy', tf.keras.metrics.AUC(curve='PR')])
Passaggio 3: addestra il modello
Esistono diverse tecniche per gestire i dati sbilanciati, tra cui l'oversampling (generazione di nuovi dati nella classe di minoranza) e il sottocampionamento (riduzione dei dati nella classe di maggioranza).
Ai fini di questo codelab, utilizziamo una tecnica che assegna un peso maggiore alla perdita in caso di classificazione errata della classe minoritaria. Specificheremo un parametro class_weight durante l'addestramento e assegneremo un peso "1" (frode) più elevato, poiché è molto meno prevalente.
In questo lab utilizzeremo 3 epoche (passaggi attraverso i dati) in modo che l'addestramento sia più rapido. In uno scenario reale, vorremmo eseguirlo abbastanza a lungo fino a quando non si vedono più aumenti di accuratezza del set di convalida.
CLASS_WEIGHT = {
0: 1,
1: 100
}
EPOCHS = 3
train_data = raw_train_data.shuffle(10000)
val_data = raw_val_data
test_data = raw_test_data
model.fit(train_data, validation_data=val_data, class_weight=CLASS_WEIGHT, epochs=EPOCHS)
Passaggio 4: valuta il modello
La funzione evaluate() può essere applicata ai dati di test che il modello non ha mai visto per fornire una valutazione oggettiva. Fortunatamente, abbiamo messo da parte i dati di test proprio per questo scopo.
model.evaluate(test_data)
Passaggio 5: esplorazione
In questo lab abbiamo mostrato come importare un set di dati di grandi dimensioni da BigQuery direttamente in un modello TensorFlow Keras. Abbiamo anche esaminato tutti i passaggi per creare un modello. Infine, abbiamo imparato qualcosa su come gestire i problemi di classificazione sbilanciata.
Continua a sperimentare con diverse architetture e approcci al set di dati sbilanciato per vedere se riesci a migliorare l'accuratezza.
6. Esegui la pulizia
Se vuoi continuare a utilizzare questo notebook, ti consigliamo di disattivarlo quando non lo usi. Dall'interfaccia utente di Notebooks nella console Cloud, seleziona il notebook, quindi seleziona Interrompi:
Se vuoi eliminare tutte le risorse che hai creato in questo lab, elimina l'istanza del notebook anziché arrestarla.
Utilizzando il menu di navigazione della console Cloud, vai a Storage ed elimina entrambi i bucket creati per archiviare gli asset del modello.