Lineaire regressie met TensorFlow (voorbeelden)

Inhoudsopgave:

Anonim

Wat is lineaire regressie?

Lineaire regressie is een statistische benadering voor het modelleren van relaties tussen twee variabelen. Deze modellering gebeurt 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 wordt deze meervoudige lineaire regressie genoemd.

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

  • Low-level API: bouw de architectuur, optimalisatie van het model vanaf nul. Het is ingewikkeld voor een beginner
  • API op hoog niveau: definieer het algoritme. Het is gemakkelijker vriendelijk. TensorFlow biedt een toolbox die een schatter aanroept om een ​​voorspelling op te bouwen, te trainen, te evalueren en te doen.

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

Download Boston DataSet

In deze TensorFlow Regression-zelfstudie leert u:

  • Wat is lineaire regressie?
  • Hoe een lineair regressiemodel te trainen
  • Hoe een lineaire regressie te trainen met TensorFlow
  • Panda's
  • Numpy-oplossing
  • Tensorflow-oplossing

Hoe een lineair regressiemodel te trainen

Laten we, voordat we beginnen met het trainen van het model, eens 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 te voorspellen van het kennen van de waarde van. Als u de gegevens plot, kunt u een positieve relatie zien tussen uw onafhankelijke variabele, x en uw afhankelijke variabele y.

U kunt zien dat als x = 1, y ongeveer gelijk is aan 6 en als x = 2, y ongeveer 8,5 zal zijn.

Dit is geen erg nauwkeurige methode en foutgevoelig, zeker niet 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 maar één afhankelijke variabele. Als je deze vergelijking moet schrijven, zal het zijn:

Met:

  • is het gewicht dat is gekoppeld aan x
  • is het residu of de fout van het model. Het bevat wat het model niet van de gegevens kan leren

Stel je voor dat je het model past en je vindt de volgende oplossing voor:

  • = 3,8
  • = 2,78

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

y = 3,8 + 2,78x

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

De rode lijn vertegenwoordigt de aangepaste waarde, dat zijn de waarden van y voor elke waarde van x. U hoeft de waarde van x niet te zien om y te voorspellen, voor elke x is er een die bij de rode lijn hoort. U kunt ook voorspellen voor waarden van x hoger dan 2!

Als u de lineaire regressie wilt uitbreiden naar meer covariaten, kunt u dit doen door meer variabelen aan het model toe te voegen. Het verschil tussen traditionele analyse en lineaire regressie is dat de lineaire regressie kijkt naar hoe y zal reageren voor elke variabele x onafhankelijk 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 (bijv. Regenachtig, zonnig, bewolkt), klantgegevens (bijv. Salaris, geslacht, burgerlijke staat).

Traditionele analyse zal proberen de verkoop te voorspellen door, laten we zeggen, het gemiddelde voor elke variabele te berekenen en proberen de verkoop voor verschillende scenario's te schatten. Het leidt tot slechte voorspellingen en beperkt de analyse tot het gekozen scenario.

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

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

Hoe het algoritme werkt

Het algoritme zal een willekeurig getal voor elk kiezen en vervang de waarde van x om de voorspelde waarde van y te krijgen. Als de dataset 100 waarnemingen heeft, berekent het algoritme 100 voorspelde waarden.

We kunnen de fout berekenen, genoteerd aan 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.

Uw 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 Mean Square Error , ook wel MSE genoemd. Wiskundig gezien is het:

Waar:

  • verwijst naar de voorspelde waarde
  • y is de echte waarden
  • m is het aantal waarnemingen

Merk op dat is de wiskundige notatie van het gemiddelde.

Het doel is om het beste te vinden dat de MSE minimaliseert

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 heet Gradient Descent .

De hellingafdaling neemt de afgeleide en vermindert 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 iteratie genoemd . Bovendien worden de hellingen vermenigvuldigd met een leertempo. Het geeft de snelheid van het leren aan.

Als het leertempo te laag is, duurt het erg lang voordat het algoritme convergeert (dat wil zeggen dat er veel iteraties nodig zijn). Als het leertempo te hoog is, kan het algoritme nooit convergeren.

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

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

U herinnert zich de eerste vergelijking

De uiteindelijke gewichten zijn 3,8 en 2,78. De onderstaande video laat zien hoe de hellingafdaling de verliesfunctie optimaliseert om deze gewichten te vinden

Hoe een lineaire regressie te trainen met TensorFlow

Nu je een beter begrip hebt van wat er achter de motorkap gebeurt, ben je klaar om de schatter-API van TensorFlow te gebruiken om je eerste lineaire regressie met TensorFlow te trainen.

U gebruikt de Boston Dataset, die de volgende variabelen bevat

criminaliteit criminaliteit per hoofd van de bevolking per stad
zn deel van de woongrond bestemd voor kavels van meer dan 25.000 m2.
indus aandeel van de niet-detailhandelareaal per stad.
nox stikstofoxiden concentratie
rm gemiddeld aantal kamers per woning
leeftijd aandeel van voor 1940 gebouwde koopwoningen
dis gewogen afstanden tot vijf arbeidsbureaus in Boston
belasting onroerende voorheffing over de volledige waarde per 10.000 dollar
ptratio leerling-leraar ratio per stad
medv Mediane waarde van koopwoningen in duizend dollar

U maakt drie verschillende datasets aan:

dataset objectief vorm
Opleiding Train het model en verkrijg de gewichten 400, 10
Evaluatie Evalueer de prestaties van het model op ongeziene 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 kunt gebruiken op drie verschillende manieren om de gegevens te importeren:

  • Met Panda's
  • Met Numpy
  • Alleen TF

Merk op dat alle opties dezelfde resultaten opleveren.

Je leert hoe je de high-level API gebruikt 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ënt afdaling
  • Matrices vermenigvuldiging
  • Grafiek en tensor

Dit is vervelend en ingewikkelder voor beginners.

Panda's

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

import pandas as pdfrom sklearn import datasetsimport tensorflow as tfimport 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, 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)

U kunt de vorm van de gegevens afdrukken.

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

Uitvoer

(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. Een met alleen de kenmerken en een met alleen de naam van het label. Deze twee lijsten zullen uw schatter vertellen wat de functies in de dataset 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 variabele te converteren: tf.feature_column.numeric_column ().

In de vorige stap definieerde u een lijst van een element dat u in het model wilt opnemen. Nu kunt u deze lijst gebruiken om ze om te zetten in numerieke gegevens. Als u objecten in uw model wilt uitsluiten, kunt u een of meer variabelen in de lijst FUNCTIES verwijderen voordat u de feature_cols construeert

Merk op dat je Python-lijstbegrip zult gebruiken met de lijst FUNCTIES om een ​​nieuwe lijst met de naam feature_cols te maken. Het helpt je om negen keer tf.feature_column.numeric_column () te schrijven. Een 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 6 vooraf gebouwde schatters, waaronder 3 voor classificatietaken en 3 voor TensorFlow-regressietaak:

  • Regressor
    • DNNRegressor
    • Lineaire regressor
    • DNNLineaCombinedRegressor
  • Classifier
    • DNNClassifier
    • Lineaire classificatie
    • DNNLineaCombinedClassifier

In deze tutorial gebruik je de Linear 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 zal automatisch een bestand aanmaken 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")

Uitvoer

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}

Het lastige met TensorFlow is de manier om het model te voeden. Tensorflow is ontworpen om te werken met parallel computing en zeer grote datasets. Vanwege de beperking van de machinebronnen is het onmogelijk om het model met alle gegevens tegelijk te voeden. Daarvoor moet u elke keer een batch gegevens invoeren. Merk op 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 definieert een batchgrootte van 10, betekent dit dat het model 10 waarnemingen voor elke iteratie zal zien (10 * 10).

Als het model alle gegevens heeft gezien, eindigt het een tijdperk . Een epoche definieert hoe vaak u wilt dat het model de gegevens ziet. Het is beter om deze stap op geen in te stellen en het model een iteratie-aantal tijd te laten uitvoeren.

Een tweede informatie die u moet toevoegen, is of u de gegevens voor elke iteratie in willekeurige volgorde wilt afspelen. Tijdens de training is het belangrijk om de data door elkaar te halen, zodat het model geen specifiek patroon van de dataset leert. Als het model de details van het onderliggende patroon van de gegevens leert, zal het problemen hebben om de voorspelling voor ongeziene gegevens te generaliseren. Dit wordt overfitting genoemd . Het model presteert goed op de trainingsgegevens, maar kan niet correct voorspellen voor ongeziene gegevens.

TensorFlow maakt deze twee stappen gemakkelijk uit te voeren. Wanneer de gegevens naar de pijplijn gaan, weet het hoeveel observaties het nodig heeft (batch) en of het de gegevens moet door elkaar halen.

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

  • x: feature data
  • y: label gegevens
  • batch_size: batch. Standaard 128
  • num_epoch: nummer van epoch, standaard 1
  • shuffle: de gegevens in willekeurige volgorde afspelen of niet. Standaard Geen

U moet het model meerdere keren voeden, 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-schatter biedt drie verschillende functies om deze drie stappen gemakkelijk 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 heeft gemaakt gebruiken om het model te voeden. Vervolgens geeft u het model opdracht om 1000 keer te herhalen. Merk op dat je niet het aantal tijdperken specificeert, je laat het model 1000 keer herhalen. Als u het aantal epoch op 1 instelt, 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 gemakkelijker om het aantal epoch op geen in te stellen en het aantal iteraties te definiëren, zoals weergegeven in het onderstaande TensorFlow-classificatievoorbeeld.

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

Uitvoer

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.

Je kunt controleren of het Tensorboard de volgende opdracht zal geven:

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

Stap 5) Evalueer uw model

U kunt de pasvorm van uw model op de testset beoordelen met de onderstaande code:

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

Uitvoer

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

U kunt het verlies afdrukken met de onderstaande code:

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

Uitvoer

Loss: 3215.895996

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

training_set['medv'].describe()

Uitvoer

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

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

Stap 6) Maak de voorspelling

Ten slotte kunt u de schatter TensorFlow-voorspelling gebruiken 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)))

Uitvoer

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

Het model voorspelt de volgende waarden:

Huis

Voorspelling

1

32.29

2

18,96

3

27.27

4

29.29

5

16.43

7

21.46

Merk op dat we de echte waarde van niet kennen. In de tutorial van deep learning probeer je het lineaire model te verslaan

Numpy-oplossing

In dit gedeelte wordt uitgelegd hoe u het model kunt trainen met behulp van een numpy-schatter om de gegevens in te voeren. De methode is dezelfde, behalve dat u numpy_input_fn Estimator gebruikt.

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

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

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

Stap 1) Importeer de gegevens

Allereerst moet u de kenmerkvariabelen onderscheiden van het label. U moet dit 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 / evaluatiedataset

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 afmeting mag hebben, het betekent (400,).

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

Uitvoer

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

U kunt de objectkolommen als volgt construeren:

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

De schatter is gedefinieerd zoals eerder, u instrueert de objectkolommen en waar de grafiek moet worden opgeslagen.

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

Uitvoer

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}

U kunt de numpy Estimapor gebruiken om de gegevens naar het model te sturen en vervolgens het model te trainen. Merk op dat we de functie input_fn eerder hebben gedefinieerd 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)

Uitvoer

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

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

Uitvoer

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}

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

Uitvoer

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

Tensorflow-oplossing

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

Merk op dat als u een Jupyter-notebook gebruikt, u de kernel opnieuw moet starten en opschonen om deze sessie uit te voeren.

TensorFlow heeft een geweldige tool gebouwd om de gegevens door te geven aan de pijplijn. In deze sectie bouw je 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. Merk op dat je twee bestanden hebt, een voor de trainingsset en een voor de testset.

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

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

Variabele vlotters 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 functie input_fn

De functie kan in drie delen worden opgesplitst:

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

Hieronder staat 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 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

** Importeer de gegevens **

Voor een csv-bestand leest de datasetmethode één regel tegelijk. Om de dataset op te bouwen, moet u het object TextLineDataset gebruiken. Uw dataset heeft een koptekst, 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 koptekst in de pijplijn uit. Om het model te voeden, moet u de kenmerken van het label scheiden. De methode die wordt gebruikt om een ​​transformatie op de gegevens toe te passen, is map.

Deze methode roept een functie aan die u gaat maken om te instrueren hoe de gegevens moeten worden getransformeerd. Kort samengevat, u moet de gegevens doorgeven aan het TextLineDataset-object, de header uitsluiten en een transformatie toepassen die wordt geïnstrueerd door een functie.

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

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

  • tf.decode_csv (waarde, record_defaults = RECORDS_ALL): de methode decode_csv gebruikt de uitvoer van de TextLineDataset om het csv-bestand te lezen. record_defaults instrueert TensorFlow over het type kolommen.
  • dict (zip (_CSV_COLUMNS, kolommen)): vul het woordenboek met alle kolommen die tijdens deze gegevensverwerking zijn geëxtraheerd
  • features.pop ('median_house_value'): sluit de doelvariabele uit van de kenmerkvariabele en maak een labelvariabele

De Dataset heeft meer elementen nodig om de Tensoren iteratief te voeden. U moet inderdaad de methodeherhaling toevoegen om de gegevensset voor onbepaalde tijd door te laten gaan met het voeden van het model. Als u de methode niet toevoegt, zal het model slechts één keer herhalen en vervolgens een fout genereren 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 ben je klaar voor de tweede stap: maak een iterator om de elementen in de dataset terug te sturen.

De eenvoudigste manier om een ​​operator aan 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 functie input_fn. U moet de functie in een sessie aanroepen om de gegevens te verbruiken. U probeert met een batchgrootte gelijk aan 1.

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

Het toont de eerste regel van het csv-bestand. U kunt deze code vaak proberen 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)

Uitvoer

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

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

Uitvoer

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}

U moet een lambda-functie gebruiken om het argument in de functie inpu_fn te kunnen schrijven. Als je geen lambda-functie gebruikt, kun je het model niet trainen.

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

Uitvoer

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

U kunt de pasvorm van uw model op de testset beoordelen met de onderstaande code:

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

Uitvoer

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

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

In de onderstaande code hebt u de waarden geschreven van elke functie die is opgenomen in het df_predict csv-bestand.

U moet een nieuwe functie input_fn schrijven omdat er geen label in de dataset is. U kunt de API from_tensor uit de Dataset 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 print u de voorspellingen.

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

Uitvoer

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

Overzicht

Om een ​​model te trainen, moet u:

  • Definieer de kenmerken: Onafhankelijke variabelen: X
  • Definieer het label: afhankelijke variabele: y
  • Bouw een trein / testset
  • Bepaal het begingewicht
  • Definieer de verliesfunctie: MSE
  • Optimaliseer het model: gradiënt afdaling
  • Bepalen:
    • Leersnelheid
    • 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 het volgende definiëren:

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

Daarna ben je klaar om te trainen, te evalueren en voorspellingen te doen met train (), evalu () en predict ()