Tutorial sulla regressione lineare con TensorFlow [Esempi]
Evelyn Clarke
Che cos'è la regressione lineare?
Regressione lineare è un approccio statistico per modellare le relazioni tra due variabili. Questa modellazione viene eseguita tra una risposta scalare e una o più variabili esplicative. La relazione con una variabile esplicativa è chiamata regressione lineare semplice e per più variabili esplicative è chiamata regressione lineare multipla.
TensorFlow fornisce strumenti per avere il pieno controllo dei calcoli. Questo viene fatto con l'API di basso livello. Oltre a ciò, TensorFlow è dotato di una vasta gamma di API per eseguirne molte machine learning algoritmi. Questa è l'API di alto livello. TensorFlow li chiama stimatori
- API di basso livello: Costruire l'architettura, ottimizzare il modello da zero. È complicato per un principiante
- API di alto livello: Definisci l'algoritmo. È facile da usare. TensorFlow fornisce una cassetta degli attrezzi chiamata estimatore costruire, addestrare, valutare e fare una previsione.
In questo tutorial utilizzerai il file solo estimatori. I calcoli sono più veloci e più facili da implementare. La prima parte del tutorial spiega come utilizzare l'ottimizzatore della discesa del gradiente per addestrare una regressione lineare in TensorFlow. In una seconda parte, utilizzerai il set di dati di Boston per prevedere il prezzo di una casa utilizzando lo stimatore TensorFlow.
Come addestrare un modello di regressione lineare
Prima di iniziare ad addestrare il modello, diamo un'occhiata a cos'è una regressione lineare.
Immagina di avere due variabili, x e y e il tuo compito è prevedere il valore di conoscendo il valore di . Se rappresenti graficamente i dati, puoi vedere una relazione positiva tra la tua variabile indipendente, x e la tua variabile dipendente y.
Puoi osservare che se x=1,y sarà all'incirca uguale a 6 e se x=2,y sarà circa 8.5.
Questo non è un metodo molto accurato ed è soggetto a errori, soprattutto con un set di dati con centinaia di migliaia di punti.
Una regressione lineare viene valutata con un'equazione. La variabile y è spiegata da una o più covariate. Nel tuo esempio, c'è solo una variabile dipendente. Se devi scrivere questa equazione, sarà:
con:
è il pregiudizio. cioè se x=0, y=
è il peso associato a x
è il residuo o l'errore del modello. Include ciò che il modello non può apprendere dai dati
Immagina di adattare il modello e di trovare la seguente soluzione per:
- = 3.8
- = 2.78
Puoi sostituire quei numeri nell'equazione e diventa:
y= 3.8 + 2.78x
Ora hai un modo migliore per trovare i valori di y. Cioè, puoi sostituire x con qualsiasi valore tu voglia prevedere y. Nell'immagine seguente, abbiamo sostituito x nell'equazione con tutti i valori nel set di dati e tracciato il risultato.
La linea rossa rappresenta il valore adattato, ovvero i valori di y per ciascun valore di x. Non è necessario vedere il valore di x per prevedere y, per ogni x ce n'è uno che appartiene alla linea rossa. Puoi anche prevedere valori di x superiori a 2!
Se desideri estendere la regressione lineare a più covariate, puoi farlo aggiungendo più variabili al modello. La differenza tra l'analisi tradizionale e la regressione lineare è che la regressione lineare esamina come reagirà y per ciascuna variabile x presa indipendentemente.
Vediamo un esempio. Immagina di voler prevedere le vendite di una gelateria. Il set di dati contiene diverse informazioni come il tempo (cioè piovoso, soleggiato, nuvoloso), informazioni sul cliente (cioè stipendio, sesso, stato civile).
L'analisi tradizionale proverà a prevedere la vendita, ad esempio calcolando la media per ciascuna variabile, e proverà a stimare la vendita per diversi scenari. Ciò porterà a previsioni inadeguate e limiterà l’analisi allo scenario scelto.
Se usi la regressione lineare, puoi scrivere questa equazione:
L'algoritmo troverà la soluzione migliore per i pesi; significa che cercherà di minimizzare il costo (la differenza tra la linea montata e i punti dati).
Come funziona l'algoritmo
L'algoritmo sceglierà un numero casuale per ciascuno 
che a 
e sostituire il valore di x per ottenere il valore previsto di y. Se il set di dati contiene 100 osservazioni, l'algoritmo calcola 100 valori previsti.
Possiamo calcolare l'errore, notato 
del modello, che è la differenza tra il valore previsto e il valore reale. Un errore positivo significa che il modello sottostima la previsione di y, mentre un errore negativo significa che il modello sovrastima la previsione di y.
Il tuo obiettivo è ridurre al minimo il quadrato dell'errore. L'algoritmo calcola la media dell'errore quadrato. Questo passaggio è chiamato minimizzazione dell’errore. Per la regressione lineare è il Errore quadratico medio, detto anche MSE. Matematicamente è:
Dove:
i pesi sono così? 
si riferisce al valore previsto- y sono i valori reali
- m è il numero di osservazioni
si riferisce al valore previstoSi noti che 
significa che utilizza la trasposizione delle matrici. IL 
è la notazione matematica della media.
L'obiettivo è trovare il meglio 
che minimizzano il MSE
Se l’errore medio è elevato, significa che il modello funziona male e i pesi non sono scelti correttamente. Per correggere i pesi è necessario utilizzare un ottimizzatore. Si chiama l'ottimizzatore tradizionale Discesa a gradiente.
La discesa del gradiente fa la derivata e diminuisce o aumenta il peso. Se la derivata è positiva il peso viene diminuito. Se la derivata è negativa il peso aumenta. Il modello aggiornerà i pesi e ricalcolerà l'errore. Questo processo viene ripetuto finché l'errore non cambia più. Ogni processo è chiamato an iterazione. Inoltre, i gradienti vengono moltiplicati per un tasso di apprendimento. Indica la velocità dell'apprendimento.
Se il tasso di apprendimento è troppo piccolo, ci vorrà molto tempo perché l'algoritmo converga (ovvero richiede molte iterazioni). Se il tasso di apprendimento è troppo alto, l’algoritmo potrebbe non convergere mai.
Come puoi vedere dall'immagine sopra, il modello ripete il processo circa 20 volte prima di trovare un valore stabile per i pesi, raggiungendo quindi l'errore più basso.
Si noti che, l'errore non è uguale a zero ma si stabilizza attorno a 5. Ciò significa che il modello commette un errore tipico pari a 5. Se si desidera ridurre l'errore, è necessario aggiungere ulteriori informazioni al modello come più variabili o utilizzare stimatori diversi .
Ricordi la prima equazione
I pesi finali sono 3.8 e 2.78. Il video qui sotto mostra come la discesa del gradiente ottimizza la funzione di perdita per trovare questi pesi
Come addestrare una regressione lineare con TensorFlow
Ora che hai una migliore comprensione di ciò che accade dietro le quinte, sei pronto per utilizzare l'API di stima fornita da TensorFlow per addestrare la tua prima regressione lineare utilizzando TensorFlow.
Utilizzerai il Boston Dataset, che include le seguenti variabili
| criminale | tasso di criminalità pro capite per città |
|---|---|
| zn | percentuale di terreno residenziale suddiviso in zone per lotti superiori a 25,000 piedi quadrati. |
| Indus | percentuale di ettari commerciali non al dettaglio per città. |
| nox | concentrazione di ossidi nitrici |
| rm | numero medio di stanze per abitazione |
| percentuale di unità abitative costruite prima del 1940 | |
| DIS | distanze ponderate da cinque centri per l'impiego di Boston |
| imposta | aliquota dell'imposta sulla proprietà a valore intero per dollari 10,000 |
| ptratio | rapporto alunni-insegnanti per comune |
| medv | Valore medio delle case occupate dai proprietari in migliaia di dollari |
Creerai tre diversi set di dati:
| dataset | obiettivo | forma |
|---|---|---|
| Formazione | Addestrare il modello e ottenere i pesi | 400, 10 |
| Valutazione | Valutare le prestazioni del modello su dati invisibili | 100, 10 |
| Prevedere | Utilizza il modello per prevedere il valore della casa sulla base di nuovi dati | 6, 10 |
L'obiettivo è utilizzare le caratteristiche del set di dati per prevedere il valore della casa.
Durante la seconda parte del tutorial imparerai come utilizzare TensorFlow con tre modi diversi per importare i dati:
- Con i panda
- Con numpy
- Solo TF
Tieni presente che tutte le opzioni fornire gli stessi risultati.
Imparerai come utilizzare l'API di alto livello per creare, addestrare e valutare un modello di regressione lineare TensorFlow. Se stavi utilizzando l'API di basso livello, dovevi definire manualmente:
- Funzione di perdita
- Ottimizza: discesa del gradiente
- Moltiplicazione di matrici
- Grafico e tensore
Questo è noioso e più complicato per i principianti.
Pandas
È necessario importare le librerie necessarie per addestrare il modello.
import pandas as pd from sklearn import datasets import tensorflow as tf import itertools
Passo 1) Importa i dati con panda.
Definisci i nomi delle colonne e li memorizzi in COLONNE. È possibile utilizzare pd.read_csv() per importare i dati.
COLUMNS = ["crim", "zn", "indus", "nox", "rm", "age",
"dis", "tax", "ptratio", "medv"]
training_set = pd.read_csv("E:/boston_train.csv", skipinitialspace=True,skiprows=1, nomi=COLUMNS)
test_set = pd.read_csv("E:/boston_test.csv", skipinitialspace=True,skiprows=1, nomi=COLUMNS)
predizione_set = pd.read_csv("E:/boston_predict.csv", skipinitialspace=True,skiprows=1, nomi=COLUMNS)
È possibile stampare la forma dei dati.
print(training_set.shape, test_set.shape, prediction_set.shape)
Uscita
(400, 10) (100, 10) (6, 10)
Tieni presente che l'etichetta, ovvero la tua y, è inclusa nel set di dati. Quindi è necessario definire altre due liste. Uno contenente solo le caratteristiche e uno solo con il nome dell'etichetta. Questi due elenchi diranno al tuo stimatore quali sono le caratteristiche del set di dati e quale nome di colonna è l'etichetta
Si fa con il codice qui sotto.
FEATURES = ["crim", "zn", "indus", "nox", "rm",
"age", "dis", "tax", "ptratio"]
LABEL = "medv"
Passo 2) Converti i dati
È necessario convertire le variabili numeriche nel formato corretto. Tensorflow fornisce un metodo per convertire la variabile continua: tf.feature_column.numeric_column().
Nel passaggio precedente definisci un elenco delle funzionalità che desideri includere nel modello. Ora puoi utilizzare questo elenco per convertirli in dati numerici. Se vuoi escludere funzionalità nel tuo modello, sentiti libero di rilasciare una o più variabili nell'elenco FEATURES prima di costruire feature_cols
Nota che utilizzerai Python comprensione dell'elenco con l'elenco FEATURES per creare un nuovo elenco denominato feature_cols. Ti aiuta a evitare di scrivere nove volte tf.feature_column.numeric_column(). La comprensione delle liste è un modo più veloce e più pulito per creare nuove liste
feature_cols = [tf.feature_column.numeric_column(k) for k in FEATURES]
Passo 3) Definire lo stimatore
In questo passaggio è necessario definire lo stimatore. Tensorflow attualmente fornisce 6 stimatori predefiniti, di cui 3 per l'attività di classificazione e 3 per l'attività di regressione TensorFlow:
- Regressore
- DNNRegressore
- Regressore lineare
- DNNLineaCombinedRegressor
- classificare
- DNNClassificatore
- Classificatore lineare
- DNNLineaCombinedClassifier
In questo tutorial utilizzerai il regressore lineare. Per accedere a questa funzione, è necessario utilizzare tf.estimator.
La funzione necessita di due argomenti:
- feature_columns: contiene le variabili da includere nel modello
- model_dir: percorso per memorizzare il grafico, salvare i parametri del modello, ecc
Tensorflow creerà automaticamente un file denominato train nella tua directory di lavoro. È necessario utilizzare questo percorso per accedere a Tensorboard come mostrato nell'esempio di regressione TensorFlow riportato di seguito.
estimator = tf.estimator.LinearRegressor(
feature_columns=feature_cols,
model_dir="train")
Uscita
INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'train', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1a215dc550>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
La parte difficile con TensorFlow è il modo di alimentare il modello. Tensorflow è progettato per funzionare con il calcolo parallelo e set di dati molto grandi. A causa delle limitazioni delle risorse della macchina, è impossibile alimentare il modello con tutti i dati contemporaneamente. Per questo, è necessario alimentare ogni volta un batch di dati. Tieni presente che stiamo parlando di un enorme set di dati con milioni o più record. Se non aggiungi batch, ti ritroverai con un errore di memoria.
Ad esempio, se i tuoi dati contengono 100 osservazioni e definisci una dimensione batch pari a 10, significa che il modello vedrà 10 osservazioni per ogni iterazione (10*10).
Quando il modello ha visto tutti i dati, ne termina uno epoca. Un'epoca definisce quante volte vuoi che il modello veda i dati. È meglio impostare questo passaggio su nessuno e lasciare che il modello esegua un certo numero di iterazioni.
Una seconda informazione da aggiungere è se si desidera mescolare i dati prima di ogni iterazione. Durante l'addestramento, è importante mescolare i dati in modo che il modello non apprenda uno schema specifico del set di dati. Se il modello apprende i dettagli dello schema sottostante dei dati, avrà difficoltà a generalizzare la previsione per dati non visti. Questo è chiamato overfitting. Il modello funziona bene sui dati di training ma non è in grado di prevedere correttamente i dati invisibili.
TensorFlow semplifica questi due passaggi. Quando i dati passano alla pipeline, sa quante osservazioni sono necessarie (batch) e se deve mescolare i dati.
Per istruire Tensorflow su come alimentare il modello, puoi utilizzare pandas_input_fn. Questo oggetto necessita di 5 parametri:
- x: dati sulle caratteristiche
- y: dati dell'etichetta
- batch_size: lotto. Di default 128
- num_epoch: numero di epoche, per impostazione predefinita 1
- Shuffle: mescola o meno i dati. Per impostazione predefinita, Nessuno
È necessario alimentare il modello molte volte in modo da definire una funzione per ripetere questo processo. tutta questa funzione get_input_fn.
def get_input_fn(data_set, num_epochs=None, n_batch = 128, shuffle=True):
return tf.estimator.inputs.pandas_input_fn(
x=pd.DataFrame({k: data_set[k].values for k in FEATURES}),
y = pd.Series(data_set[LABEL].values),
batch_size=n_batch,
num_epochs=num_epochs,
shuffle=shuffle)
Il metodo usuale per valutare le prestazioni di un modello è:
- Allena il modello
- Valutare il modello in un set di dati diverso
- Fai una previsione
Lo stimatore Tensorflow fornisce tre diverse funzioni per eseguire facilmente questi tre passaggi.
Passo 4): addestra il modello
È possibile utilizzare il treno degli stimatori per valutare il modello. Lo stimatore del treno necessita di un input_fn e di un numero di passaggi. Puoi utilizzare la funzione che hai creato sopra per alimentare il modello. Quindi, chiedi al modello di ripetere 1000 volte. Tieni presente che non specifichi il numero di epoche, lasci che il modello esegua l'iterazione 1000 volte. Se imposti il numero di epoch su 1, il modello eseguirà l'iterazione 4 volte: ci sono 400 record nel set di training e la dimensione del batch è 128
- 128 piani
- 128 piani
- 128 piani
- 16 piani
Pertanto, è più semplice impostare il numero di epoche su nessuno e definire il numero di iterazioni come mostrato nell'esempio di classificazione TensorFlow riportato di seguito.
estimator.train(input_fn=get_input_fn(training_set,
num_epochs=None,
n_batch = 128,
shuffle=False),
steps=1000)
Uscita
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Create CheckpointSaverHook. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Saving checkpoints for 1 into train/model.ckpt. INFO:tensorflow:loss = 83729.64, step = 1 INFO:tensorflow:global_step/sec: 238.616 INFO:tensorflow:loss = 13909.657, step = 101 (0.420 sec) INFO:tensorflow:global_step/sec: 314.293 INFO:tensorflow:loss = 12881.449, step = 201 (0.320 sec) INFO:tensorflow:global_step/sec: 303.863 INFO:tensorflow:loss = 12391.541, step = 301 (0.327 sec) INFO:tensorflow:global_step/sec: 308.782 INFO:tensorflow:loss = 12050.5625, step = 401 (0.326 sec) INFO:tensorflow:global_step/sec: 244.969 INFO:tensorflow:loss = 11766.134, step = 501 (0.407 sec) INFO:tensorflow:global_step/sec: 155.966 INFO:tensorflow:loss = 11509.922, step = 601 (0.641 sec) INFO:tensorflow:global_step/sec: 263.256 INFO:tensorflow:loss = 11272.889, step = 701 (0.379 sec) INFO:tensorflow:global_step/sec: 254.112 INFO:tensorflow:loss = 11051.9795, step = 801 (0.396 sec) INFO:tensorflow:global_step/sec: 292.405 INFO:tensorflow:loss = 10845.855, step = 901 (0.341 sec) INFO:tensorflow:Saving checkpoints for 1000 into train/model.ckpt. INFO:tensorflow:Loss for final step: 5925.9873.
È possibile controllare la Tensorboard con il seguente comando:
activate hello-tf # For MacOS tensorboard --logdir=./train # For Windows tensorboard --logdir=train
Passo 5) Valuta il tuo modello
Puoi valutare l'adattamento del tuo modello sul set di prova con il codice seguente:
ev = estimator.evaluate(
input_fn=get_input_fn(test_set,
num_epochs=1,
n_batch = 128,
shuffle=False))
Uscita
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Starting evaluation at 2018-05-13-01:43:13 INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train/model.ckpt-1000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Finished evaluation at 2018-05-13-01:43:13 INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896
Puoi stampare lo smarrimento con il codice qui sotto:
loss_score = ev["loss"]
print("Loss: {0:f}".format(loss_score))
Uscita
Loss: 3215.895996
Il modello ha una perdita di 3215. Puoi controllare la statistica riassuntiva per avere un'idea di quanto è grande l'errore.
training_set['medv'].describe()
Uscita
count 400.000000 mean 22.625500 std 9.572593 min 5.000000 25% 16.600000 50% 21.400000 75% 25.025000 max 50.000000 Name: medv, dtype: float64
Dalla statistica riassuntiva sopra, sai che il prezzo medio di una casa è di 22mila, con un prezzo minimo di 9mila e massimo di 50mila. Il modello commette un errore tipico di 3k dollari.
Passo 6) Fai la previsione
Infine, puoi utilizzare lo stimatore TensorFlow per stimare il valore di 6 case di Boston.
y = estimator.predict(
input_fn=get_input_fn(prediction_set,
num_epochs=1,
n_batch = 128,
shuffle=False))
Per stampare i valori stimati di , puoi utilizzare questo codice:
predictions = list(p["predictions"] for p in itertools.islice(y, 6))print("Predictions: {}".format(str(predictions)))
Uscita
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train/model.ckpt-1000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. Predictions: [array([32.297546], dtype=float32), array([18.96125], dtype=float32), array([27.270979], dtype=float32), array([29.299236], dtype=float32), array([16.436684], dtype=float32), array([21.460876], dtype=float32)]
Il modello prevede i seguenti valori:
| Casa | Predizione | |
|---|---|---|
| 1 | 32.29 | |
| 2 | 18.96 | |
| 3 | 27.27 | |
| 4 | 29.29 | |
| 5 | 16.43 | |
| 7 | 21.46 |
Tieni presente che non conosciamo il vero valore di . Nel tutorial sul deep learning, proverai a superare il modello lineare
Soluzione Numpy
Questa sezione spiega come addestrare il modello utilizzando uno stimatore Numpy per alimentare i dati. Il metodo è lo stesso, tranne per il fatto che utilizzerai lo stimatore numpy_input_fn.
training_set_n = pd.read_csv(“E:/boston_train.csv”).valori
test_set_n = pd.read_csv(“E:/boston_test.csv”).valori
predizione_set_n = pd.read_csv(“E:/boston_predict.csv”).valori
Passo 1) Importa i dati
Prima di tutto, devi differenziare le variabili della caratteristica dall'etichetta. È necessario eseguire questa operazione per i dati di addestramento e la valutazione. È più veloce definire una funzione per suddividere i dati.
def prepare_data(df):
X_train = df[:, :-3]
y_train = df[:,-3]
return X_train, y_train
È possibile utilizzare la funzione per dividere l'etichetta dalle caratteristiche del set di dati addestra/valuta
X_train, y_train = prepare_data(training_set_n) X_test, y_test = prepare_data(test_set_n)
È necessario escludere l'ultima colonna del set di dati di previsione perché contiene solo NaN
x_predict = prediction_set_n[:, :-2]
Conferma la forma dell'array. Tieni presente che l'etichetta non dovrebbe avere una dimensione, significa (400,).
print(X_train.shape, y_train.shape, x_predict.shape)
Uscita
(400, 9) (400,) (6, 9)
È possibile costruire le colonne delle funzionalità come segue:
feature_columns = [ tf.feature_column.numeric_column('x', shape=X_train.shape[1:])]
Lo stimatore è definito come prima, si indicano le colonne delle caratteristiche e dove salvare il grafico.
estimator = tf.estimator.LinearRegressor(
feature_columns=feature_columns,
model_dir="train1")
Uscita
INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'train1', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1a218d8f28>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
È possibile utilizzare la stima Numpy per fornire i dati al modello e quindi addestrare il modello. Tieni presente che definiamo prima la funzione input_fn per facilitare la leggibilità.
# Train the estimatortrain_input = tf.estimator.inputs.numpy_input_fn(
x={"x": X_train},
y=y_train,
batch_size=128,
shuffle=False,
num_epochs=None)
estimator.train(input_fn = train_input,steps=5000)
Uscita
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Create CheckpointSaverHook. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Saving checkpoints for 1 into train1/model.ckpt. INFO:tensorflow:loss = 83729.64, step = 1 INFO:tensorflow:global_step/sec: 490.057 INFO:tensorflow:loss = 13909.656, step = 101 (0.206 sec) INFO:tensorflow:global_step/sec: 788.986 INFO:tensorflow:loss = 12881.45, step = 201 (0.126 sec) INFO:tensorflow:global_step/sec: 736.339 INFO:tensorflow:loss = 12391.541, step = 301 (0.136 sec) INFO:tensorflow:global_step/sec: 383.305 INFO:tensorflow:loss = 12050.561, step = 401 (0.260 sec) INFO:tensorflow:global_step/sec: 859.832 INFO:tensorflow:loss = 11766.133, step = 501 (0.117 sec) INFO:tensorflow:global_step/sec: 804.394 INFO:tensorflow:loss = 11509.918, step = 601 (0.125 sec) INFO:tensorflow:global_step/sec: 753.059 INFO:tensorflow:loss = 11272.891, step = 701 (0.134 sec) INFO:tensorflow:global_step/sec: 402.165 INFO:tensorflow:loss = 11051.979, step = 801 (0.248 sec) INFO:tensorflow:global_step/sec: 344.022 INFO:tensorflow:loss = 10845.854, step = 901 (0.288 sec) INFO:tensorflow:Saving checkpoints for 1000 into train1/model.ckpt. INFO:tensorflow:Loss for final step: 5925.985. Out[23]: <tensorflow.python.estimator.canned.linear.LinearRegressor at 0x1a1b6ea860>
Replica lo stesso passaggio con uno stimatore diverso per valutare il tuo modello
eval_input = tf.estimator.inputs.numpy_input_fn(
x={"x": X_test},
y=y_test,
shuffle=False,
batch_size=128,
num_epochs=1)
estimator.evaluate(eval_input,steps=None)
Uscita
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-05-13-01:44:00
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-05-13-01:44:00
INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.158947, global_step = 1000, loss = 3215.8945
Out[24]:
{'average_loss': 32.158947, 'global_step': 1000, 'loss': 3215.8945}
Infine, puoi calcolare la previsione. Dovrebbe essere simile ai panda.
test_input = tf.estimator.inputs.numpy_input_fn(
x={"x": x_predict},
batch_size=128,
num_epochs=1,
shuffle=False)
y = estimator.predict(test_input)
predictions = list(p["predictions"] for p in itertools.islice(y, 6))
print("Predictions: {}".format(str(predictions)))
Uscita
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. Predictions: [array([32.297546], dtype=float32), array([18.961248], dtype=float32), array([27.270979], dtype=float32), array([29.299242], dtype=float32), array([16.43668], dtype=float32), array([21.460878], dtype=float32)]
Soluzione Tensorflow
L'ultima sezione è dedicata a una soluzione TensorFlow. Questo metodo è leggermente più complicato dell'altro.
Nota che se usi Jupyter taccuino, è necessario riavviare e pulire il kernel per eseguire questa sessione.
TensorFlow ha creato un ottimo strumento per trasferire i dati nella pipeline. In questa sezione creerai tu stesso la funzione input_fn.
Passo 1) Definire il percorso e il formato dei dati
Prima di tutto, dichiari due variabili con il percorso del file csv. Tieni presente che hai due file, uno per il set di addestramento e uno per il set di test.
import tensorflow as tf
df_train = "E:/boston_train.csv"
df_eval = "E:/boston_test.csv"
Quindi, devi definire le colonne che desideri utilizzare dal file CSV. Useremo tutto. Successivamente, devi dichiarare il tipo di variabile.
Le variabili float sono definite da [0.]
COLUMNS = ["crim", "zn", "indus", "nox", "rm", "age",
"dis", "tax", "ptratio", "medv"]RECORDS_ALL = [[0.0], [0.0], [0.0], [0.0],[0.0],[0.0],[0.0],[0.0],[0.0],[0.0]]
Passo 2) Definire la funzione input_fn
La funzione può essere suddivisa in tre parti:
- Importa i dati
- Crea l'iteratore
- Consumare i dati
Di seguito è riportato il codice generale per definire la funzione. Il codice verrà spiegato dopo
def input_fn(data_file, batch_size, num_epoch = None):
# Step 1
def parse_csv(value):
columns = tf.decode_csv(value, record_defaults= RECORDS_ALL)
features = dict(zip(COLUMNS, columns))
#labels = features.pop('median_house_value')
labels = features.pop('medv')
return features, labels
# Extract lines from input files using the
Dataset API. dataset = (tf.data.TextLineDataset(data_file) # Read text file
.skip(1) # Skip header row
.map(parse_csv))
dataset = dataset.repeat(num_epoch)
dataset = dataset.batch(batch_size)
# Step 3
iterator = dataset.make_one_shot_iterator()
features, labels = iterator.get_next()
return features, labels
**Importa i dati**
Per un file CSV, il metodo del set di dati legge una riga alla volta. Per creare il set di dati, è necessario utilizzare l'oggetto TextLineSet di dati. Il tuo set di dati ha un'intestazione quindi devi utilizzare skip(1) per saltare la prima riga. A questo punto, leggi solo i dati ed escludi l'intestazione nella pipeline. Per alimentare il modello, è necessario separare le caratteristiche dall'etichetta. Il metodo utilizzato per applicare qualsiasi trasformazione ai dati è map.
Questo metodo chiama una funzione che creerai per istruire su come trasformare i dati. In poche parole, devi passare i dati nel TextLineOggetto set di dati, esclude l'intestazione e applica una trasformazione che viene istruita da una funzione. Spiegazione del codice
- tf.data.TextLineDataset(data_file): questa riga legge il file CSV
- .skip(1): salta l'intestazione
- .map(parse_csv)): analizza i record nei tensori. È necessario definire una funzione per istruire l'oggetto mappa. Puoi chiamare questa funzione parse_csv.
Questa funzione analizza il file csv con il metodo tf.decode_csv e dichiara le feature e l'etichetta. Le feature possono essere dichiarate come un dizionario o una tupla. Si usa il metodo del dizionario perché è più comodo.Spiegazione del codice
- tf.decode_csv(value, record_defaults= RECORDS_ALL): il metodo decode_csv utilizza l'output del TextLineSet di dati per leggere il file CSV. record_defaults indica a TensorFlow il tipo di colonne.
- dict(zip(_CSV_COLUMNS, columns)): popola il dizionario con tutte le colonne estratte durante questa elaborazione dei dati
- features.pop('median_house_value'): esclude la variabile target dalla variabile feature e crea una variabile label
Il Dataset necessita di ulteriori elementi per alimentare iterativamente i Tensori. Infatti, è necessario aggiungere il metodo ripeti per consentire al dataset di continuare indefinitamente ad alimentare il modello. Se non aggiungi il metodo, il modello eseguirà l'iterazione solo una volta e quindi genererà un errore perché non vengono più inseriti dati nella pipeline.
Successivamente, puoi controllare la dimensione del batch con il metodo batch. Significa che devi dire al set di dati quanti dati vuoi passare nella pipeline per ogni iterazione. Se imposti una dimensione batch elevata, il modello sarà lento.
Passaggio 3) Creare l'iteratore
Ora sei pronto per il secondo passaggio: crea un iteratore per restituire gli elementi nel set di dati.
Il modo più semplice per creare un operatore è con il metodo make_one_shot_iterator.
Successivamente, puoi creare funzionalità ed etichette dall'iteratore.
Passaggio 4) Consumare i dati
Puoi controllare cosa succede con la funzione input_fn. È necessario chiamare la funzione in una sessione per consumare i dati. Prova con una dimensione batch pari a 1.
Tieni presente che stampa le funzionalità in un dizionario e l'etichetta come array.
Mostrerà la prima riga del file CSV. Puoi provare a eseguire questo codice più volte con dimensioni batch diverse.
next_batch = input_fn(df_train, batch_size = 1, num_epoch = None)
with tf.Session() as sess:
first_batch = sess.run(next_batch)
print(first_batch)
Uscita
({'crim': array([2.3004], dtype=float32), 'zn': array([0.], dtype=float32), 'indus': array([19.58], dtype=float32), 'nox': array([0.605], dtype=float32), 'rm': array([6.319], dtype=float32), 'age': array([96.1], dtype=float32), 'dis': array([2.1], dtype=float32), 'tax': array([403.], dtype=float32), 'ptratio': array([14.7], dtype=float32)}, array([23.8], dtype=float32))
Passo 4) Definire la colonna della funzionalità
È necessario definire le colonne numeriche come segue:
X1= tf.feature_column.numeric_column('crim')
X2= tf.feature_column.numeric_column('zn')
X3= tf.feature_column.numeric_column('indus')
X4= tf.feature_column.numeric_column('nox')
X5= tf.feature_column.numeric_column('rm')
X6= tf.feature_column.numeric_column('age')
X7= tf.feature_column.numeric_column('dis')
X8= tf.feature_column.numeric_column('tax')
X9= tf.feature_column.numeric_column('ptratio')
Tieni presente che devi combinare tutte le variabili in un bucket
base_columns = [X1, X2, X3,X4, X5, X6,X7, X8, X9]
Passo 5) Costruisci il modello
È possibile addestrare il modello con lo stimatore LinearRegressor.
model = tf.estimator.LinearRegressor(feature_columns=base_columns, model_dir='train3')
Uscita
INFO:tensorflow:Using default config. INFO:tensorflow:Using config: {'_model_dir': 'train3', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1820a010f0>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
È necessario utilizzare una funzione lambda per consentire di scrivere l'argomento nella funzione inpu_fn. Se non usi a funzione lambda, non è possibile addestrare il modello.
# Train the estimatormodel.train(steps =1000,
input_fn= lambda : input_fn(df_train,batch_size=128, num_epoch = None))
Uscita
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Create CheckpointSaverHook. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Saving checkpoints for 1 into train3/model.ckpt. INFO:tensorflow:loss = 83729.64, step = 1 INFO:tensorflow:global_step/sec: 72.5646 INFO:tensorflow:loss = 13909.657, step = 101 (1.380 sec) INFO:tensorflow:global_step/sec: 101.355 INFO:tensorflow:loss = 12881.449, step = 201 (0.986 sec) INFO:tensorflow:global_step/sec: 109.293 INFO:tensorflow:loss = 12391.541, step = 301 (0.915 sec) INFO:tensorflow:global_step/sec: 102.235 INFO:tensorflow:loss = 12050.5625, step = 401 (0.978 sec) INFO:tensorflow:global_step/sec: 104.656 INFO:tensorflow:loss = 11766.134, step = 501 (0.956 sec) INFO:tensorflow:global_step/sec: 106.697 INFO:tensorflow:loss = 11509.922, step = 601 (0.938 sec) INFO:tensorflow:global_step/sec: 118.454 INFO:tensorflow:loss = 11272.889, step = 701 (0.844 sec) INFO:tensorflow:global_step/sec: 114.947 INFO:tensorflow:loss = 11051.9795, step = 801 (0.870 sec) INFO:tensorflow:global_step/sec: 111.484 INFO:tensorflow:loss = 10845.855, step = 901 (0.897 sec) INFO:tensorflow:Saving checkpoints for 1000 into train3/model.ckpt. INFO:tensorflow:Loss for final step: 5925.9873. Out[8]: <tensorflow.python.estimator.canned.linear.LinearRegressor at 0x18225eb8d0>
Puoi valutare l'adattamento del tuo modello sul set di prova con il codice seguente:
results = model.evaluate(steps =None,input_fn=lambda: input_fn(df_eval, batch_size =128, num_epoch = 1))
for key in results:
print(" {}, was: {}".format(key, results[key]))
Uscita
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Starting evaluation at 2018-05-13-02:06:02 INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Finished evaluation at 2018-05-13-02:06:02 INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896 average_loss, was: 32.158958435058594 loss, was: 3215.89599609375 global_step, was: 1000
L'ultimo passaggio è prevedere il valore di in base al valore di , le matrici delle caratteristiche. Puoi scrivere un dizionario con i valori che vuoi prevedere. Il tuo modello ha 9 funzioni, quindi devi fornire un valore per ciascuna. Il modello fornirà una previsione per ciascuno di essi.
Nel codice seguente, hai scritto i valori di ciascuna funzionalità contenuta nel file csv df_predict.
È necessario scrivere una nuova funzione input_fn perché non è presente alcuna etichetta nel set di dati. Puoi utilizzare l'API from_tensor dal set di dati.
prediction_input = {
'crim': [0.03359,5.09017,0.12650,0.05515,8.15174,0.24522],
'zn': [75.0,0.0,25.0,33.0,0.0,0.0],
'indus': [2.95,18.10,5.13,2.18,18.10,9.90],
'nox': [0.428,0.713,0.453,0.472,0.700,0.544],
'rm': [7.024,6.297,6.762,7.236,5.390,5.782],
'age': [15.8,91.8,43.4,41.1,98.9,71.7],
'dis': [5.4011,2.3682,7.9809,4.0220,1.7281,4.0317],
'tax': [252,666,284,222,666,304],
'ptratio': [18.3,20.2,19.7,18.4,20.2,18.4]
}
def test_input_fn():
dataset = tf.data.Dataset.from_tensors(prediction_input)
return dataset
# Predict all our prediction_inputpred_results = model.predict(input_fn=test_input_fn)
Infine, stampi le previsioni.
for pred in enumerate(pred_results): print(pred)
Uscita
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
(0, {'predictions': array([32.297546], dtype=float32)})
(1, {'predictions': array([18.96125], dtype=float32)})
(2, {'predictions': array([27.270979], dtype=float32)})
(3, {'predictions': array([29.299236], dtype=float32)})
(4, {'predictions': array([16.436684], dtype=float32)})
(5, {'predictions': array([21.460876], dtype=float32)})
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train3/model.ckpt-5000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. (0, {'predictions': array([35.60663], dtype=float32)}) (1, {'predictions': array([22.298521], dtype=float32)}) (2, {'predictions': array([25.74533], dtype=float32)}) (3, {'predictions': array([35.126694], dtype=float32)}) (4, {'predictions': array([17.94416], dtype=float32)}) (5, {'predictions': array([22.606628], dtype=float32)})
Sommario
Per addestrare un modello, è necessario:
- Definire le caratteristiche: Variabili indipendenti: X
- Definire l'etichetta: Variabile dipendente: y
- Costruisci un set di treni/test
- Definire il peso iniziale
- Definire la funzione di perdita: MSE
- Ottimizza il modello: discesa del gradiente
- Definire:
- Tasso di apprendimento
- Numero di epoche
- Dimensione del lotto
In questo tutorial hai imparato come utilizzare l'API di alto livello per uno stimatore TensorFlow di regressione lineare. È necessario definire:
- Colonne di funzionalità. Se continuo: tf.feature_column.numeric_column(). Puoi popolare un elenco con la comprensione dell'elenco Python
- Lo stimatore: tf.estimator.LinearRegressor(feature_columns, model_dir)
- Una funzione per importare i dati, la dimensione del batch e l'epoca: input_fn()
Successivamente, sei pronto per addestrare, valutare e fare previsioni con train(),valuta() e predit()
