Lineær regresjonsveiledning med TensorFlow [Eksempler]

Hva er lineær regresjon?

lineær regresjon er en tilnærming innen statistikk for modellering av sammenhenger mellom to variabler. Denne modelleringen gjøres mellom en skalar respons og en eller flere forklarende variabler. Sammenhengen med én forklarende variabel kalles enkel lineær regresjon, og med mer enn én forklarende variabel kalles den multippel lineær regresjon.

TensorFlow gir verktøy for å ha full kontroll over beregningene. Dette gjøres med lavnivå-API. På toppen av det er TensorFlow utstyrt med et stort utvalg av APIer for å utføre mange maskinlæring algoritmer. Dette er API-et på høyt nivå, og TensorFlow kaller dem estimatorer.

• API på lavt nivåBygg arkitekturen og optimaliseringen av modellen fra bunnen av. Det er komplisert for en nybegynner.
• API på høyt nivåDefiner algoritmen. Den er brukervennlig. TensorFlow tilbyr en verktøykasse kalt estimator å konstruere, trene, evaluere og lage en prediksjon.

I denne opplæringen vil du bruke bare estimatorerBeregningene er raskere og enklere å implementere. Den første delen forklarer hvordan du bruker gradient descent optimizer til å trene en lineær regresjon i TensorFlow. I en andre del skal du bruke Boston-datasettet til å forutsi prisen på et hus ved hjelp av en TensorFlow estimator.

Last ned Boston DataSet

Hvordan trene en lineær regresjonsmodell

Før vi begynner å trene modellen, la oss se på hva en lineær regresjon egentlig er.

Tenk deg at du har to variabler, x og y, og oppgaven din er å forutsi verdien av y når du kjenner verdien av x. Hvis du plotter dataene, kan du se en positiv sammenheng mellom den uavhengige variabelen, x, og den avhengige variabelen, y, som spredningsplottet nedenfor viser.

Du kan observere at hvis x=1, vil y omtrent være lik 6, og hvis x=2, vil y være rundt 8.5.

Dette er ikke en veldig nøyaktig metode og er utsatt for feil, spesielt med et datasett som inneholder hundretusenvis av punkter.

En lineær regresjon evalueres med en ligning. Variabelen y forklares av en eller flere kovariater. I ditt eksempel er det bare én avhengig variabel. Hvis du må skrive denne ligningen, vil den være:

Med:

• er skjevheten. Det vil si at hvis x=0, er y=
• er vekten assosiert med x
• er residualet, eller modellens feil. Den inkluderer hva modellen ikke kan lære fra dataene

Tenk deg at du passer modellen og du finner følgende løsning for:

• = 3.8
• = 2.78

Du kan erstatte disse tallene i ligningen og det blir:

y= 3.8 + 2.78x

Nå har du en bedre måte å finne verdiene for y på. Det vil si at du kan erstatte x med en hvilken som helst verdi du ønsker for å forutsi y. I bildet nedenfor har vi erstattet x i ligningen med alle verdiene i datasettet og plottet resultatet.

Den røde linjen representerer den tilpassede verdien, det vil si verdiene av y for hver verdi av x. Du trenger ikke å se verdien av x for å forutsi y; for hver x er det en verdi som tilhører den røde linjen. Du kan også forutsi verdier av x som er høyere enn 2.

Hvis du vil utvide den lineære regresjonen til flere kovariater, kan du gjøre det ved å legge til flere variabler i modellen. Forskjellen mellom tradisjonell analyse og lineær regresjon er at lineær regresjon ser på hvordan y vil reagere for hver variabel x tatt uavhengig.

La oss se på et eksempel. Tenk deg at du vil forutsi salget til en iskrembutikk. Datasettet inneholder forskjellig informasjon, som vær (regn, sol, overskyet) og kundeinformasjon (lønn, kjønn, sivilstatus).

Tradisjonell analyse vil forsøke å forutsi salget ved, la oss si, å beregne gjennomsnittet for hver variabel og forsøke å estimere salget for ulike scenarier. Dette vil føre til dårlige forutsigelser og begrense analysen til det valgte scenariet.

Hvis du bruker lineær regresjon, kan du skrive denne ligningen:

Algoritmen vil finne den beste løsningen for vektene; det betyr at den vil prøve å minimere kostnaden, som er forskjellen mellom den tilpassede linjen og datapunktene.

Hvordan algoritmen fungerer

Diagrammet nedenfor oppsummerer løkken algoritmen gjentar: velg vekter, forutsi y-verdien, mål feilen og korriger vektene.

Algoritmen vil velge et tilfeldig tall for hver og og erstatte verdien av x for å få den anslåtte verdien av y. Hvis datasettet har 100 observasjoner, beregner algoritmen 100 predikerte verdier.

Vi kan beregne feilen, bemerket , av modellen, som er forskjellen mellom den predikerte verdien og den virkelige verdien. En positiv feil betyr at modellen undervurderer prediksjonen av y, og en negativ feil betyr at modellen overvurderer prediksjonen av y.

Målet ditt er å minimere kvadratet av feilen. Algoritmen beregner gjennomsnittet av kvadratfeilen. Dette trinnet kalles minimering av feilen. For lineær regresjon er dette Mean Square Feil, også kalt MSE. Matematisk er det:

Hvor:

• er vektene, så refererer til den anslåtte verdien
• y er de virkelige verdiene
• m er antall observasjoner

Legg merke til at betyr at den bruker transponeringen av matrisene. De er den matematiske notasjonen av gjennomsnittet.

Målet er å finne de beste som minimerer MSE.

Hvis gjennomsnittsfeilen er stor, betyr det at modellen yter dårlig og vektene ikke er riktig valgt. For å korrigere vektene må du bruke en optimizer. Den tradisjonelle optimizeren kalles Gradient Nedstigning.

Gradientnedgangen tar den deriverte og reduserer eller øker vekten. Hvis den deriverte er positiv, reduseres vekten. Hvis den deriverte er negativ, øker vekten. Modellen vil oppdatere vektene og beregne feilen på nytt. Denne prosessen gjentas til feilen ikke lenger endres. Hver passering kalles en køyringDessuten multipliseres gradientene med en læringshastighet, som indikerer læringshastigheten.

Hvis læringsraten er for liten, vil det ta svært lang tid for algoritmen å konvergere, fordi den krever mange flere iterasjoner. Hvis læringsraten er for høy, kan det hende at algoritmen aldri konvergerer. Tapskurven nedenfor plotter feilen mot iterasjonsantallet for dette datasettet.

Du kan se fra bildet ovenfor at modellen gjentar prosessen omtrent 20 ganger før den finner en stabil verdi for vektene, og dermed når den laveste feilen.

Merk at feilen ikke er lik null, men stabiliserer seg rundt 5. Det betyr at modellen har en typisk feil på 5. Hvis du vil redusere feilen, må du legge til mer informasjon i modellen, for eksempel flere variabler, eller bruke forskjellige estimatorer.

Du husker den første ligningen:

De endelige vektene er 3.8 og 2.78. Videoen nedenfor viser deg hvordan gradientnedgangen optimaliserer tapsfunksjonen for å finne disse vektene.

Hvordan trene en lineær regresjon med TensorFlow

Nå som du har en bedre forståelse av hva som skjer bak panseret, er du klar til å bruke estimator-APIet levert av TensorFlow for å trene din første lineære regresjon ved hjelp av TensorFlow.

Versjonsmerknad: Estimatorarbeidsflyten som vises nedenfor ble skrevet mot TensorFlow 1.x og de tidlige 2.x-utgivelsene. TensorFlow markerte tf.estimator og tf.feature_column API-er ble fullstendig avskrevet i versjon 2.12 og Estimatorer ble fjernet i versjon 2.16. Kjør denne koden i en TensorFlow 1.15 eller 2.x-med- på en gjeldende installasjon.tf.compat.v1 miljø, eller porter det til Keras, hvor tf.keras.layers.Dense(1) pluss at forbehandlingslag erstatter LinearRegressor og funksjonskolonnene. Konseptene – funksjoner, etiketter, batcher, epoker, MSE og gradientnedstigning – fortsetter uendret.

Du skal bruke Boston-datasettet, som inkluderer følgende variabler.

Du vil lage tre forskjellige datasett:

Målet er å bruke funksjonene i datasettet til å forutsi verdien av huset.

I løpet av den andre delen av veiledningen lærer du hvordan du bruker TensorFlow med tre forskjellige måter å importere dataene på:

• Med pandaer
• Med nusset
• Bare TensorFlow

Merk at alle tre alternativene gir de samme resultatene.

Du lærer hvordan du bruker høynivå-API-et til å bygge, trene og evaluere en TensorFlow lineær regresjonsmodell. Hvis du brukte lavnivå-API-et, måtte du definere følgende manuelt:

• Tapsfunksjon
• Optimaliser: gradientnedstigning
• Matriksmultiplikasjon
• Graf og tensor

Dette er kjedelig og mer komplisert for en nybegynner.

Panda-løsning

Du må importere de nødvendige bibliotekene for å trene modellen.

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

Trinn 1) Importer dataene med pandaer.

Du definerer kolonnenavnene og lagrer dem i KOLONNER. Du kan bruke pd.read_csv() til å importere dataene.

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

Rett hvert anrop mot CSV-filene du lastet ned tidligere.

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)

Du kan skrive ut formen på dataene.

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

Produksjon

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

Merk at etiketten, det vil si y-verdien din, er inkludert i datasettet. Så du må definere to andre lister: én som bare inneholder funksjonene, og én som bare inneholder navnet på etiketten. Disse to listene vil fortelle estimatoren din hva funksjonene i datasettet er og hvilket kolonnenavn som er etiketten.

Det gjøres med koden nedenfor.

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

Trinn 2) Konverter dataene

Du må konvertere de numeriske variablene til riktig format. TensorFlow tilbyr en metode for å konvertere en kontinuerlig variabel: tf.feature_column.numeric_column().

I forrige trinn definerte du en liste over funksjoner du vil inkludere i modellen. Nå kan du bruke denne listen til å konvertere dem til numeriske data. Hvis du vil ekskludere funksjoner fra modellen, kan du gjerne fjerne én eller flere variabler fra listen FUNKSJONER før du konstruerer feature_cols.

Merk at du vil bruke en Python listeforståelse med listen FEATURES for å opprette en ny liste kalt feature_cols. Det hjelper deg å unngå å skrive tf.feature_column.numeric_column() ni ganger. En listeforståelse er en raskere og renere måte å opprette nye lister på.

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

Trinn 3) Definer estimatoren

I dette trinnet må du definere estimatoren. TensorFlow tilbyr seks forhåndsbygde, forhåndsbestemte estimatorer, tre for klassifiseringsoppgaver og tre for TensorFlow-regresjonsoppgaver:

• Regressor
  • DNNRegressor
  • LineærRegressor
  • DNNLineærKombinertRegressor
• klassifisere
  • DNNklassifiserer
  • LinearClassifier
  • DNNLineærKombinertKlassifikator

I denne opplæringen vil du bruke den lineære regressoren. For å få tilgang til denne funksjonen må du bruke tf.estimator.

Funksjonen trenger to argumenter:

• feature_columns: inneholder variablene som skal inkluderes i modellen
• model_dir: sti for å lagre grafen, lagre modellparametrene og så videre

TensorFlow vil automatisk opprette en mappe med navnet train i arbeidsmappen din. Du må bruke denne banen for å få tilgang. TensorBoard, som vist i TensorFlow-regresjonseksemplet nedenfor.

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

Produksjon

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}

Det vanskelige med TensorFlow er måten å mate modellen på. TensorFlow er designet for å fungere med parallell databehandling og veldig store datasett. På grunn av begrensningene i maskinressursene er det umulig å mate modellen med alle dataene samtidig. For å gjøre det må du mate en databatch hver gang. Merk at vi snakker om enorme datasett med millioner eller flere poster. Hvis du ikke legger til en batch, vil du ende opp med en minnefeil.

For eksempel, hvis dataene dine inneholder 100 observasjoner og du definerer en batchstørrelse på 10, betyr det at modellen vil se 10 observasjoner for hver iterasjon (10*10).

Når modellen har sett alle dataene, fullfører den én epoke. En epoke definerer hvor mange ganger du vil at modellen skal se dataene. Det er bedre å sette dette trinnet til ingen og la modellen utføre et angitt antall iterasjoner.

En annen informasjon å legge til er om du vil omstokke dataene før hver iterasjon. Under treningen er det viktig å omstokke dataene slik at modellen ikke lærer et spesifikt mønster i datasettet. Hvis modellen lærer detaljene i det underliggende mønsteret i dataene, vil den ha problemer med å generalisere prediksjonen for usynlige data. Dette kalles overtilpasning. Modellen yter bra på treningsdataene, men kan ikke forutsi riktig for usynlige data.

TensorFlow gjør disse to trinnene enkle å gjøre. Når dataene går til pipelinen, vet den hvor mange observasjoner den trenger (batch) og om den må omstokke dataene.

For å instruere TensorFlow hvordan modellen skal mates, kan du bruke pandas_input_fn. Dette objektet trenger fem parametere:

• x: funksjonsdata
• y: etikettdata
• batch_size: batch. Som standard 128
• num_epoch: antall epoker, som standard 1
• shuffle: bland dataene eller ikke. Som standard, Ingen

Du må mate modellen mange ganger, så du definerer en funksjon for å gjenta denne prosessen. Kall denne funksjonen 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)

Den vanlige metoden for å evaluere ytelsen til en modell er å:

• Tren modellen
• Evaluer modellen på et annet datasett
• Gjør en spådom

TensorFlow-estimatoren tilbyr tre forskjellige funksjoner for å utføre disse tre trinnene enkelt.

Trinn 4) Tren modellen

Du kan bruke estimator-togmetoden for å tilpasse modellen. Togestimatoren trenger en input_fn og en rekke trinn. Du kan bruke funksjonen du opprettet ovenfor for å mate modellen. Deretter instruerer du modellen til å iterere 1000 ganger. Merk at du ikke spesifiserer antall epoker; du lar modellen iterere 1000 ganger. Hvis du setter antall epoker til 1, vil modellen iterere fire ganger, fordi det er 400 poster i treningssettet og batchstørrelsen er 128:

1. 128 rader
2. 128 rader
3. 128 rader
4. 16 rader

Derfor er det enklere å sette antall epoker til ingen og definere antall iterasjoner, som vist i TensorFlow-klassifiseringseksemplet nedenfor.

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

Produksjon

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.

Du kan sjekke TensorBoard med følgende kommando:

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

Trinn 5) Vurder modellen din

Du kan evaluere passformen til modellen din på testsettet med koden nedenfor:

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

Produksjon

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

Du kan skrive ut tapet med koden nedenfor:

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

Produksjon

Loss: 3215.895996

Modellen har et tap på 3215. Du kan sjekke sammendragsstatistikken for å få en idé om hvor stor feilen er.

training_set['medv'].describe()

Produksjon

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

Fra den sammendragsmessige statistikken ovenfor vet du at gjennomsnittsprisen for et hus er 22 tusen, med en minimumspris på 5 tusen og et maksimum på 50 tusen. Fordi det rapporterte tapet er den gjennomsnittlige kvadratfeilen, er den typiske feilen i de opprinnelige enhetene omtrent kvadratroten av 32.16, som er omtrent 5.7 tusen dollar.

Trinn 6) Gjør spådommen

Til slutt kan du bruke estimatoren TensorFlows prediksjonsmetoden til å estimere verdien av seks hus i Boston.

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

For å skrive ut de estimerte verdiene kan du bruke denne koden:

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

Produksjon

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

Modellen forutsier følgende verdier:

Merk at vi ikke vet den sanne verdien av disse seks husene. I veiledningen for dyp læring skal du prøve å overgå den lineære modellen.

NumPy-løsning

Denne delen forklarer hvordan du trener modellen ved hjelp av en NumPy-estimator for å mate dataene. Metoden er den samme, bortsett fra at du bruker numpy_input_fn-estimatoren.

Les de samme tre CSV-filene, men behold bare de rå NumPy-arraysene med .values.

training_set_n = pd.read_csv("E:/boston_train.csv").values
test_set_n = pd.read_csv("E:/boston_test.csv").values
prediction_set_n = pd.read_csv("E:/boston_predict.csv").values

Trinn 1) Importer dataene

Først av alt må du skille funksjonsvariablene fra etiketten. Du må gjøre dette for treningsdataene og evalueringsdataene. Det er raskere å definere en funksjon for å dele dataene.

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

Du kan bruke funksjonen til å dele etiketten fra togets funksjoner og evaluere datasett.

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

Du må ekskludere den siste kolonnen i prediksjonsdatasettet fordi den bare inneholder NaN.

x_predict = prediction_set_n[:, :-2]

Bekreft formen på tabellen. Merk at etiketten ikke skal ha en andre dimensjon, som betyr (400,).

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

Produksjon

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

Du kan konstruere funksjonskolonnene slik:

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

Estimatoren er definert som før: du angir funksjonskolonnene og hvor grafen skal lagres.

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

Produksjon

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}

Du kan bruke NumPy-estimatoren til å mate dataene til modellen og deretter trene modellen. Merk at vi definerer input_fn-funksjonen på forhånd for å gjøre det enklere å lese.

# Train the estimator
train_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)

Produksjon

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>

Du gjentar det samme trinnet med en annen inputfunksjon for å evaluere modellen din.

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)

Produksjon

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}

Til slutt kan du beregne prediksjonen. Den skal være lik Pandas-resultatet.

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

Produksjon

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-løsning

Den siste delen er dedikert til en ren tensorflow løsning. Denne metoden er litt mer komplisert enn de to andre.

Merk at hvis du bruker en Jupyter bærbare, må du starte på nytt og tømme kjernen for å kjøre denne økten.

TensorFlow har bygget et flott verktøy for å sende data inn i pipelinen. I denne delen skal du bygge input_fn-funksjonen selv.

Trinn 1) Definer banen og formatet til dataene

Først deklarerer du to variabler med banen til CSV-filene. Merk at du har to filer, én for treningssettet og én for testsettet.

import tensorflow as tf

df_train = "E:/boston_train.csv"

df_eval = "E:/boston_test.csv"

Så må du definere kolonnene du vil bruke fra CSV-filen. Vi skal bruke alle. Etter det må du deklarere typen til hver variabel.

Flytvariabler er definert av [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]]

Trinn 2) Definer input_fn-funksjonen

Funksjonen kan deles inn i tre deler:

1. Importer dataene
2. Lag iteratoren
3. Konsumere dataene

Nedenfor finner du den overordnede koden for å definere funksjonen. Koden vil bli forklart senere.

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

Importer dataene

For en CSV-fil leser datasettmetoden én linje om gangen. For å bygge datasettet må du bruke objektet TextLineDatasett. Datasettet ditt har en header, så du må bruke skip(1) for å hoppe over den første linjen. På dette tidspunktet leser du bare dataene og ekskluderer headeren i pipelinen. For å mate modellen må du skille funksjonene fra etiketten. Metoden som brukes for å bruke enhver transformasjon på dataene er map.

Denne metoden kaller en funksjon du skal opprette for å instruere hvordan dataene skal transformeres. Kort sagt må du sende dataene inn i TextLineDatasettobjekt, ekskluder overskriften og bruk en transformasjon som er instruert av en funksjon.

Code forklaring

• tf.data.TextLineDataset(data_file): denne linjen leser CSV-filen
• .skip(1): hopper over overskriften
• .map(parse_csv)): analyserer postene til tensorene

Du må definere en funksjon for å instruere kartobjektet. Du kan kalle denne funksjonen parse_csv.

Denne funksjonen analyserer CSV-filen med metoden tf.decode_csv og deklarerer funksjonene og etiketten. Funksjonene kan deklareres som en ordbok eller en tuple. Du bruker ordbokmetoden fordi den er mer praktisk.

Code forklaring

• tf.decode_csv(verdi, record_defaults= RECORDS_ALL): metoden decode_csv bruker utdataene fra TextLineDatasett for å lese CSV-filen. record_defaults instruerer TensorFlow om kolonnetypene. I TensorFlow 2.x finnes dette symbolet på tf.io.decode_csv.
• dict(zip(COLUMNS, columns)): fyller ordboken med alle kolonnene f.eks.tracunder denne databehandlingen
• features.pop('medv'): ekskluderer målvariabelen fra funksjonsvariablene og oppretter en labelvariabel

Datasettet trenger ytterligere elementer for å iterativt mate tensorene. Du må faktisk legge til metoden «repeat» for å la datasettet fortsette i det uendelige å mate modellen. Hvis du ikke legger til metoden, vil modellen bare iterere én gang og deretter gi en feil fordi det ikke mates flere data inn i pipelinen.

Etter det kan du kontrollere batchstørrelsen med batchmetoden. Det betyr at du forteller datasettet hvor mye data du vil sende inn i pipelinen for hver iterasjon. Hvis du angir en stor batchstørrelse, vil modellen være treg.

Trinn 3) Lag iteratoren

Nå er du klar for det andre trinnet: lag en iterator for å returnere elementene i datasettet.

Den enkleste måten å lage en operator på er med metoden make_one_shot_iterator.

Etter det kan du lage funksjonene og etikettene fra iteratoren.

Trinn 4) Konsumere dataene

Du kan sjekke hva som skjer med input_fn-funksjonen. Du må kalle funksjonen i en økt for å konsumere dataene. Du prøver med en batchstørrelse lik 1.

Merk at den skriver ut funksjonene i en ordbok og etiketten som en matrise.

Den vil vise den første linjen i CSV-filen. Du kan prøve å kjøre denne koden mange ganger med forskjellige batchstørrelser.

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)

Produksjon

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

Trinn 5) Definer funksjonskolonnen

Du må definere de numeriske kolonnene som følger:

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 at du må kombinere alle variablene i en bøtte.

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

Trinn 6) Bygg modellen

Du kan trene modellen med estimatoren LinearRegressor.

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

Produksjon

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}

Du må bruke en lambda-funksjon slik at du kan skrive argumentene for funksjonen input_fn. Hvis du ikke bruker en lambda-funksjon, kan du ikke trene modellen.

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

Produksjon

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>

Du kan evaluere passformen til modellen din på testsettet med koden nedenfor:

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

Produksjon

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

Det siste trinnet er å forutsi verdien av målet basert på verdien av funksjonsmatrisen. Du kan skrive en ordbok med verdiene du vil forutsi. Modellen din har ni funksjoner, så du må oppgi en verdi for hver av dem. Modellen vil gi en prediksjon for hver av dem.

I koden nedenfor skriver du verdiene for hver funksjon som finnes i df_predict CSV-filen.

Du må skrive en ny input_fn-funksjon fordi det ikke finnes noen etikett i datasettet. Du kan bruke from_tensors API fra Dataset-objektet.

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_input
     pred_results = model.predict(input_fn=test_input_fn)

Til slutt skriver du ut spådommene.

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

Produksjon

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

Alle tre pipelines returnerer de samme seks prediksjonene, noe som bekrefter at valget mellom Pandas, NumPy og et native TensorFlow-datasett er et spørsmål om bekvemmelighet, ikke om nøyaktighet.

Spørsmål og svar