Lineær regresjon med TensorFlow (eksempler)

Innholdsfortegnelse:

Anonim

Hva er lineær regresjon?

Lineær regresjon er en tilnærming i statistikk for modellering av forhold mellom to variabler. Denne modelleringen gjøres mellom en skalarrespons og en eller flere forklarende variabler. Forholdet til en forklarende variabel kalles enkel lineær regresjon, og for mer enn en forklarende variabel kalles den multippel lineær regresjon.

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

  • API på lavt nivå: Bygg arkitekturen, optimalisering av modellen fra bunnen av. Det er komplisert for en nybegynner
  • API på høyt nivå: Definer algoritmen. Det er lettere-vennlig. Tensorflow gir en verktøykasse samtaler estimator å konstruere, tog, evaluere og foreta en forutsigelse.

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

Last ned Boston DataSet

I denne TensorFlow regresjonsopplæringen lærer du:

  • Hva er lineær regresjon?
  • Hvordan trene en lineær regresjonsmodell
  • Hvordan trene en lineær regresjon med TensorFlow
  • Pandaer
  • Numpy Solution
  • Tensorflow-løsning

Hvordan trene en lineær regresjonsmodell

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

Tenk deg at du har to variabler, x og y, og at oppgaven din er å forutsi verdien av å vite verdien av. Hvis du plotter dataene, kan du se et positivt forhold mellom den uavhengige variabelen x og den avhengige variabelen y.

Du kan se 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 utsatt for feil, spesielt med et datasett med hundretusener av poeng.

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

Med:

  • er vekten assosiert med x
  • er gjenværende eller feil i modellen. Den inkluderer hva modellen ikke kan lære av dataene

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

  • = 3,8
  • = 2,78

Du kan erstatte disse tallene i ligningen, og den blir:

y = 3,8 + 2,78x

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

Den røde linjen representerer den tilpassede verdien, det vil si verdiene til y for hver verdi av x. Du trenger ikke se verdien av x for å forutsi y, for hver x er det noen som hører til den røde linjen. Du kan også forutsi verdier på x 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 den lineære regresjonen ser på hvordan y vil reagere for hver variabel x tatt uavhengig.

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

Tradisjonell analyse vil prøve å forutsi salget ved å la oss si å beregne gjennomsnittet for hver variabel og prøve å estimere salget for forskjellige scenarier. Det vil føre til dårlige spådommer 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 kostnadene (forskjellen mellom den tilpassede linjen og datapunktene).

Hvordan algoritmen fungerer

Algoritmen vil velge et tilfeldig tall for hver 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 forutsagte verdien og den virkelige verdien. En positiv feil betyr at modellen undervurderer prediksjonen til y, og en negativ feil betyr at modellen overvurderer prediksjonen til 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 Mean Square Error , også kalt MSE. Matematisk er det:

Hvor:

  • refererer til den forutsagte verdien
  • y er de virkelige verdiene
  • m er antall observasjoner

Merk at er den matematiske notasjonen av gjennomsnittet.

Målet er å finne det beste som minimerer MSE

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

Gradientnedstigningen tar derivatet og reduserer eller øker vekten. Hvis derivatet er positivt, reduseres vekten. Hvis derivatet er negativt, øker vekten. Modellen oppdaterer vektene og beregner feilen på nytt. Denne prosessen gjentas til feilen ikke endres lenger. Hver prosess kalles en iterasjon . Dessuten multipliseres gradientene med en læringsrate. Det indikerer hastigheten på læringen.

Hvis læringsgraden er for liten, vil det ta veldig lang tid for algoritmen å konvergere (dvs. krever mange iterasjoner). Hvis læringsgraden er for høy, kan algoritmen kanskje ikke konvergere.

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

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

Du husker den første ligningen

De endelige vektene er 3,8 og 2,78. Videoen nedenfor viser deg hvordan gradientnedstigningen optimaliserer tapsfunksjonen for å finne denne vekten

Hvordan trene en lineær regresjon med TensorFlow

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

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

crim per innbygger kriminalitetsrate etter by
zn andel av boligområder avsatt for mye over 25.000 kvm.
indus andel ikke-detaljhandelshektar per by.
nox nitrogenoksidkonsentrasjon
rm gjennomsnittlig antall rom per bolig
alder andel av eierboliger som ble bygget før 1940
dis vektede avstander til fem Boston-arbeidssentre
avgift fullverdig eiendomsskatt per dollar 10.000
ptratio elev-lærer-forhold etter by
medv Medianverdi av eierboliger i tusen dollar

Du vil lage tre forskjellige datasett:

datasett objektiv form
Opplæring Tren modellen og få vektene 400, 10
Evaluering Evaluer ytelsen til modellen på usett data 100, 10
Forutsi Bruk modellen til å forutsi husverdi på nye data 6, 10

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

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

  • Med Pandaer
  • Med Numpy
  • Bare TF

Merk at alle alternativene gir de samme resultatene.

Du lærer hvordan du bruker API på høyt nivå til å bygge, trene og evaluere en TensorFlow lineær regresjonsmodell. Hvis du brukte API på lavt nivå, måtte du definere:

  • Tap funksjon
  • Optimaliser: Gradient nedstigning
  • Matrikser multiplikasjon
  • Graf og tensor

Dette er kjedelig og mer komplisert for nybegynnere.

Pandaer

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

import pandas as pdfrom sklearn import datasetsimport tensorflow as tfimport itertools

Trinn 1) Importer dataene med panda.

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

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)

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, dvs. din y, er inkludert i datasettet. Så du må definere to andre lister. En som bare inneholder funksjonene og en med bare navnet på etiketten. Disse to listene vil fortelle estimatoren din hva som er funksjonene i datasettet 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 i riktig format. Tensorflow gir en metode for å konvertere kontinuerlig variabel: tf.feature_column.numeric_column ().

I forrige trinn definerer du en liste en funksjon du vil ha med i modellen. Nå kan du bruke denne listen til å konvertere dem til numeriske data. Hvis du vil ekskludere funksjoner i modellen din, kan du gjerne slippe en eller flere variabler i listen FUNKSJONER før du konstruerer feature_cols

Merk at du vil bruke Python-listeforståelse med listen FUNKSJONER for å lage en ny liste med navnet feature_cols. Det hjelper deg med å unngå å skrive ni ganger tf.feature_column.numeric_column (). En listeforståelse er en raskere og renere måte å lage 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 for øyeblikket 6 forhåndsbygde estimatorer, inkludert 3 for klassifiseringsoppgave og 3 for TensorFlow-regresjonsoppgave:

  • Regressor
    • DNNRegressor
    • LineærRegressor
    • DNNLineaCombinedRegressor
  • Klassifisering
    • DNNClassifier
    • LinearClassifier
    • DNNLineaCombinedClassifier

I denne opplæringen vil du bruke Linear Regressor. For å få tilgang til denne funksjonen, må du bruke tf.estimator.

Funksjonen trenger to argumenter:

  • feature_column: Inneholder variablene som skal inkluderes i modellen
  • model_dir: sti for å lagre grafen, lagre modellparametrene osv

Tensorflow oppretter automatisk en fil med navnet train i arbeidskatalogen din. Du må bruke denne banen for å få tilgang til Tensorboard som vist i nedenstående TensorFlow regresjonseksempel.

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': , '_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}

Den vanskelige delen med TensorFlow er måten å mate modellen på. Tensorflow er designet for å fungere med parallell databehandling og veldig stort datasett. På grunn av begrensningen av maskinressursene er det umulig å mate modellen med alle dataene samtidig. For det må du mate en mengde data hver gang. Merk at vi snakker om enorme datasett med millioner eller flere poster. Hvis du ikke legger til batch, vil du ende opp med en minnefeil.

For eksempel, hvis dataene 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, avslutter den en 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 iterasjonstid.

En annen informasjon å legge til er hvis du vil blande dataene før hver iterasjon. Under opplæringen er det viktig å blande dataene slik at modellen ikke lærer seg spesifikt mønster av datasettet. Hvis modellen lærer seg detaljene i det underliggende mønsteret til dataene, vil det ha vanskeligheter med å generalisere spådommen for usynlige data. Dette kalles overmontering . Modellen klarer seg godt 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 rørledningen, vet den hvor mange observasjoner den trenger (batch) og om den må blande dataene.

For å instruere Tensorflow hvordan du mater modellen, kan du bruke pandas_input_fn. Dette objektet trenger 5 parametere:

  • x: funksjonsdata
  • y: etikettdata
  • batch_size: batch. Som standard 128
  • num_epoch: Antall epoker, som standard 1
  • shuffle: Shuffle eller ikke dataene. Som standard ingen

Du må mate modellen mange ganger, så du definerer en funksjon for å gjenta denne prosessen. all 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 i et annet datasett
  • Gjør spådommer

Tensorflow estimator har tre forskjellige funksjoner for å utføre disse tre trinnene enkelt.

Trinn 4) : Tren modellen

Du kan bruke estimatortoget til å evaluere modellen. Togestimatoren trenger en input_fn og et antall trinn. Du kan bruke funksjonen du opprettet ovenfor for å mate modellen. Deretter instruerer du modellen om å gjenta 1000 ganger. Merk at du ikke angir antall epoker, du lar modellen gjentas 1000 ganger. Hvis du setter antall epoker til 1, vil modellen gjenta 4 ganger: 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 lettere å sette antall epoker til ingen og definere antall iterasjon som vist i nedenstående TensorFlow klassifiseringseksempel.

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 = 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.

Du kan sjekke Tensorboard vil ha følgende kommando:

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

Trinn 5) Evaluer 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: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

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 oppsummeringsstatistikken for å få en ide om hvor stor feilen er.

training_set['medv'].describe()

Produksjon

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

Fra sammendragsstatistikken ovenfor vet du at gjennomsnittsprisen for et hus er 22 tusen, med en minimumspris på 9 tusen og maksimalt 50 tusen. Modellen gjør en typisk feil på 3 000 dollar.

Trinn 6) Gjør spådommen

Til slutt kan du bruke estimatoren TensorFlow forutsi for å estimere verdien av 6 Boston-hus.

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

For å skrive ut de estimerte verdiene av 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-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)]

Modellen forutslo følgende verdier:

Hus

Prediksjon

1

32,29

2

18.96

3

27.27

4

29.29

5

16.43

7

21.46

Merk at vi ikke vet den sanne verdien av. I veiledningen om dyp læring vil du prøve å slå den lineære modellen

Numpy Solution

Denne delen forklarer hvordan du trener modellen ved hjelp av en nummende estimator for å mate dataene. Metoden er den samme bortsett fra at du vil bruke numpy_input_fn estimator.

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

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

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

Trinn 1) Importer dataene

Først og fremst må du skille funksjonsvariablene fra etiketten. Du må gjøre dette for opplæringsdata og evaluering. 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 funksjonene i toget / evaluere datasettet

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 det bare inneholder NaN

x_predict = prediction_set_n[:, :-2]

Bekreft formen på matrisen. Merk at etiketten ikke skal ha en dimensjon, det betyr (400,).

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

Produksjon

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

Du kan konstruere funksjonskolonnene som følger:

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

Estimatoren er definert som før, du instruerer funksjonskolonnene og hvor du skal lagre grafen.

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': , '_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 nummen estimapor til å mate dataene til modellen og deretter trene modellen. Merk at vi definerer input_fn-funksjonen før for å lette lesbarheten.

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

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

Du replikerer det samme trinnet med en annen estimator for å evaluere modellen

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

Endelig, du kan beregne spådommen. Det skal være det samme som pandaer.

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

Den siste delen er dedikert til en TensorFlow-løsning. Denne metoden er litt mer komplisert enn den andre.

Merk at hvis du bruker Jupyter-notatbok, må du starte på nytt og rense kjernen for å kjøre denne økten.

TensorFlow har bygget et flott verktøy for å føre dataene inn i rørledningen. I denne delen vil du bygge input_fn-funksjonen selv.

Trinn 1) Definer banen og formatet til dataene

Først og fremst erklærer du to variabler med banen til csv-filen. Merk at du har to filer, en for treningssettet og en for testsettet.

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

Deretter må du definere kolonnene du vil bruke fra csv-filen. Vi vil bruke alt. Etter det må du oppgi hvilken type variabel den er.

Flytevariabler 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. Bruk dataene

Nedenfor er overkoden for å definere funksjonen. Koden vil bli forklart etter

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

** Importer dataene **

For en csv-fil leser datasettmetoden en linje om gangen. For å bygge datasettet må du bruke objektet TextLineDataset. Datasettet ditt har en overskrift, så du må bruke skip (1) for å hoppe over første linje. På dette punktet leser du bare dataene og ekskluderer overskriften i rørledningen. For å mate modellen må du skille funksjonene fra etiketten. Metoden som brukes til å bruke enhver transformasjon til dataene er kart.

Denne metoden kaller en funksjon som du vil lage for å instruere hvordan du transformerer dataene. I et nøtteskall må du sende dataene i TextLineDataset-objektet, ekskludere overskriften og bruke en transformasjon som er instruert av en funksjon.

  • tf.data.TextLineDataset (data_file): Denne linjen leser csv-filen
  • .skip (1): hopp over overskriften
  • .map (parse_csv)): parsere postene i 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 erklæres som en ordbok eller en tuple. Du bruker ordbokmetoden fordi den er mer praktisk. Kode forklaring

  • tf.decode_csv (verdi, record_defaults = RECORDS_ALL): metoden decode_csv bruker utdataene fra TextLineDataset til å lese csv-filen. record_defaults instruerer TensorFlow om kolonnetypen.
  • dict (zip (_CSV_COLUMNS, kolonner)): Fyll ordboken med alle kolonnene ekstrahert under denne databehandlingen
  • features.pop ('median_house_value'): Ekskluder målvariabelen fra funksjonsvariabelen og opprett en etikettvariabel

Datasettet trenger ytterligere elementer for å mate Tensorene iterativt. Du må faktisk legge til metodemetoden for å la datasettet fortsette på ubestemt tid for å mate modellen. Hvis du ikke legger til metoden, gjentar modellen bare én gang og kaster en feil fordi det ikke blir matet flere data i rørledningen.

Etter det kan du kontrollere batchstørrelsen med batch-metoden. Det betyr at du forteller datasettet hvor mange data du vil sende i rørledningen for hver iterasjon. Hvis du angir en stor batchstørrelse, vil modellen være treg.

Trinn 3) Opprett iteratoren

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

Den enkleste måten å opprette en operatør på er med metoden make_one_shot_iterator.

Etter det kan du opprette funksjonene og etikettene fra iteratoren.

Trinn 4) Bruk dataene

Du kan sjekke hva som skjer med input_fn-funksjonen. Du må ringe 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 viser den første linjen i csv-filen. Du kan prøve å kjøre denne koden mange ganger med annen batchstørrelse.

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 4) 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 5) 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': , '_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 for å tillate å skrive argumentet i funksjonen inpu_fn. Hvis du ikke bruker en lambda-funksjon, kan du ikke trene modellen.

# Train the estimatormodel.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 = 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]:

Du kan evaluere passformen til din modell 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: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

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

I koden nedenfor skrev du verdiene for hver funksjon som finnes i df_predict csv-filen.

Du må skrive en ny input_fn-funksjon fordi det ikke er noen etikett i datasettet. Du kan bruke API-en fra_tensor fra datasettet.

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)

Endelig, du skriver 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-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)})

Sammendrag

For å trene en modell, må du:

  • Definer funksjonene: Uavhengige variabler: X
  • Definer etiketten: Avhengig variabel: y
  • Konstruer et tog / testsett
  • Definer startvekten
  • Definer tapsfunksjonen: MSE
  • Optimaliser modellen: Gradient nedstigning
  • Definere:
    • Læringsgrad
    • Antall epoker
    • Partistørrelse, Gruppestørrelse

I denne opplæringen lærte du hvordan du bruker API på høyt nivå for en lineær regresjon TensorFlow estimator. Du må definere:

  1. Funksjonskolonner. Hvis kontinuerlig: tf.feature_column.numeric_column (). Du kan fylle ut en liste med pythonlisteforståelse
  2. Estimatoren: tf.estimator.LinearRegressor (funksjonskolonner, modell_dir)
  3. En funksjon for å importere data, batchstørrelse og epoke: input_fn ()

Etter det er du klar til å trene, evaluere og forutsi med tog (), evaluere () og forutsi ()