Lineær regresjonsveiledning med TensorFlow [Eksempler]
Evelyn Clarke
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 skalarrespons og en eller flere forklaringsvariabler. Forholdet til én forklaringsvariabel kalles enkel lineær regresjon og for mer enn én forklaringsvariabel kalles det 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 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 kalt estimator å konstruere, trene, evaluere og lage en prediksjon.
I denne opplæringen vil du bruke bare estimatorer. Beregningene er raskere og er enklere å implementere. Den første delen av opplæringen forklarer hvordan du bruker gradient descent optimizer for å 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.
Hvordan trene en lineær regresjonsmodell
Før vi begynner å trene modellen, la oss ta en titt på hva som er en lineær regresjon.
Tenk deg at du har to variabler, x og y, og oppgaven din er å forutsi verdien av å vite verdien av . Hvis du plotter dataene, kan du se en positiv sammenheng mellom den uavhengige variabelen din, x og den avhengige variabelen y.
Du kan observere at hvis x=1, vil y være omtrent 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 hundretusenvis av poeng.
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. dvs. hvis x=0, y=
er vekten knyttet til x
er resten eller feilen til modellen. Det inkluderer det modellen ikke kan lære av 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
Du har nå en bedre måte å finne verdiene for y på. 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 tilhører den røde linjen. Du kan også forutsi for verdier på x høyere enn 2!
Hvis du ønsker å utvide den lineære regresjonen til flere kovariater, kan du ved å legge til flere variabler i modellen. Forskjellen mellom tradisjonell analyse og lineær regresjon er at 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 scenarioet.
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 monterte linjen og datapunktene).
Hvordan algoritmen fungerer
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 reelle verdien. En positiv feil betyr at modellen undervurderer prediksjonen av 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 Feil, også kalt MSE. Matematisk er det:
Hvor:
er vektene slik 
refererer til den anslåtte verdien- y er de virkelige verdiene
- m er antall observasjoner
refererer til den anslåtte verdienLegg 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.
Gradientnedstigningen tar den deriverte og reduserer eller øker vekten. Hvis derivatet er positivt, reduseres vekten. Hvis den deriverte er negativ, øker vekten. Modellen vil oppdatere vektene og beregne feilen på nytt. Denne prosessen gjentas til feilen ikke endres lenger. Hver prosess kalles en køyring. Dessuten multipliseres gradientene med en læringsrate. Det indikerer hastigheten på læringen.
Hvis læringshastigheten er for liten, vil det ta veldig lang tid før algoritmen konvergerer (dvs. krever mange iterasjoner). Hvis læringshastigheten er for høy, kan det hende at algoritmen aldri konvergerer.
Du kan se fra bildet over, modellen gjentar prosessen ca. 20 ganger før for å finne en stabil verdi for vektene, og når derfor den laveste feilen.
Legg merke til at, feilen er ikke 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 bruke forskjellige estimatorer .
Du husker den første ligningen
Sluttvektene 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 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.
Du vil bruke Boston Dataset, som inkluderer følgende variabler
| krim | kriminalitet per innbygger etter by |
|---|---|
| zn | andel boligareal som er regulert for tomter over 25,000 XNUMX sq.ft. |
| Indus | andel ikke-detaljhandelsvirksomhet per by. |
| nox | konsentrasjon av nitrogenoksider |
| rm | gjennomsnittlig antall rom per bolig |
| alder | andel av selveiere bygget før 1940 |
| DIS | vektede avstander til fem Boston sysselsettingssentre |
| skatt | full verdi eiendomsskattesats per dollar 10,000 XNUMX |
| ptratio | elev-lærer forholdet etter by |
| medv | Medianverdien av eierboliger i tusen dollar |
Du vil lage tre forskjellige datasett:
| datasett | Målet | forme |
|---|---|---|
| Kurs | Tren modellen og skaff vektene | 400, 10 |
| Evaluering | Evaluer ytelsen til modellen på usynlige 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 vil du lære hvordan du bruker TensorFlow med tre forskjellige måter å importere dataene på:
- Med pandaer
- Med Klumpete
- Bare TF
Merk at alle alternativer gi de samme resultatene.
Du vil lære hvordan du bruker høynivå-API for å bygge, trene og evaluere en TensorFlow lineær regresjonsmodell. Hvis du brukte API-en på lavt nivå, måtte du definere for hånd:
- Tapsfunksjon
- Optimaliser: Gradientnedstigning
- Multiplikasjon av matriser
- Graf og tensor
Dette er kjedelig og mer komplisert for nybegynnere.
pandaer
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 panda.
Du definerer kolonnenavnene og lagrer dem i KOLONNER. Du kan bruke pd.read_csv() for å 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, altså din y, er inkludert i datasettet. Så du må definere to andre lister. En som bare inneholder funksjonene og en med kun 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 over en funksjon du vil inkludere 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 FEATURES før du konstruerer feature_cols
Merk at du vil bruke Python listeforståelse med listen FEATURES for å lage en ny liste kalt feature_cols. Det hjelper deg å 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 tiden 6 forhåndsbygde estimatorer, inkludert 3 for klassifiseringsoppgaver og 3 for TensorFlow regresjonsoppgaver:
- Regressor
- DNNRegressor
- LineærRegressor
- DNNLineaCombinedRegressor
- klassifisere
- DNNklassifiserer
- LinearClassifier
- DNNLineaCombinedClassifier
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: bane for å lagre grafen, lagre modellparametrene osv
Tensorflow vil automatisk opprette en fil kalt tog i arbeidskatalogen din. Du må bruke denne banen for å få tilgang til 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}
Den vanskelige delen med TensorFlow er måten å mate modellen på. Tensorflow er designet for å fungere med parallell databehandling og svært store datasett. På grunn av begrensningen av maskinressursene er det umulig å mate modellen med alle dataene samtidig. For det må du mate en batch med data hver gang. Merk at vi snakker om et stort datasett med millioner eller flere poster. Hvis du ikke legger til 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 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 iterasjon antall ganger.
En annen informasjon å legge til er om du vil blande dataene før hver iterasjon. Under opplæringen er det viktig å stokke dataene slik at modellen ikke lærer spesifikt mønster av datasettet. Hvis modellen lærer detaljene i det underliggende mønsteret til dataene, vil den ha vanskeligheter med å generalisere prediksjonen for usynlige data. Dette kalles overtilpassing. Modellen presterer bra på treningsdataene, men kan ikke forutsi riktig for usett 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å stokke dataene.
For å instruere Tensorflow hvordan modellen skal mate, 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: Bland eller ikke dataene. Som standard, Ingen
Du må mate modellen mange ganger slik at 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 gir 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 en rekke trinn. Du kan bruke funksjonen du opprettet ovenfor for å mate modellen. Deretter ber du modellen om å iterere 1000 ganger. Merk at du ikke spesifiserer antall epoker, du lar modellen iterere 1000 ganger. Hvis du setter antallet epoker til 1, vil modellen iterere 4 ganger: Det er 400 poster i treningssettet, og batchstørrelsen er 128
- 128 rader
- 128 rader
- 128 rader
- 16 rader
Derfor er det lettere å sette antall epoker til ingen og definere antall iterasjoner som vist i eksemplet under TensorFlow-klassifiseringen.
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 vil 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 oppsummeringsstatistikken for å få en ide 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 oppsummeringsstatistikken ovenfor vet du at gjennomsnittsprisen for et hus er 22 tusen, med en minimumspris på 9 tusen og maksimum 50 tusen. Modellen gjør en typisk feil på 3k dollar.
Trinn 6) Gjør spådommen
Til slutt kan du bruke estimatoren TensorFlow-prediksjon 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 for 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 anslår 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 opplæringen for dyp læring vil du prøve å slå den lineære modellen
Numpy løsning
Denne delen forklarer hvordan du trener modellen ved å bruke en numpy 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”).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 treningsdata 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 til tog/evaluer 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 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 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 = 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 replikerer det samme trinnet med en annen estimator 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. Det bør 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-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 TensorFlow-løsning. Denne metoden er litt mer komplisert enn den andre.
Merk at hvis du bruker Jupyter bærbare, må du starte på nytt og rense kjernen for å kjøre denne økten.
tensorflow har bygget et flott verktøy for å sende dataene inn i rørledningen. I denne delen skal du bygge input_fn-funksjonen selv.
Trinn 1) Definer banen og formatet til dataene
Først av alt, 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 alle. Etter det må du deklarere hvilken type variabel det er.
Flytningsvariabelen 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:
- Importer dataene
- Lag iteratoren
- Konsumere dataene
Nedenfor er den generelle koden for å definere funksjonen. Koden vil bli forklart etterpå
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 data**
For en csv-fil leser datasettmetoden én linje om gangen. For å bygge datasettet må du bruke objektet TextLineDatasett. Datasettet ditt har en overskrift, så du må bruke skip(1) for å hoppe over den første linjen. På dette tidspunktet leser du bare dataene og ekskluderer overskriften i pipelinen. For å mate modellen må du skille funksjonene fra etiketten. Metoden som brukes for å bruke enhver transformasjon på dataene er kart.
Denne metoden kaller en funksjon som du vil opprette for å instruere hvordan du transformerer dataene. Kort fortalt må du sende dataene i TextLineDatasettobjekt, ekskluder overskriften og bruk en transformasjon som er instruert av en funksjon.Kodeforklaring
- tf.data.TextLineDatasett(data_fil): Denne linjen leste csv-filen
- .skip(1): hopp over overskriften
- .map(parse_csv)): parse postene inn i tensoreneDu 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 erklærer funksjonene og etiketten. Funksjonene kan deklareres som en ordbok eller en tuppel. Du bruker ordbokmetoden fordi det er mer praktisk. Kodeforklaring
- tf.decode_csv(verdi, record_defaults= RECORDS_ALL): metoden decode_csv bruker utdataene fra TextLineDatasett for å lese csv-filen. record_defaults instruerer TensorFlow om kolonnetypen.
- dict(zip(_CSV_COLUMNS, columns)): Fyll ut ordboken med alle kolonnene som er hentet ut under denne databehandlingen
- features.pop('median_house_value'): Ekskluder målvariabelen fra funksjonsvariabelen og lag en etikettvariabel
Datasettet trenger flere elementer for iterativt å mate tensorene. Faktisk må du legge til metoderepetisjonen for å la datasettet fortsette på ubestemt tid for å mate modellen. Hvis du ikke legger til metoden, vil modellen iterere bare én gang og deretter gi en feil fordi det ikke mates mer data i rørledningen.
Etter det kan du kontrollere batchstørrelsen med batchmetoden. Det betyr at du forteller datasettet hvor mange data du vil sende 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) 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 vil vise den første linjen i csv-filen. Du kan prøve å kjøre denne koden mange ganger med forskjellig 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': <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 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 = 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 basert på verdien av , matrisene 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 csv-filen df_predict.
Du må skrive en ny input_fn-funksjon fordi det ikke er noen etikett i datasettet. Du kan bruke API 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)
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)})
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: Gradientnedstigning
- Definere:
- Læringsfrekvens
- Antall epoker
- Partistørrelse, Gruppestørrelse
I denne opplæringen lærte du hvordan du bruker høynivå-API for en lineær regresjon TensorFlow-estimator. Du må definere:
- Funksjonskolonner. Hvis kontinuerlig: tf.feature_column.numeric_column(). Du kan fylle ut en liste med python-listeforståelse
- Estimatoren: tf.estimator.LinearRegressor(feature_columns, model_dir)
- En funksjon for å importere dataene, batchstørrelsen og epoken: input_fn()
Etter det er du klar til å trene, evaluere og forutsi med train(), evaluate() og predict()
