TensorFlow Decision Forests ( TF-DF ) è una raccolta di algoritmi Decision Forest ( DF ) disponibili in TensorFlow. Le Decision Forests funzionano diversamente dalle Reti Neurali ( NN ): i DF generalmente non si addestrano con la backpropagation o in mini-batch. Pertanto, le pipeline TF-DF presentano alcune differenze rispetto alle altre pipeline TensorFlow.
Questo documento è un elenco di tali differenze e una guida per aggiornare le pipeline TF per utilizzare TF-DF
Questo documento presuppone la familiarità con la collaborazione per principianti .
Set di dati e funzionalità
Set di dati di convalida
A differenza del paradigma di addestramento della rete neurale standard, i modelli TF-DF non necessitano di un set di dati di convalida per monitorare l’overfitting o per interrompere anticipatamente l’addestramento. Se disponi già di una suddivisione treno/convalida/test e stai utilizzando la convalida per uno di questi motivi, è sicuro addestrare il tuo TF-DF su treno+convalida (a meno che la suddivisione di convalida non venga utilizzata anche per qualcos'altro, come ottimizzazione degli iperparametri).
- model.fit(train_ds, validation_data=val_ds)
+ model.fit(train_ds.concatenate(val_ds))
# Or just don't create a validation dataset
Motivazione: il framework TF-DF è composto da più algoritmi. Alcuni di essi non utilizzano un set di dati di validazione (ad esempio Random Forest) mentre altri lo fanno (ad esempio Gradient Boosted Trees). Gli algoritmi che lo fanno potrebbero trarre vantaggio da diversi tipi e dimensioni di set di dati di convalida. Pertanto, se è necessario un set di dati di convalida, verrà estratto automaticamente dal set di dati di addestramento.
I/O del set di dati
Allenati esattamente per 1 epoca
# Number of epochs in Keras
- model.fit(train_ds, num_epochs=5)
# Number of epochs in the dataset
- train_ds = train_ds.repeat(5)
- model.fit(train_ds)
+ model.fit(train_ds)
Motivazione: gli utenti delle reti neurali spesso addestrano un modello per N passaggi (che possono comportare il looping sul set di dati > 1 volta), a causa della natura di SGD . TF-DF si addestra leggendo l'intero set di dati ed eseguendo l'addestramento alla fine. È necessaria 1 epoca per leggere il set di dati completo e qualsiasi passaggio aggiuntivo comporterà I/O di dati non necessari, nonché un addestramento più lento.
Non mescolare il set di dati
Non è necessario mescolare i set di dati (a meno che input_fn non stia leggendo solo un campione del set di dati).
- train_ds = train_ds.shuffle(5)
- model.fit(train_ds)
+ model.fit(train_ds)
Motivazione: TF-DF mescola internamente l'accesso ai dati dopo aver letto l'intero set di dati in memoria. Gli algoritmi TF-DF sono deterministici (se l'utente non modifica il seme casuale). Abilitare la mescolanza renderà l'algoritmo non deterministico. Il mescolamento ha senso se il set di dati di input è ordinato e input_fn ne leggerà solo un campione (il campione dovrebbe essere casuale). Tuttavia, ciò renderà la procedura di addestramento non deterministica.
Non ottimizzare la dimensione del batch
La dimensione del lotto non influirà sulla qualità del modello
- train_ds = train_ds.batch(hyper_parameter_batch_size())
- model.fit(train_ds)
# The batch size does not matter.
+ train_ds = train_ds.batch(64)
+ model.fit(train_ds)
Motivazione: poiché TF-DF viene sempre addestrato sull'intero set di dati dopo la lettura, la qualità del modello non varierà in base alla dimensione del batch (a differenza degli algoritmi di addestramento mini-batch come SGD in cui parametri come la velocità di apprendimento devono essere ottimizzati congiuntamente). Pertanto dovrebbe essere rimosso dagli sweep degli iperparametri. La dimensione del batch avrà un impatto solo sulla velocità di I/O del set di dati.
Set di dati di grandi dimensioni
A differenza delle reti neurali, che possono eseguire cicli infinitamente mini-batch di un set di dati di grandi dimensioni, le foreste decisionali richiedono un set di dati finito che si adatti alla memoria per le loro procedure di addestramento. La dimensione del set di dati ha implicazioni sulle prestazioni e sulla memoria.
Aumentando la dimensione del set di dati si ottengono rendimenti decrescenti e gli algoritmi DF necessitano probabilmente di meno esempi di convergenza rispetto ai modelli NN di grandi dimensioni. Invece di ridimensionare il numero di passaggi di training (come in una NN), puoi provare a ridimensionare la quantità di dati per vedere dove ha senso il compromesso di calcolo. Pertanto, è una buona idea provare prima l'addestramento su un (piccolo) sottoinsieme del set di dati.
La soluzione alternativa è utilizzare la formazione distribuita . L'addestramento distribuito è un ottimo modo per aumentare le dimensioni del set di dati se sono disponibili più macchine. Sebbene tutti gli algoritmi distribuiti siano disponibili per distribuire il calcolo, non tutti sono in grado di distribuire l'utilizzo della RAM. Controlla la documentazione per maggiori dettagli.
Quanti esempi usare
Dovrebbe adattarsi alla memoria della macchina su cui il modello si sta allenando :
Tieni presente che questa non è la stessa dimensione degli esempi su disco.
Come regola generale, un valore numerico o categoriale utilizza 4 byte di memoria. Pertanto, un set di dati con 100 funzionalità e 25 milioni di esempi richiederà circa 10 GB (= 100 * 25 *10^6 * 4 byte) di memoria.
Le funzionalità impostate per categoria (ad esempio il testo tokenizzato) richiedono più memoria (4 byte per token + 12 byte per funzionalità).
Considera il budget del tuo tempo di formazione
Sebbene generalmente più veloci di NN per set di dati più piccoli (ad esempio <100.000 esempi), gli algoritmi di training DF non si adattano linearmente alla dimensione del set di dati; piuttosto, ~O(feature x num_examples x log(num_examples)) nella maggior parte dei casi.
Il tempo di addestramento dipende dagli iperparametri. I parametri di maggiore impatto sono: (1) il numero di alberi (
num_trees), (2) la frequenza di campionamento dell'esempio (subsamplefor GBT) e (3) la frequenza di campionamento degli attributi (num_candidate_attributes_ratio)Le funzionalità del set categoriale sono più costose di altre funzionalità. Il costo è controllato dal parametro
categorical_set_split_greedy_sampling.Le funzionalità sparse oblique (disabilitate per impostazione predefinita) forniscono buoni risultati ma sono costose da calcolare.
Regole pratiche per l'aumento dei dati
Suggeriamo di iniziare con una piccola porzione di dati (<10.000 esempi), che dovrebbe consentire di addestrare un modello TF-DF in pochi secondi o in pochi minuti nella maggior parte dei casi. Successivamente è possibile aumentare i dati a un ritmo fisso (ad esempio il 40% in più ogni volta), fermandosi quando le prestazioni del set di convalida non migliorano o il set di dati non entra più in memoria.
Normalizzazione/preelaborazione delle funzionalità
Non trasformare i dati con colonne di funzionalità
I modelli TF-DF non richiedono di fornire esplicitamente la semantica e le trasformazioni delle funzionalità. Per impostazione predefinita, tutte le funzionalità nel set di dati (diverse dall'etichetta) verranno rilevate e utilizzate dal modello. La semantica della funzionalità verrà rilevata automaticamente e, se necessario, potrà essere sovrascritta manualmente.
# Estimator code
- feature_columns = [
- tf.feature_column.numeric_column(feature_1),
- tf.feature_column.categorical_column_with_vocabulary_list(feature_2, ['First', 'Second', 'Third'])
- ]
- model = tf.estimator.LinearClassifier(feature_columns=feature_columnes)
# Use all the available features. Detect the type automatically.
+ model = tfdf.keras.GradientBoostedTreesModel()
Puoi anche specificare un sottoinsieme di funzionalità di input:
+ features = [
+ tfdf.keras.FeatureUsage(name="feature_1"),
+ tfdf.keras.FeatureUsage(name="feature_2")
+ ]
+ model = tfdf.keras.GradientBoostedTreesModel(features=features, exclude_non_specified_features=True)
Se necessario, puoi forzare la semantica di una funzionalità.
+ forced_features = [
+ tfdf.keras.FeatureUsage(name="feature_1", semantic=tfdf.keras.FeatureSemantic.CATEGORICAL),
+ ]
+ model = tfdf.keras.GradientBoostedTreesModel(features=features)
Motivazione: mentre alcuni modelli (come le reti neurali) richiedono un livello di input standardizzato (ad esempio mappature da diversi tipi di funzionalità → incorporamenti), i modelli TF-DF possono utilizzare funzionalità categoriche e numeriche in modo nativo, nonché rilevare automaticamente i tipi semantici delle funzionalità sulla base dei dati.
Non preelaborare le funzionalità
Gli algoritmi dell'albero decisionale non beneficiano di alcune delle classiche funzionalità di preelaborazione utilizzate per le reti neurali. Di seguito, alcune delle strategie di elaborazione delle funzionalità più comuni sono elencate esplicitamente, ma un punto di partenza sicuro è rimuovere tutta la pre-elaborazione progettata per facilitare l'addestramento della rete neurale.
Non normalizzare le caratteristiche numeriche
- def zscore(value):
- return (value-mean) / sd
- feature_columns = [tf.feature_column.numeric_column("feature_1",normalizer_fn=zscore)]
Razionale: gli algoritmi della foresta decisionale supportano nativamente caratteristiche numeriche non normalizzate, poiché gli algoritmi di suddivisione non eseguono alcuna trasformazione numerica dell'input. Alcuni tipi di normalizzazione (ad esempio la normalizzazione del punteggio z) non aiuteranno la stabilità numerica della procedura di addestramento, mentre altri (ad esempio il ritaglio anomalo) potrebbero danneggiare l'espressività del modello finale.
Non codificare caratteristiche categoriche (ad esempio hashing, one-hot o incorporamento)
- integerized_column = tf.feature_column.categorical_column_with_hash_bucket("feature_1",hash_bucket_size=100)
- feature_columns = [tf.feature_column.indicator_column(integerized_column)]
- integerized_column = tf.feature_column.categorical_column_with_vocabulary_list('feature_1', ['bob', 'george', 'wanda'])
- feature_columns = [tf.feature_column.indicator_column(integerized_column)]
Motivazione: TF-DF ha il supporto nativo per le funzionalità categoriche e tratterà un elemento del vocabolario "trasformato" come un semplice elemento nel suo vocabolario interno (che può essere configurato tramite gli iperparametri del modello). Alcune trasformazioni (come l'hashing) possono comportare perdite. Gli incorporamenti non sono supportati a meno che non siano pre-addestrati, poiché i modelli Decision Forest non sono differenziabili (vedi colab intermedio ). Tieni presente che le strategie di vocabolario specifiche del dominio (ad esempio rimozione di stopword, normalizzazione del testo) possono comunque essere utili.
Come gestire le funzionalità del testo
TF-DF supporta nativamente le funzionalità del set di categorie . Pertanto, i sacchi di n-grammi tokenizzati possono essere consumati in modo nativo.
In alternativa, il testo può anche essere utilizzato tramite un incorporamento pre-addestrato .
I set categoriali sono efficienti in termini di campioni su set di dati di piccole dimensioni, ma costosi da addestrare su set di dati di grandi dimensioni. La combinazione di set di categorie e incorporamento pre-addestrato può spesso produrre risultati migliori rispetto all'utilizzo di uno dei due da solo.
Non sostituire le caratteristiche mancanti con valori magici
Motivazione: TF-DF ha il supporto nativo per i valori mancanti. A differenza delle reti neurali, che possono propagare i NaN ai gradienti se sono presenti NaN nell'input, TF-DF si addestrerà in modo ottimale se l'algoritmo rileva la differenza tra un valore mancante e un valore sentinella.
- feature_columns = [
- tf.feature_column.numeric_column("feature_1", default_value=0),
- tf.feature_column.numeric_column("feature_1_is_missing"),
- ]
Gestione di immagini e serie temporali
Non esiste un algoritmo standard per l'utilizzo di funzionalità di immagini o serie temporali in Decision Forests, pertanto per utilizzarle è necessario del lavoro aggiuntivo.
Motivazione: Convoluzione, LSTM, attenzione e altri algoritmi di elaborazione di sequenze sono architetture specifiche della rete neurale.
È possibile gestire queste funzionalità utilizzando le seguenti strategie:
Ingegneria delle caratteristiche
Immagini: l'uso delle immagini con Random Forest era popolare ad un certo punto (ad es
Microsoft Kinect , ma oggi le reti neurali sono all'avanguardia.
Serie temporali: [ Le statistiche in movimento ] possono funzionare sorprendentemente bene per i dati di serie temporali che hanno relativamente pochi esempi (ad esempio, i segni vitali in ambito medico).
Moduli di incorporamento: i moduli di incorporamento della rete neurale possono fornire funzionalità avanzate per un algoritmo della foresta decisionale. La collaborazione intermedia mostra come combinare un incorporamento tf-hub e un modello TF-DF.
Condotto di formazione
Non utilizzare acceleratori hardware, ad esempio GPU, TPU
La formazione TF-DF non supporta (ancora) gli acceleratori hardware. Tutto l'addestramento e l'inferenza vengono eseguiti sulla CPU (a volte utilizzando SIMD).
Si noti che l'inferenza TF-DF sulla CPU (specialmente se servita utilizzando le librerie C++ Yggdrasil) può essere sorprendentemente veloce (meno di un microsecondo per esempio per core della CPU).
Non utilizzare checkpoint o hook a metà allenamento
TF-DF non supporta (attualmente) il checkpoint del modello, il che significa che gli hook che prevedono che il modello sia utilizzabile prima del completamento dell'addestramento non sono in gran parte supportati. Il modello sarà disponibile solo dopo aver addestrato il numero di alberi richiesto (o fermato prima).
Anche i ganci Keras che si basano sulla fase di addestramento non funzioneranno: a causa della natura dell'addestramento TF-DF, il modello si addestra alla fine della prima epoca e sarà costante dopo quell'epoca. Il passaggio corrisponde solo all'I/O del set di dati.
Determinismo del modello
L'algoritmo di addestramento TF-DF è deterministico, ovvero l'addestramento due volte sullo stesso set di dati fornirà esattamente lo stesso modello. Questo è diverso dalle reti neurali addestrate con TensorFlow. Per preservare questo determinismo, gli utenti dovrebbero garantire che anche le letture dei set di dati siano deterministiche.
Configurazione dell'allenamento
Specificare un compito (ad esempio classificazione, classificazione) invece di una perdita (ad esempio entropia incrociata binaria)
- model = tf_keras.Sequential()
- model.add(Dense(64, activation=relu))
- model.add(Dense(1)) # One output for binary classification
- model.compile(loss=tf_keras.losses.BinaryCrossentropy(from_logits=True),
- optimizer='adam',
- metrics=['accuracy'])
# The loss is automatically determined from the task.
+ model = tfdf.keras.GradientBoostedTreesModel(task=tf_keras.Task.CLASSIFICATION)
# Optional if you want to report the accuracy.
+ model.compile(metrics=['accuracy'])
Motivazione: non tutti gli algoritmi di apprendimento TF-DF utilizzano una perdita. Per coloro che lo fanno, la perdita viene rilevata automaticamente dall'attività e stampata nel riepilogo del modello. Puoi anche sovrascriverlo con l'iperparametro di perdita.
Gli iperparametri sono semanticamente stabili
Tutti gli iperparametri hanno valori predefiniti. Questi valori sono i primi candidati ragionevoli da provare. È garantito che i valori predefiniti degli iperparametri non cambieranno mai. Per questo motivo, i nuovi iperparametri o i miglioramenti dell'algoritmo sono disabilitati per impostazione predefinita.
Gli utenti che desiderano utilizzare gli algoritmi più recenti, ma che non vogliono ottimizzare gli iperparametri stessi, possono utilizzare i "modelli di iperparametri" forniti da TF-DF. Verranno rilasciati nuovi modelli di iperparametri con aggiornamenti al pacchetto.
# Model with default hyper-parameters.
model = tfdf.keras.GradientBoostedTreesModel()
# List the hyper-parameters (with default value) and hyper-parameters templates of the GBT learning algorithm (in colab)
?tfdf.keras.GradientBoostedTreesModel
# Use a hyper-parameter template.
model = tfdf.keras.GradientBoostedTreesModel(hp_template="winner_1")
# Change one of the hyper-parameters.
model = tfdf.keras.GradientBoostedTreesModel(num_trees=500)
# List all the learning algorithms available
tfdf.keras.get_all_models()
Debug del modello
Questa sezione presenta alcuni modi in cui puoi visualizzare/debug/interpretare il modello. La collaborazione per principianti contiene un esempio end-to-end.
Riepilogo semplice del modello
# Text description of the model, training logs, feature importances, etc.
model.summary()
Registri di allenamento e Tensorboard
# List of metrics
logs = model.make_inspector().training_logs()
print(logs)
Oppure utilizzando TensorBoard:
% load_ext
tensorboard
model.make_inspector().export_to_tensorboard("/tmp/tensorboard_logs")
% tensorboard - -logdir
"/tmp/tensorboard_logs"
Importanza delle caratteristiche
model.make_inspector().variable_importances()
Tracciare gli alberi
tfdf.model_plotter.plot_model_in_colab(model, tree_idx=0)
Accedi alla struttura ad albero
tree = model.make_inspector().extract_tree(tree_idx=0)
print(tree)
(Vedi collaborazione avanzata )
Non utilizzare strategie di distribuzione TensorFlow
TF-DF non supporta ancora le strategie di distribuzione TF. Le configurazioni con più lavoratori verranno ignorate e la formazione avverrà solo sul manager.
- with tf.distribute.MirroredStrategy():
- model = ...
+ model = ....
Modelli impilabili
I modelli TF-DF non propagano all'indietro i gradienti. Di conseguenza, non possono essere composti con modelli NN a meno che gli NN non siano già addestrati.
Migrazione da tf.estimator.BoostedTrees {Classificatore/Regressore/Estimatore}
Nonostante sembrino simili, gli alberi potenziati TF-DF e Estimator sono algoritmi diversi. TF-DF implementa le classiche carte Random Forest e Gradient Boosted Machine (utilizzando Trees) . tf.estimator.BoostedTreesEstimator è un algoritmo approssimativo di Gradient Boosted Trees con una procedura di training mini-batch descritta in questo documento
Alcuni iperparametri hanno una semantica simile (ad esempio num_trees), ma hanno implicazioni di qualità diverse. Se hai ottimizzato gli iperparametri sul tuo tf.estimator.BoostedTreesEstimator, dovrai ottimizzare gli iperparametri all'interno di TF-DF per ottenere risultati ottimali.
Per gli utenti di Yggdrasil
Yggdrasil Decision Forest è la libreria principale di training e inferenza utilizzata da TF-DF. La configurazione e i modelli di addestramento sono cross-compatibili (ovvero i modelli addestrati con TF-DF possono essere utilizzati con l'inferenza Yggdrasil).
Tuttavia, alcuni degli algoritmi Yggdrasil non sono (ancora) disponibili in TF-DF.
- Albero con gradiente potenziato con campionamento frammentato.