Zelfstudie lineaire regressie met TensorFlow [Voorbeelden]

Wat is lineaire regressie?

Lineaire regressie is een benadering in de statistiek voor het modelleren van relaties tussen twee variabelen. Deze modellering wordt uitgevoerd tussen een scalaire respons en een of meer verklarende variabelen. De relatie met één verklarende variabele wordt eenvoudige lineaire regressie genoemd en voor meer dan één verklarende variabele heet dit meervoudige lineaire regressie.

TensorFlow biedt tools om volledige controle over de berekeningen te hebben. Dit gebeurt met de low-level API. Bovendien is TensorFlow uitgerust met een breed scala aan API's om er vele uit te voeren machine learning algoritmen. Dit is de API op hoog niveau. TensorFlow noemt ze schatters

  • API op laag niveau: Bouw de architectuur, optimalisatie van het model vanaf nul. Voor een beginner is het ingewikkeld
  • API op hoog niveau: Definieer het algoritme. Het is gemakkelijker-vriendelijk. TensorFlow biedt een hulpmiddelbox Dit betekent dat we onszelf en onze geliefden praktisch vergiftigen. taxateur construeren, trainen, evalueren en een voorspelling doen.

In deze zelfstudie gebruikt u de alleen schatters. De berekeningen zijn sneller en gemakkelijker te implementeren. In het eerste deel van de tutorial wordt uitgelegd hoe u de Gradient Descent Optimizer kunt gebruiken om een ​​lineaire regressie in TensorFlow te trainen. In een tweede deel gebruik je de Boston-dataset om de prijs van een huis te voorspellen met behulp van de TensorFlow-schatter.

Boston-dataset downloaden

Hoe een lineair regressiemodel te trainen

Voordat we het model gaan trainen, gaan we eerst kijken naar wat een lineaire regressie is.

Stel je voor dat je twee variabelen hebt, x en y, en het is jouw taak om de waarde van kno te voorspellenwing de waarde van . Als u de gegevens plot, ziet u een positieve relatie tussen uw onafhankelijke variabele x en uw afhankelijke variabele y.

Train een lineair regressiemodel

Je kunt zien dat als x=1,y ongeveer gelijk zal zijn aan 6 en als x=2,y ongeveer 8.5 zal zijn.

Dit is geen erg nauwkeurige methode en gevoelig voor fouten, vooral bij een dataset met honderdduizenden punten.

Een lineaire regressie wordt geëvalueerd met een vergelijking. De variabele y wordt verklaard door een of meerdere covariaten. In uw voorbeeld is er slechts één afhankelijke variabele. Als je deze vergelijking moet schrijven, wordt het:

Train een lineair regressiemodel

Met:

  • Lineaire regressie met TensorFlow is de vooringenomenheid. dwz als x=0, y=Train een lineair regressiemodel
  • Train een lineair regressiemodel is het gewicht geassocieerd met x
  • Train een lineair regressiemodel is het residu of de fout van het model. Het omvat wat het model niet van de gegevens kan leren

Stel je voor dat je in het model past en de volgende resultaten vindtwing oplossing voor:

  • Train een lineair regressiemodel = 3.8
  • Train een lineair regressiemodel = 2.78

Je kunt deze getallen in de vergelijking vervangen en het wordt:

y= 3.8 + 2.78x

Je hebt nu een betere manier om de waarden voor y te vinden. Dat wil zeggen, u kunt x vervangen door elke waarde waarvan u y wilt voorspellen. In de onderstaande afbeelding hebben we x in de vergelijking vervangen door alle waarden in de dataset en het resultaat uitgezet.

Train een lineair regressiemodel

De rode lijn vertegenwoordigt de aangepaste waarde, dat wil zeggen de waarden van y voor elke waarde van x. Je hoeft de waarde van x niet te zien om y te voorspellen, voor elke x is er een waarde die tot de rode lijn behoort. Je kunt ook voorspellen voor waarden van x hoger dan 2!

Als u de lineaire regressie naar meer covariaten wilt uitbreiden, kunt u meer variabelen aan het model toevoegen. Het verschil tussen traditionele analyse en lineaire regressie is dat bij lineaire regressie wordt gekeken naar hoe y zal reageren voor elke variabele x afzonderlijk genomen.

Laten we een voorbeeld bekijken. Stel je voor dat je de verkoop van een ijssalon wilt voorspellen. De dataset bevat verschillende informatie, zoals het weer (dwz regenachtig, zonnig, bewolkt), klantinformatie (dwz salaris, geslacht, burgerlijke staat).

Traditionele analyse zal proberen de verkoop te voorspellen door bijvoorbeeld het gemiddelde voor elke variabele te berekenen en de verkoop voor verschillende scenario's te schatten. Het zal leiden tot slechte voorspellingen en de analyse beperken tot het gekozen scenario.

Als u lineaire regressie gebruikt, kunt u deze vergelijking schrijven:

Train een lineair regressiemodel

Het algoritme vindt de beste oplossing voor de gewichten; het betekent dat het zal proberen de kosten (het verschil tussen de gepaste lijn en de datapunten) te minimaliseren.

Hoe het algoritme werkt

Werking van algoritme

Het algoritme kiest voor elk een willekeurig getal Lineaire regressie met TensorFlow en Werking van algoritme en vervang de waarde van x om de voorspelde waarde van y te krijgen. Als de dataset 100 waarnemingen bevat, berekent het algoritme 100 voorspelde waarden.

We kunnen de fout berekenen, opgemerkt Werking van algoritme van het model, wat het verschil is tussen de voorspelde waarde en de werkelijke waarde. Een positieve fout betekent dat het model de voorspelling van y onderschat, en een negatieve fout betekent dat het model de voorspelling van y overschat.

Werking van algoritme

Je doel is om het kwadraat van de fout te minimaliseren. Het algoritme berekent het gemiddelde van de kwadratische fout. Deze stap wordt het minimaliseren van de fout genoemd. Voor lineaire regressie is de Gemiddelde kwadratische fout, ook wel MSE genoemd. Wiskundig gezien is het:

Werking van algoritme

Waar:

  • Werking van algoritme zijn de gewichten zo? Werking van algoritme verwijst naar de voorspelde waarde
  • y zijn de echte waarden
  • m is het aantal waarnemingen

Merk op dat Werking van algoritme betekent dat het de transpositie van de matrices gebruikt. De Werking van algoritme is de wiskundige notatie van het gemiddelde.

Het doel is om de beste te vinden Werking van algoritme die de MSE minimaliseren

Als de gemiddelde fout groot is, betekent dit dat het model slecht presteert en dat de gewichten niet goed zijn gekozen. Om de gewichten te corrigeren, moet u een optimizer gebruiken. De traditionele optimizer wordt genoemd Gradient Afdaling.

De gradiëntafdaling neemt de afgeleide en verlaagt of verhoogt het gewicht. Als de afgeleide positief is, wordt het gewicht verlaagd. Als de afgeleide negatief is, neemt het gewicht toe. Het model zal de gewichten bijwerken en de fout opnieuw berekenen. Dit proces wordt herhaald totdat de fout niet meer verandert. Elk proces wordt een genoemd herhaling. Bovendien worden de gradiënten vermenigvuldigd met een leerpercentage. Het geeft de snelheid van het leren aan.

Als de leersnelheid te klein is, zal het erg lang duren voordat het algoritme convergeert (dat wil zeggen dat er veel iteraties nodig zijn). Als de leersnelheid te hoog is, zal het algoritme mogelijk nooit convergeren.

Werking van algoritme

Je kunt op de afbeelding hierboven zien dat het model het proces ongeveer twintig keer eerder herhaalt om een ​​stabiele waarde voor de gewichten te vinden, waardoor de laagste fout wordt bereikt.

Merk op dat, de fout is niet gelijk aan nul, maar stabiliseert rond 5. Dit betekent dat het model een typische fout van 5 maakt. Als u de fout wilt verkleinen, moet u meer informatie aan het model toevoegen, zoals meer variabelen, of andere schatters gebruiken. .

Je herinnert je de eerste vergelijking

Werking van algoritme

De eindgewichten zijn 3.8 en 2.78. De onderstaande video laat zien hoe de gradiëntafdaling de verliesfunctie optimaliseert om deze gewichten te vinden

Hoe u een lineaire regressie traint met TensorFlow

Nu u beter begrijpt wat er achter de motorkap gebeurt, bent u klaar om de schatter-API van TensorFlow te gebruiken om uw eerste lineaire regressie te trainen met behulp van TensorFlow.

U gebruikt de Boston Dataset, die de following variabelen

crimineel criminaliteit per hoofd van de bevolking per stad
zn aandeel van de residentiële grond bestemd voor kavels van meer dan 25,000 vierkante meter.
onnodig aandeel van het areaal niet-detailhandelsbedrijven per stad.
nox concentratie stikstofoxiden
rm gemiddeld aantal kamers per woning
leeftijd aandeel koopwoningen gebouwd vóór 1940
dis gewogen afstanden tot vijf werkgelegenheidscentra in Boston
belasting onroerendgoedbelasting over de volledige waarde per dollar 10,000
ptratio leerling-leraar-ratio per stad
met V Mediaanwaarde van koopwoningen in duizend dollar

U maakt drie verschillende datasets:

dataset doel van de persoon vorm
Trainingen Train het model en verkrijg de gewichten 400, 10
Evaluatie Evalueer de prestaties van het model op basis van onzichtbare gegevens 100, 10
Voorspellen Gebruik het model om de woningwaarde te voorspellen op basis van nieuwe gegevens 6, 10

Het doel is om de kenmerken van de dataset te gebruiken om de waarde van het huis te voorspellen.

Tijdens het tweede deel van de tutorial leert u hoe u TensorFlow op drie verschillende manieren kunt gebruiken om de gegevens te importeren:

  • Met Panda's
  • met numpy
  • Alleen TF

Let op, alle opties dezelfde resultaten opleveren.

Je leert hoe je de high-level API kunt gebruiken om een ​​TensorFlow lineair regressiemodel te bouwen, trainen en evalueren. Als u de low-level API gebruikte, moest u met de hand het volgende definiëren:

  • Verliesfunctie
  • Optimaliseren: Gradiëntafdaling
  • Vermenigvuldiging van matrices
  • Grafiek en tensor

Dit is vervelend en ingewikkelder voor beginners.

Pandas

U moet de benodigde bibliotheken importeren om het model te trainen.

import pandas as pd
from sklearn import datasets
import tensorflow as tf
import itertools

Stap 1) Importeer de gegevens met panda.

U definieert de kolomnamen en slaat deze op in COLUMNS. U kunt pd.read_csv() gebruiken om de gegevens te importeren.

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

training_set = pd.read_csv(“E:/boston_train.csv”, skipinitialspace=True,skiprows=1, namen=COLUMNS)

test_set = pd.read_csv(“E:/boston_test.csv”, skipinitialspace=True,skiprows=1, namen=COLUMNS)

voorspelling_set = pd.read_csv(“E:/boston_predict.csv”, skipinitialspace=True,skiprows=1, namen=COLUMNS)

U kunt de vorm van de gegevens afdrukken.

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

uitgang

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

Merk op dat het label, dat wil zeggen uw y, is opgenomen in de dataset. U moet dus twee andere lijsten definiëren. Eén met alleen de kenmerken en één met alleen de naam van het label. Deze twee lijsten vertellen uw schatter wat de kenmerken in de gegevensset zijn en welke kolomnaam het label is

Het wordt gedaan met de onderstaande code.

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

Stap 2) Converteer de gegevens

U moet de numerieke variabelen in het juiste formaat converteren. Tensorflow biedt een methode om continue variabelen te converteren: tf.feature_column.numeric_column().

In de vorige stap definieert u een lijst met objecten die u in het model wilt opnemen. Nu kunt u deze lijst gebruiken om ze in numerieke gegevens om te zetten. Als u features in uw model wilt uitsluiten, kunt u een of meer variabelen in de lijst FEATURES plaatsen voordat u de feature_cols construeert

Merk op dat u Python-lijstbegrip zult gebruiken met de lijst FEATURES om een ​​nieuwe lijst te maken met de naam feature_cols. Het helpt u te voorkomen dat u negen keer tf.feature_column.numeric_column() schrijft. Lijstbegrip is een snellere en schonere manier om nieuwe lijsten te maken

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

Stap 3) Definieer de schatter

In deze stap moet u de schatter definiëren. Tensorflow biedt momenteel zes vooraf gebouwde schatters, waaronder drie voor de classificatietaak en drie voor de TensorFlow-regressietaak:

  • Regressor
    • DNNRegressor
    • Lineaire regressor
    • DNNLineaCombinedRegressor
  • classifier
    • DNNClassificator
    • Lineaire Classificator
    • DNNLineaCombinedClassifier

In deze zelfstudie gebruikt u de lineaire regressor. Om toegang te krijgen tot deze functie moet u tf.estimator gebruiken.

De functie heeft twee argumenten nodig:

  • feature_columns: Bevat de variabelen die in het model moeten worden opgenomen
  • model_dir: pad om de grafiek op te slaan, de modelparameters op te slaan, enz

Tensorflow maakt automatisch een bestand met de naam train in uw werkmap. U moet dit pad gebruiken om toegang te krijgen tot het Tensorboard, zoals weergegeven in het onderstaande TensorFlow-regressievoorbeeld.

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

uitgang

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}

Het lastige bij TensorFlow is de manier waarop het model wordt gevoed. Tensorflow is ontworpen om te werken met parallel computergebruik en een zeer grote dataset. Vanwege de beperking van de machinebronnen is het onmogelijk om het model in één keer met alle gegevens te voeden. Daarvoor moet u elke keer een batch gegevens invoeren. Houd er rekening mee dat we het hebben over een enorme dataset met miljoenen of meer records. Als u geen batch toevoegt, krijgt u een geheugenfout.

Als uw gegevens bijvoorbeeld 100 waarnemingen bevatten en u een batchgrootte van 10 definieert, betekent dit dat het model voor elke iteratie 10 waarnemingen ziet (10*10).

Wanneer het model alle gegevens heeft gezien, maakt het er één af tijdperk. Een tijdperk definieert hoe vaak u wilt dat het model de gegevens ziet. Het is beter om deze stap op nul in te stellen en het model een iteratieaantal keer te laten uitvoeren.

Een tweede informatie die u moet toevoegen, is of u de gegevens vóór elke iteratie in willekeurige volgorde wilt afspelen. Tijdens de training is het belangrijk om de gegevens in willekeurige volgorde af te spelen, zodat het model geen specifiek patroon van de dataset leert. Als het model de de leerttails van het onderliggende patroon van de gegevens, zal het moeilijk zijn om de voorspelling voor onzichtbare gegevens te generaliseren. Dit heet overfitting. Het model presteert goed op de trainingsgegevens, maar kan niet correct voorspellen voor ongeziene gegevens.

TensorFlow maakt deze twee stappen eenvoudig uit te voeren. Wanneer de gegevens naar de pijplijn gaan, weet het hoeveel waarnemingen het nodig heeft (batch) en of het de gegevens moet schudden.

Om Tensorflow te instrueren hoe het model moet worden gevoed, kunt u pandas_input_fn gebruiken. Dit object heeft 5 parameters nodig:

  • x: kenmerkgegevens
  • y: labelgegevens
  • batch_grootte: batch. Standaard 128
  • num_epoch: Aantal tijdperken, standaard 1
  • shuffle: Shuffle of niet de gegevens. Standaard Geen

U moet het model vele malen invoeren, dus u definieert een functie om dit proces te herhalen. al deze functie 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)

De gebruikelijke methode om de prestaties van een model te evalueren is:

  • Train het model
  • Evalueer het model in een andere dataset
  • Maak voorspelling

Tensorflow Estimator biedt drie verschillende functies om deze drie stappen eenvoudig uit te voeren.

Stap 4): Train het model

U kunt de schattertrein gebruiken om het model te evalueren. De treinschatter heeft een input_fn en een aantal stappen nodig. U kunt de functie die u hierboven hebt gemaakt gebruiken om het model te voeden. Vervolgens geeft u het model de opdracht om 1000 keer te itereren. Merk op dat u het aantal tijdperken niet specificeert, maar dat u het model 1000 keer laat itereren. Als u het aantal tijdperken instelt op 1, herhaalt het model 4 keer: er zijn 400 records in de trainingsset en de batchgrootte is 128

  1. 128 rijen
  2. 128 rijen
  3. 128 rijen
  4. 16 rijen

Daarom is het eenvoudiger om het aantal tijdperken op nul in te stellen en het aantal iteraties te definiëren, zoals weergegeven in het onderstaande voorbeeld van de TensorFlow-classificatie.

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

uitgang

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.

U kunt het Tensorboard als volgt controlerenwing opdracht:

activate hello-tf
# For MacOS
tensorboard --logdir=./train
# For Windows
tensorboard --logdir=train

Stap 5) Evalueer uw model

Met de onderstaande code kunt u de pasvorm van uw model op de testset beoordelen:

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

uitgang

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

Met onderstaande code kunt u de schade uitprinten:

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

uitgang

Loss: 3215.895996

Het model heeft een verlies van 3215. U kunt de samenvattende statistiek bekijken om een ​​idee te krijgen van hoe groot de fout is.

training_set['medv'].describe()

uitgang

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

Uit de samenvattende statistiek hierboven weet je dat de gemiddelde prijs voor een huis 22 duizend bedraagt, met een minimumprijs van 9 duizend en een maximum van 50 duizend. Het model maakt een typische fout van 3 dollar.

Stap 6) Maak de voorspelling

Ten slotte kunt u de schatter TensorFlow voorspellen om de waarde van 6 huizen in Boston te schatten.

y = estimator.predict(    
         input_fn=get_input_fn(prediction_set,                          
         num_epochs=1,                          
         n_batch = 128,                          
         shuffle=False))

Om de geschatte waarden van af te drukken, kunt u deze code gebruiken:

predictions = list(p["predictions"] for p in itertools.islice(y, 6))print("Predictions: {}".format(str(predictions)))

uitgang

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

Het model voorspelde het volgendewing waarden:

Huis Voorspelling
1 32.29
2 18.96
3 27.27
4 29.29
5 16.43
7 21.46

Houd er rekening mee dat we de werkelijke waarde van . In de tutorial over deep learning probeer je het lineaire model te verslaan

Numpy-oplossing

In deze sectie wordt uitgelegd hoe u het model traint met behulp van een numpy-schatter om de gegevens in te voeren. De methode is hetzelfde, behalve dat u de numpy_input_fn-schatter gebruikt.

training_set_n = pd.read_csv(“E:/boston_train.csv”).waarden

test_set_n = pd.read_csv(“E:/boston_test.csv”).waarden

voorspelling_set_n = pd.read_csv(“E:/boston_predict.csv”).waarden

Stap 1) Importeer de gegevens

Allereerst moet u de kenmerkvariabelen onderscheiden van het label. Dit moet je doen voor de trainingsgegevens en evaluatie. Het is sneller om een ​​functie te definiëren om de gegevens te splitsen.

def prepare_data(df):     
        X_train = df[:, :-3]    
        y_train = df[:,-3]    
        return X_train, y_train

U kunt de functie gebruiken om het label te splitsen van de kenmerken van de trein/evaluatie-dataset

X_train, y_train = prepare_data(training_set_n)
X_test, y_test = prepare_data(test_set_n)

U moet de laatste kolom van de voorspellingsgegevensset uitsluiten omdat deze alleen NaN bevat

x_predict = prediction_set_n[:, :-2]

Bevestig de vorm van de array. Merk op dat het label geen dimensie mag hebben, het betekent (400,).

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

uitgang

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

U kunt de featurekolommen als volgt opbouwen:

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

De schatter is gedefinieerd zoals voorheen, u geeft instructies aan de functiekolommen en waar de grafiek moet worden opgeslagen.

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

uitgang

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}

U kunt de numpy-schatting gebruiken om de gegevens aan het model toe te voegen en het model vervolgens te trainen. Merk op dat we de input_fn-functie eerder definiëren om de leesbaarheid te vergemakkelijken.

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

uitgang

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>

U repliceert dezelfde stap met een andere schatter om uw model te evalueren

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)

uitgang

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}

Ten slotte kunt u de voorspelling berekenen. Het zou hetzelfde moeten zijn als panda's.

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

uitgang

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

Tensorflow-oplossing

Het laatste gedeelte is gewijd aan een TensorFlow-oplossing. Deze methode is iets ingewikkelder dan de andere.

Houd er rekening mee dat als u Jupyter notitieboekje, moet u de kernel opnieuw opstarten en opschonen om deze sessie uit te voeren.

TensorFlow heeft een geweldig hulpmiddel gebouwd om de gegevens in de pijplijn door te geven. In deze sectie bouwt u zelf de functie input_fn.

Stap 1) Definieer het pad en het formaat van de gegevens

Allereerst declareer je twee variabelen met het pad van het csv-bestand. Houd er rekening mee dat u twee bestanden heeft, één voor de trainingsset en één voor de testset.

import tensorflow as tf
df_train = "E:/boston_train.csv"
df_eval = "E:/boston_test.csv"

Vervolgens moet u de kolommen definiëren die u wilt gebruiken vanuit het csv-bestand. We zullen alles gebruiken. Daarna moet u het type variabele declareren.

Floats-variabelen worden gedefinieerd door [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]]

Stap 2) Definieer de input_fn-functie

De functie kan in drie delen worden opgesplitst:

  1. Importeer de gegevens
  2. Maak de iterator
  3. Consumeer de gegevens

Hieronder vindt u de algemene code om de functie te definiëren. De code wordt hierna uitgelegd

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

** Importeer de gegevens**

Voor een csv-bestand leest de datasetmethode regel voor regel. Om de gegevensset te bouwen, moet u het object gebruiken TextLineGegevensset. Uw dataset heeft een header, dus u moet skip(1) gebruiken om de eerste regel over te slaan. Op dit punt leest u alleen de gegevens en sluit u de header in de pijplijn uit. Om het model te voeden, moet u de kenmerken van het label scheiden. De methode die wordt gebruikt om elke transformatie op de gegevens toe te passen, is kaart.

Deze methode roept een functie aan die u gaat maken om te instrueren hoe u de gegevens moet transformeren. In een notendop moet u de gegevens doorgeven in de TextLineDataset-object, sluit de header uit en pas een transformatie toe die wordt geïnstrueerd door een functie. Code-uitleg

  • tf.data.TextLineDataset(data_file): Deze regel leest het csv-bestand
  • .skip(1): sla de header over
  • .map(parse_csv)): parseer de records in de tensors. U moet een functie definiëren om het kaartobject instructies te geven. Je kunt deze functie parse_csv aanroepen.

Deze functie parseert het csv-bestand met de methode tf.decode_csv en declares de kenmerken en het etiket. De functies kunnen worden gedeclareerd als een woordenboek of een tupel. U gebruikt de woordenboekmethode omdat dit handiger is. Code-uitleg

  • tf.decode_csv(value, record_defaults= RECORDS_ALL): de methode decode_csv gebruikt de uitvoer van de TextLineGegevensset om het csv-bestand te lezen. record_defaults instrueert TensorFlow over het kolomtype.
  • dict(zip(_CSV_COLUMNS, columns)): Vul het woordenboek in met alle kolommen die tijdens deze gegevensverwerking zijn geëxtraheerd
  • features.pop('median_house_value'): Sluit de doelvariabele uit van de featurevariabele en maak een labelvariabele

De dataset heeft verdere elementen nodig om de tensoren iteratief te voeden. U moet inderdaad de methodeherhaling toevoegen om ervoor te zorgen dat de dataset voor onbepaalde tijd doorgaat met het voeden van het model. Als u de methode niet toevoegt, herhaalt het model slechts één keer en genereert vervolgens een fout omdat er geen gegevens meer in de pijplijn worden ingevoerd.

Daarna kunt u de batchgrootte regelen met de batchmethode. Het betekent dat u de dataset vertelt hoeveel gegevens u voor elke iteratie in de pijplijn wilt doorgeven. Als u een grote batchgrootte instelt, zal het model traag zijn.

Stap 3) Maak de iterator

Nu bent u klaar voor de tweede stap: maak een iterator om de elementen in de dataset terug te geven.

De eenvoudigste manier om een ​​operator te maken is met de methode make_one_shot_iterator.

Daarna kunt u de functies en labels maken vanuit de iterator.

Stap 4) Consumeer de gegevens

U kunt controleren wat er gebeurt met de input_fn-functie. U moet de functie in een sessie aanroepen om de gegevens te verbruiken. Je probeert het met een batchgrootte gelijk aan 1.

Merk op dat het de functies in een woordenboek en het label als een array afdrukt.

Het toont de eerste regel van het csv-bestand. U kunt proberen deze code vele malen uit te voeren met verschillende batchgroottes.

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)

uitgang

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

Stap 4) Definieer de functiekolom

U moet de numerieke kolommen als volgt definiëren:

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

Houd er rekening mee dat u alle variabelen in een bucket moet combineren

base_columns = [X1, X2, X3,X4, X5, X6,X7, X8, X9]

Stap 5) Bouw het model

U kunt het model trainen met de schatter LinearRegressor.

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

uitgang

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}

U moet een lambda-functie gebruiken om het argument in de functie input_fn te kunnen schrijven. Als u geen gebruik maakt van een lambda-functie, kunt u het model niet trainen.

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

uitgang

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>

Met de onderstaande code kunt u de pasvorm van uw model op de testset beoordelen:

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

uitgang

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

De laatste stap is het voorspellen van de waarde van op basis van de waarde van , de matrices van de kenmerken. U kunt een woordenboek schrijven met de waarden die u wilt voorspellen. Uw model heeft 9 kenmerken, dus u moet voor elk een waarde opgeven. Het model zal voor elk van hen een voorspelling doen.

In de onderstaande code hebt u de waarden geschreven van alle functies die zich in het df_predict csv-bestand bevinden.

U moet een nieuwe input_fn-functie schrijven omdat er geen label in de gegevensset aanwezig is. U kunt de API from_tensor uit de gegevensset gebruiken.

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)

Ten slotte drukt u de voorspellingen af.

for pred in enumerate(pred_results):    
print(pred)

uitgang

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

Samengevat

Om een ​​model te trainen, moet je:

  • Definieer de kenmerken: Onafhankelijke variabelen: X
  • Definieer het label: Afhankelijke variabele: y
  • Bouw een trein/testset
  • Definieer het initiële gewicht
  • Definieer de verliesfunctie: MSE
  • Optimaliseer het model: Gradiëntafdaling
  • Bepalen:
    • Leren tarief
    • Aantal tijdperk
    • Seriegrootte

In deze zelfstudie hebt u geleerd hoe u de API op hoog niveau kunt gebruiken voor een TensorFlow-schatter voor lineaire regressie. U moet definiëren:

  1. Functiekolommen. Indien continu: tf.feature_column.numeric_column(). U kunt een lijst vullen met Python-lijstbegrip
  2. De schatter: tf.estimator.LinearRegressor(feature_columns, model_dir)
  3. Een functie om de gegevens, de batchgrootte en het tijdperk te importeren: input_fn()

Daarna bent u klaar om te trainen, evalueren en voorspellingen te doen met train(), evalueren() en voorspellen()