Zelfstudie lineaire regressie met TensorFlow [Voorbeelden]
Evelien Clarke
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 high-level API. TensorFlow noemt ze estimators
- API op laag niveau: Bouw de architectuur, optimaliseer het model vanaf nul. Het is ingewikkeld voor een beginner
- API op hoog niveau: Definieer het algoritme. Het is gebruiksvriendelijker. TensorFlow biedt een toolbox genaamd 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.
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 je taak is om de waarde van te voorspellen door de waarde van te weten. Als je de data plot, zie je een positieve relatie tussen je onafhankelijke variabele, x en je afhankelijke variabele y.
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:
Met:
is de vooringenomenheid. dwz als x=0, y=
is het gewicht geassocieerd met x
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 het model toepast en de volgende oplossing vindt voor:
- = 3.8
- = 2.78
Je kunt deze getallen in de vergelijking vervangen, dan wordt het:
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.
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 (bijv. regenachtig, zonnig, bewolkt), klantgegevens (bijv. 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:
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
Het algoritme kiest voor elk een willekeurig getal 
en 
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 
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.
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:
Waar:
zijn de gewichten zo? 
verwijst naar de voorspelde waarde- y zijn de echte waarden
- m is het aantal waarnemingen
verwijst naar de voorspelde waardeMerk op dat 
betekent dat het de transpositie van de matrices gebruikt. De 
is de wiskundige notatie van het gemiddelde.
Het doel is om de beste te vinden 
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.
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
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 volgende variabelen bevat
| 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 |
|---|---|---|
| Opleiding | 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
Houd er rekening mee dat u zult gebruiken Python lijstbegrip met de lijst FEATURES om een nieuwe lijst met de naam feature_cols te maken. 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 voor elke iteratie wilt schudden. Tijdens de training is het belangrijk om de gegevens te schudden, 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 moeilijk zijn om de voorspelling voor ongeziene gegevens te generaliseren. Dit wordt genoemd 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
- 128 rijen
- 128 rijen
- 128 rijen
- 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 controleren met de volgende 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 de volgende 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:
- Importeer de gegevens
- Maak de iterator
- 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 declareert de features en het label. De features kunnen worden gedeclareerd als een dictionary of een tuple. U gebruikt de dictionary-methode omdat deze handiger is. Uitleg van de code
- 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)})
Samenvatting
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:
- Functiekolommen. Indien continu: tf.feature_column.numeric_column(). U kunt een lijst vullen met Python-lijstbegrip
- De schatter: tf.estimator.LinearRegressor(feature_columns, model_dir)
- 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()
