Regressione lineare con TensorFlow (esempi)

Sommario:

Anonim

Cos'è la regressione lineare?

La regressione lineare è un approccio in statistica 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. Inoltre, TensorFlow è dotato di una vasta gamma di API per eseguire molti algoritmi di apprendimento automatico. Questa è l'API di alto livello. TensorFlow li chiama stimatori

  • API di basso livello: costruisci l'architettura, ottimizza il modello da zero. È complicato per un principiante
  • API di alto livello: definire l'algoritmo. È più facile da usare. TensorFlow fornisce un toolbox chiama lo stimatore per costruire, addestrare, valutare ed effettuare una previsione.

In questo tutorial, utilizzerai solo gli stimatori . 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.

Scarica Boston DataSet

In questo tutorial sulla regressione di TensorFlow imparerai:

  • Cos'è la regressione lineare?
  • Come addestrare un modello di regressione lineare
  • Come addestrare una regressione lineare con TensorFlow
  • Panda
  • Soluzione Numpy
  • Soluzione 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, xey e il tuo compito è prevedere il valore di conoscere il valore di. Se tracci i dati, puoi vedere una relazione positiva tra la tua variabile indipendente, x e la tua variabile dipendente y.

Puoi osservare, se x = 1, y sarà approssimativamente uguale a 6 e se x = 2, y sarà circa 8,5.

Questo non è un metodo molto accurato e 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 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 per y. Cioè, puoi sostituire x con qualsiasi valore che desideri prevedere y. Nell'immagine seguente, abbiamo sostituito x nell'equazione con tutti i valori nel set di dati e tracciamo il risultato.

La linea rossa rappresenta il valore adattato, ovvero i valori di y per ogni valore di x. Non è necessario vedere il valore di x per prevedere y, per ogni x ce n'è qualcuna che appartiene alla linea rossa. Puoi anche prevedere valori di x maggiori di 2!

Se si desidera estendere la regressione lineare a più covariate, è possibile aggiungendo più variabili al modello. La differenza tra l'analisi tradizionale e la regressione lineare è che la regressione lineare osserva come y reagirà 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 (ad esempio pioggia, sole, nuvoloso), informazioni sui clienti (ad esempio stipendio, sesso, stato civile).

L'analisi tradizionale proverà a prevedere la vendita supponiamo calcolando la media per ogni variabile e tentando di stimare la vendita per diversi scenari. Porterà a previsioni sbagliate e limiterà l'analisi allo scenario scelto.

Se usi la regressione lineare, puoi scrivere questa equazione:

L'algoritmo troverà la migliore soluzione per i pesi; significa che cercherà di minimizzare il costo (la differenza tra la linea adattata e i punti dati).

Come funziona l'algoritmo

L'algoritmo sceglierà un numero casuale per ogni e sostituirà il valore di x per ottenere il valore previsto di y. Se il set di dati ha 100 osservazioni, l'algoritmo calcola 100 valori previsti.

Possiamo calcolare l'errore, annotato 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 e 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 quadratico. Questo passaggio è chiamato minimizzazione dell'errore. Per la regressione lineare è il Mean Square Error , chiamato anche MSE. Matematicamente, è:

Dove:

  • riferisce al valore previsto
  • y sono i valori reali
  • m è il numero di osservazioni

Nota che è la notazione matematica della media.

L'obiettivo è trovare il meglio che minimizzi il MSE

Se l'errore medio è elevato, significa che il modello ha prestazioni scadenti e i pesi non sono stati scelti correttamente. Per correggere i pesi, è necessario utilizzare un ottimizzatore. L'ottimizzatore tradizionale si chiama Gradient Descent .

La discesa del gradiente prende 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 fino a quando l'errore non cambia più. Ogni processo è chiamato iterazione . Inoltre, i gradienti vengono moltiplicati per un tasso di apprendimento. Indica la velocità di apprendimento.

Se il tasso di apprendimento è troppo piccolo, l'algoritmo impiegherà molto tempo a convergere (cioè richiede molte iterazioni). Se il tasso di apprendimento è troppo alto, l'algoritmo potrebbe non convergere mai.

Come potete vedere dall'immagine sopra, il modello ripete il processo circa 20 volte prima per trovare un valore stabile per i pesi, raggiungendo quindi l'errore più basso.

Nota che l'errore non è uguale a zero ma si stabilizza intorno a 5. Significa che il modello fa un errore tipico di 5. Se vuoi ridurre l'errore, devi aggiungere più informazioni al modello come più variabili o usare 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 sta accadendo 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

crim tasso di criminalità pro capite per città
zn percentuale di terreno residenziale suddiviso in zone per lotti di oltre 25.000 piedi quadrati.
indus proporzione di acri di attività commerciali non al dettaglio per città.
nox concentrazione di ossidi nitrici
rm numero medio di stanze per abitazione
età percentuale di unità abitate dai proprietari costruite prima del 1940
dis distanze ponderate da cinque centri per l'impiego di Boston
imposta aliquota dell'imposta sulla proprietà a valore pieno per 10.000 dollari
ptratio rapporto alunni-insegnanti per città
medv Valore medio delle case occupate dai proprietari in migliaia di dollari

Creerai tre diversi set di dati:

set di dati obbiettivo forma
Formazione Allena il modello e ottieni i pesi 400, 10
Valutazione Valuta le prestazioni del modello su dati invisibili 100, 10
Prevedi Utilizza il modello per prevedere il valore della casa su 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 forniscono 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 a mano:

  • Funzione di perdita
  • Ottimizza: discesa in pendenza
  • Moltiplicazione di matrici
  • Grafico e tensore

Questo è noioso e più complicato per i principianti.

Panda

È necessario importare le librerie necessarie per addestrare il modello.

import pandas as pdfrom sklearn import datasetsimport tensorflow as tfimport itertools

Passaggio 1) Importa i dati con panda.

Definisci i nomi delle colonne e li memorizzi in COLUMNS. È 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, names = COLUMNS)

test_set = pd.read_csv ("E: /boston_test.csv", skipinitialspace = True, skiprows = 1, names = COLUMNS)

prediction_set = pd.read_csv ("E: /boston_predict.csv", skipinitialspace = True, skiprows = 1, names = COLUMNS)

È possibile stampare la forma dei dati.

print(training_set.shape, test_set.shape, prediction_set.shape)

Produzione

(400, 10) (100, 10) (6, 10)

Nota che l'etichetta, cioè la tua y, è inclusa nel set di dati. Quindi è necessario definire altri due elenchi. Uno contenente solo le caratteristiche e uno solo con il nome dell'etichetta. Questi due elenchi diranno al tuo estimatore quali sono le caratteristiche nel set di dati e quale nome di colonna è l'etichetta

È fatto con il codice sottostante.

FEATURES = ["crim", "zn", "indus", "nox", "rm","age", "dis", "tax", "ptratio"]LABEL = "medv"

Passaggio 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 di una caratteristica che desideri includere nel modello. Ora puoi utilizzare questo elenco per convertirli in dati numerici. Se desideri escludere funzionalità nel tuo modello, sentiti libero di rilasciare una o più variabili nell'elenco CARATTERISTICHE prima di costruire feature_cols

Nota che utilizzerai la comprensione delle liste Python con le CARATTERISTICHE della lista per creare una nuova lista chiamata feature_cols. Ti aiuta a evitare di scrivere nove volte tf.feature_column.numeric_column (). La comprensione degli elenchi è un modo più rapido e pulito per creare nuovi elenchi

feature_cols = [tf.feature_column.numeric_column(k) for k in FEATURES]

Passaggio 3) Definisci lo stimatore

In questo passaggio, è necessario definire lo stimatore. Tensorflow attualmente fornisce 6 stimatori predefiniti, inclusi 3 per l'attività di classificazione e 3 per l'attività di regressione TensorFlow:

  • Regressore
    • DNNRegressor
    • LinearRegressor
    • DNNLineaCombinedRegressor
  • Classificatore
    • DNNClassifier
    • LinearClassifier
    • 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 directory di lavoro. È necessario utilizzare questo percorso per accedere a Tensorboard come mostrato nell'esempio di regressione TensorFlow di seguito.

estimator = tf.estimator.LinearRegressor(feature_columns=feature_cols,model_dir="train")

Produzione

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': , '_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 della limitazione delle risorse della macchina, è impossibile alimentare il modello con tutti i dati contemporaneamente. Per questo, è necessario alimentare ogni volta un batch di dati. Nota 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 di 10, significa che il modello vedrà 10 osservazioni per ogni iterazione (10 * 10).

Quando il modello ha visto tutti i dati, termina un'epoca . Un'epoca definisce quante volte si desidera che il modello veda i dati. È meglio impostare questo passaggio su nessuno e lasciare che il modello esegua il numero di iterazioni di tempo.

Una seconda informazione da aggiungere è se vuoi mescolare i dati prima di ogni iterazione. Durante l'addestramento, è importante mescolare i dati in modo che il modello non apprenda il modello specifico del set di dati. Se il modello apprende i dettagli del modello sottostante dei dati, avrà difficoltà a generalizzare la previsione per i dati invisibili. Questo si chiama overfitting . Il modello funziona bene sui dati di addestramento ma non può prevedere correttamente i dati non visualizzati.

TensorFlow semplifica l'esecuzione di questi due passaggi. Quando i dati vanno alla pipeline, sa quante osservazioni ha bisogno (batch) e se deve mescolare i dati.

Per istruire Tensorflow su come alimentare il modello, puoi usare pandas_input_fn. Questo oggetto necessita di 5 parametri:

  • x: dati delle caratteristiche
  • y: dati dell'etichetta
  • batch_size: batch. Per impostazione predefinita 128
  • num_epoch: numero di epoch, per impostazione predefinita 1
  • shuffle: mescola o no 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 è:

  • Addestra il modello
  • Valuta il modello in un set di dati diverso
  • Fai previsioni

Lo stimatore di Tensorflow fornisce tre diverse funzioni per eseguire facilmente questi tre passaggi.

Passaggio 4) : addestrare il modello

È possibile utilizzare il training dello stimatore per valutare il modello. Lo stimatore del treno necessita di input_fn e di un numero di passaggi. Puoi utilizzare la funzione che hai creato sopra per alimentare il modello. Quindi, istruisci il modello a iterare 1000 volte. Nota che, non specifichi il numero di epoche, lasci che il modello iteri 1000 volte. Se imposti il ​​numero di epoch su 1, il modello itererà 4 volte: ci sono 400 record nel set di addestramento e la dimensione del batch è 128

  1. 128 righe
  2. 128 righe
  3. 128 righe
  4. 16 righe

Pertanto, è più semplice impostare il numero di epoch su none e definire il numero di iterazioni come mostrato nell'esempio di classificazione TensorFlow di seguito.

estimator.train(input_fn=get_input_fn(training_set,num_epochs=None,n_batch = 128,shuffle=False),steps=1000)

Produzione

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 = 1INFO:tensorflow:global_step/sec: 238.616INFO:tensorflow:loss = 13909.657, step = 101 (0.420 sec)INFO:tensorflow:global_step/sec: 314.293INFO:tensorflow:loss = 12881.449, step = 201 (0.320 sec)INFO:tensorflow:global_step/sec: 303.863INFO:tensorflow:loss = 12391.541, step = 301 (0.327 sec)INFO:tensorflow:global_step/sec: 308.782INFO:tensorflow:loss = 12050.5625, step = 401 (0.326 sec)INFO:tensorflow:global_step/sec: 244.969INFO:tensorflow:loss = 11766.134, step = 501 (0.407 sec)INFO:tensorflow:global_step/sec: 155.966INFO:tensorflow:loss = 11509.922, step = 601 (0.641 sec)INFO:tensorflow:global_step/sec: 263.256INFO:tensorflow:loss = 11272.889, step = 701 (0.379 sec)INFO:tensorflow:global_step/sec: 254.112INFO:tensorflow:loss = 11051.9795, step = 801 (0.396 sec)INFO:tensorflow:global_step/sec: 292.405INFO: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.

Puoi controllare il Tensorboard con il seguente comando:

activate hello-tf# For MacOStensorboard --logdir=./train# For Windowstensorboard --logdir=train

Passaggio 5) Valuta il tuo modello

Puoi valutare l'adattamento del tuo modello sul set di test con il codice seguente:

ev = estimator.evaluate(input_fn=get_input_fn(test_set,num_epochs=1,n_batch = 128,shuffle=False))

Produzione

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-05-13-01:43:13INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-13-01:43:13INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896

Puoi stampare la perdita con il codice qui sotto:

loss_score = ev["loss"]print("Loss: {0:f}".format(loss_score))

Produzione

Loss: 3215.895996

Il modello ha una perdita di 3215. Puoi controllare la statistica di riepilogo per avere un'idea di quanto sia grande l'errore.

training_set['medv'].describe()

Produzione

count 400.000000mean 22.625500std 9.572593min 5.00000025% 16.60000050% 21.40000075% 25.025000max 50.000000Name: medv, dtype: float64

Dalla statistica di sintesi sopra, sai che il prezzo medio di una casa è di 22mila, con un prezzo minimo di 9mila e massimo di 50mila. Il modello fa un tipico errore di 3k dollari.

Passaggio 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)))

Produzione

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train/model.ckpt-1000INFO: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

Nota che non conosciamo il vero valore di. Nel tutorial di deep learning, proverai a battere 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 che utilizzerai lo stimatore numpy_input_fn.

training_set_n = pd.read_csv ("E: /boston_train.csv"). values

test_set_n = pd.read_csv ("E: /boston_test.csv"). values

prediction_set_n = pd.read_csv ("E: /boston_predict.csv"). values

Passaggio 1) Importa i dati

Prima di tutto, devi differenziare le variabili delle caratteristiche dall'etichetta. È necessario eseguire questa operazione per i dati di addestramento e la valutazione. È più veloce definire una funzione per dividere 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 di formazione / valutazione

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. Nota che l'etichetta non dovrebbe avere una dimensione, significa (400,).

print(X_train.shape, y_train.shape, x_predict.shape)

Produzione

(400, 9) (400,) (6, 9)

Puoi costruire le colonne delle caratteristiche come segue:

feature_columns = [ tf.feature_column.numeric_column('x', shape=X_train.shape[1:])]

Lo stimatore è definito come prima, istruisci le colonne delle caratteristiche e dove salvare il grafico.

estimator = tf.estimator.LinearRegressor(feature_columns=feature_columns,model_dir="train1")

Produzione

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': , '_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 numpy estimapor per fornire i dati al modello e quindi addestrare il modello. Nota che definiamo la funzione input_fn prima 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)

Produzione

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 = 1INFO:tensorflow:global_step/sec: 490.057INFO:tensorflow:loss = 13909.656, step = 101 (0.206 sec)INFO:tensorflow:global_step/sec: 788.986INFO:tensorflow:loss = 12881.45, step = 201 (0.126 sec)INFO:tensorflow:global_step/sec: 736.339INFO:tensorflow:loss = 12391.541, step = 301 (0.136 sec)INFO:tensorflow:global_step/sec: 383.305INFO:tensorflow:loss = 12050.561, step = 401 (0.260 sec)INFO:tensorflow:global_step/sec: 859.832INFO:tensorflow:loss = 11766.133, step = 501 (0.117 sec)INFO:tensorflow:global_step/sec: 804.394INFO:tensorflow:loss = 11509.918, step = 601 (0.125 sec)INFO:tensorflow:global_step/sec: 753.059INFO:tensorflow:loss = 11272.891, step = 701 (0.134 sec)INFO:tensorflow:global_step/sec: 402.165INFO:tensorflow:loss = 11051.979, step = 801 (0.248 sec)INFO:tensorflow:global_step/sec: 344.022INFO: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]:

Replichi lo stesso passaggio con un diverso estimatore 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)

Produzione

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-05-13-01:44:00INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-13-01:44:00INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.158947, global_step = 1000, loss = 3215.8945Out[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)))

Produzione

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000INFO: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 il notebook Jupyter, devi riavviare e pulire il kernel per eseguire questa sessione.

TensorFlow ha creato un ottimo strumento per trasferire i dati nella pipeline. In questa sezione, costruirai da solo la funzione input_fn.

Passaggio 1) Definisci 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, è necessario definire le colonne che si desidera utilizzare dal file csv. Useremo tutto. Dopodiché, devi dichiarare il tipo di variabile che è.

Le variabili Floats 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]]

Passaggio 2) Definire la funzione input_fn

La funzione può essere suddivisa in tre parti:

  1. Importa i dati
  2. Crea l'iteratore
  3. Consuma 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 1def 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 theDataset 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 3iterator = dataset.make_one_shot_iterator()features, labels = iterator.get_next()return features, labels

** Importa i dati **

Per un file csv, il metodo dataset legge una riga alla volta. Per creare il set di dati, è necessario utilizzare l'oggetto TextLineDataset. Il tuo set di dati ha un'intestazione, quindi devi usare 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 come trasformare i dati.In poche parole, devi passare i dati nell'oggetto TextLineDataset, escludere l'intestazione e applicare una trasformazione che viene istruita da una funzione.

  • 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. È possibile chiamare questa funzione parse_csv.

Questa funzione analizza il file csv con il metodo tf.decode_csv e dichiara le caratteristiche e l'etichetta. Le caratteristiche possono essere dichiarate come un dizionario o una tupla. Si utilizza il metodo del dizionario perché è più conveniente. Spiegazione del codice

  • tf.decode_csv (value, record_defaults = RECORDS_ALL): il metodo decode_csv utilizza l'output di TextLineDataset per leggere il file csv. record_defaults indica a TensorFlow il tipo di colonne.
  • dict (zip (_CSV_COLUMNS, colonne)): popolare il dizionario con tutte le colonne estratte durante questa elaborazione dati
  • features.pop ('median_house_value'): esclude la variabile target dalla variabile feature e crea una variabile label

Il set di dati necessita di ulteriori elementi per alimentare in modo iterativo i tensori. Infatti, è necessario aggiungere la ripetizione del metodo per consentire al set di dati di continuare indefinitamente ad alimentare il modello. Se non aggiungi il metodo, il modello itererà solo una volta e quindi genererà un errore perché nella pipeline non vengono inseriti più dati.

Successivamente, puoi controllare la dimensione del batch con il metodo batch. Significa che dici al set di dati quanti dati vuoi passare nella pipeline per ogni iterazione. Se imposti un lotto di grandi dimensioni, il modello sarà lento.

Passaggio 3) Crea 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 le caratteristiche e le etichette dall'iteratore.

Passaggio 4) Consuma i dati

Puoi controllare cosa succede con la funzione input_fn. È necessario chiamare la funzione in una sessione per consumare i dati. Provi con una dimensione del batch uguale a 1.

Notare che stampa le caratteristiche in un dizionario e l'etichetta come un array.

Mostrerà la prima riga del file csv. Puoi provare a eseguire questo codice molte 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)

Produzione

({'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))

Passaggio 4) Definire la colonna delle caratteristiche

È 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]

Passaggio 5) Costruisci il modello

È possibile addestrare il modello con lo stimatore LinearRegressor.

model = tf.estimator.LinearRegressor(feature_columns=base_columns, model_dir='train3')

Produzione

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': , '_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 una funzione lambda, non puoi addestrare il modello.

# Train the estimatormodel.train(steps =1000,input_fn= lambda : input_fn(df_train,batch_size=128, num_epoch = None))

Produzione

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 = 1INFO:tensorflow:global_step/sec: 72.5646INFO:tensorflow:loss = 13909.657, step = 101 (1.380 sec)INFO:tensorflow:global_step/sec: 101.355INFO:tensorflow:loss = 12881.449, step = 201 (0.986 sec)INFO:tensorflow:global_step/sec: 109.293INFO:tensorflow:loss = 12391.541, step = 301 (0.915 sec)INFO:tensorflow:global_step/sec: 102.235INFO:tensorflow:loss = 12050.5625, step = 401 (0.978 sec)INFO:tensorflow:global_step/sec: 104.656INFO:tensorflow:loss = 11766.134, step = 501 (0.956 sec)INFO:tensorflow:global_step/sec: 106.697INFO:tensorflow:loss = 11509.922, step = 601 (0.938 sec)INFO:tensorflow:global_step/sec: 118.454INFO:tensorflow:loss = 11272.889, step = 701 (0.844 sec)INFO:tensorflow:global_step/sec: 114.947INFO:tensorflow:loss = 11051.9795, step = 801 (0.870 sec)INFO:tensorflow:global_step/sec: 111.484INFO: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]:

Puoi valutare l'adattamento del tuo modello sul set di test 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]))

Produzione

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-05-13-02:06:02INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-13-02:06:02INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896average_loss, was: 32.158958435058594loss, was: 3215.89599609375global_step, was: 1000

L'ultimo passaggio è prevedere il valore di in base al valore di, le matrici delle caratteristiche. È possibile scrivere un dizionario con i valori che si desidera 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)

Produzione

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000INFO: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, devi:

  • Definisci le caratteristiche: Variabili indipendenti: X
  • Definisci l'etichetta: Variabile dipendente: y
  • Costruisci un treno / set di prova
  • Definisci il peso iniziale
  • Definisci la funzione di perdita: MSE
  • Ottimizza il modello: discesa in gradiente
  • Definire:
    • Tasso di apprendimento
    • Numero di epoca
    • Dimensione del lotto

In questo tutorial, hai imparato a utilizzare l'API di alto livello per uno stimatore TensorFlow di regressione lineare. Devi definire:

  1. Colonne delle caratteristiche. Se continuo: tf.feature_column.numeric_column (). Puoi popolare un elenco con la comprensione degli elenchi Python
  2. Lo stimatore: tf.estimator.LinearRegressor (feature_columns, model_dir)
  3. Una funzione per importare i dati, la dimensione del batch e l'epoca: input_fn ()

Dopodiché, sei pronto per addestrare, valutare e fare previsioni con train (), assess () e prediction ()