Hvad er lineær regression?
Lineær regression er en tilgang i statistikker til modellering af forhold mellem to variabler. Denne modellering udføres mellem et skalarrespons og en eller flere forklarende variabler. Forholdet til en forklarende variabel kaldes simpel lineær regression og for mere end en forklarende variabel kaldes den multipel lineær regression.
TensorFlow giver værktøjer til at have fuld kontrol over beregningerne. Dette gøres med API'en på lavt niveau. Derudover er TensorFlow udstyret med et stort udvalg af API'er til at udføre mange maskinindlæringsalgoritmer. Dette er API'en på højt niveau. TensorFlow kalder dem estimatorer
- API på lavt niveau: Byg arkitekturen, optimering af modellen fra bunden. Det er kompliceret for en nybegynder
- API på højt niveau: Definer algoritmen. Det er lettere-venligt. TensorFlow giver en værktøjskasse opkald Estimator til konstruktion, tog, evaluere og lave en forudsigelse.
I denne vejledning bruger du kun estimatorerne . Beregningerne er hurtigere og lettere at implementere. Den første del af vejledningen forklarer, hvordan man bruger gradientnedstigningsoptimering til at træne en lineær regression i TensorFlow. I en anden del bruger du Boston-datasættet til at forudsige prisen på et hus ved hjælp af TensorFlow estimator.
Download Boston DataSet
I denne TensorFlow Regression-tutorial lærer du:
- Hvad er lineær regression?
- Sådan træner du en lineær regressionsmodel
- Sådan træner du en lineær regression med TensorFlow
- Pandaer
- Numpy løsning
- Tensorflow løsning
Sådan træner du en lineær regressionsmodel
Før vi begynder at træne modellen, skal vi se på, hvad der er en lineær regression.
Forestil dig, at du har to variabler, x og y, og din opgave er at forudsige værdien af at kende værdien af. Hvis du plotter dataene, kan du se et positivt forhold mellem din uafhængige variabel, x og din afhængige variabel y.
Du kan se, hvis x = 1, vil y omtrent være lig med 6, og hvis x = 2, vil y være omkring 8,5.
Dette er ikke en meget nøjagtig metode og tilbøjelig til fejl, især med et datasæt med hundreder af tusinder af point.
En lineær regression vurderes med en ligning. Variablen y forklares med et eller flere kovariater. I dit eksempel er der kun en afhængig variabel. Hvis du skal skrive denne ligning, vil den være:
Med:
er vægten associeret med x
er den resterende eller fejlen i modellen. Det inkluderer, hvad modellen ikke kan lære af dataene
Forestil dig, at du passer til modellen, og du finder følgende løsning til:
- = 3,8
- = 2,78
Du kan erstatte disse tal i ligningen, og det bliver:
y = 3,8 + 2,78 x
Du har nu en bedre måde at finde værdierne for y på. Det vil sige, du kan erstatte x med en hvilken som helst værdi, du vil forudsige y. På billedet nedenfor har vi erstattet x i ligningen med alle værdierne i datasættet og plottet resultatet.
Den røde linje repræsenterer den monterede værdi, det vil sige værdierne for y for hver værdi på x. Du behøver ikke se værdien af x for at forudsige y, for hver x er der nogen, der hører til den røde linje. Du kan også forudsige værdier på x højere end 2!
Hvis du vil udvide den lineære regression til flere kovariater, kan du ved at tilføje flere variabler til modellen. Forskellen mellem traditionel analyse og lineær regression er den lineære regression ser på, hvordan y vil reagere for hver variabel x taget uafhængigt.
Lad os se et eksempel. Forestil dig, at du vil forudsige salget af en isbutik. Datasættet indeholder forskellige oplysninger såsom vejret (dvs. regnfuldt, solrigt, overskyet), kundeinformation (dvs. løn, køn, civilstand).
Traditionel analyse vil forsøge at forudsige salget ved at sige at beregne gennemsnittet for hver variabel og forsøge at estimere salget for forskellige scenarier. Det vil føre til dårlige forudsigelser og begrænse analysen til det valgte scenarie.
Hvis du bruger lineær regression, kan du skrive denne ligning:
Algoritmen finder den bedste løsning til vægten; det betyder, at det vil forsøge at minimere omkostningerne (forskellen mellem den monterede linje og datapunkterne).
Sådan fungerer algoritmen
Algoritmen vælger et tilfældigt tal for hver erstatter værdien af x for at få den forudsagte værdi af y. Hvis datasættet har 100 observationer, beregner algoritmen 100 forudsagte værdier.
Vi kan beregne den fejl, der er bemærket af modellen, som er forskellen mellem den forudsagte værdi og den reelle værdi. En positiv fejl betyder, at modellen undervurderer forudsigelsen af y, og en negativ fejl betyder, at modellen overvurderer forudsigelsen af y.
Dit mål er at minimere kvadratet af fejlen. Algoritmen beregner gennemsnittet af kvadratfejlen. Dette trin kaldes minimering af fejlen. For lineær regression er den gennemsnitlige firkantfejl , også kaldet MSE. Matematisk er det:
Hvor:
henviser til den forudsagte værdi- y er de reelle værdier
- m er antallet af observationer
Bemærk, at det 
er den matematiske notation af middelværdien.
Målet er at finde det bedste, 
der minimerer MSE
Hvis den gennemsnitlige fejl er stor, betyder det, at modellen fungerer dårligt, og vægtene ikke vælges korrekt. For at korrigere vægtene skal du bruge en optimizer. Den traditionelle optimizer kaldes Gradient Descent .
Gradientnedstigningen tager afledningen og formindsker eller øger vægten. Hvis derivatet er positivt, reduceres vægten. Hvis derivatet er negativt, stiger vægten. Modellen opdaterer vægtene og beregner fejlen igen. Denne proces gentages, indtil fejlen ikke ændres længere. Hver proces kaldes en iteration . Desuden ganges gangene med en læringsrate. Det angiver læringshastigheden.
Hvis læringshastigheden er for lille, vil det tage meget lang tid for algoritmen at konvergere (dvs. kræver mange iterationer). Hvis læringshastigheden er for høj, kan algoritmen muligvis aldrig konvergere.
Du kan se fra billedet ovenfor, modellen gentager processen cirka 20 gange før for at finde en stabil værdi for vægtene og når den laveste fejl.
Bemærk , at fejlen ikke er lig med nul, men stabiliserer sig omkring 5. Det betyder, at modellen laver en typisk fejl på 5. Hvis du vil reducere fejlen, skal du tilføje mere information til modellen, f.eks. Flere variabler eller bruge forskellige estimatorer.
Du husker den første ligning
De endelige vægte er 3,8 og 2,78. Videoen nedenfor viser dig, hvordan gradientnedstigningen optimerer tabsfunktionen for at finde denne vægt
Sådan træner du en lineær regression med TensorFlow
Nu hvor du har en bedre forståelse af, hvad der sker bag emhætten, er du klar til at bruge estimator API leveret af TensorFlow til at træne din første lineære regression ved hjælp af TensorFlow.
Du bruger Boston datasættet, som indeholder følgende variabler
| crim | kriminalitetsrate pr. indbygger efter by |
|---|---|
| zn | andel af beboelsesarealer, der er indrettet til partier over 25.000 kvm. |
| indus | andel af ikke-detailhandelshektar pr. by. |
| nox | nitrogenoxidkoncentration |
| rm | gennemsnitligt antal værelser pr. bolig |
| alder | andel af ejerboliger, der blev bygget før 1940 |
| dis | vægtede afstande til fem beskæftigelsescentre i Boston |
| skat | fuld værdi ejendomsskattesats pr. dollars 10.000 |
| ptratio | elev-lærer-forhold efter by |
| medv | Medianværdi af ejerboliger i tusind dollars |
Du opretter tre forskellige datasæt:
| datasæt | objektiv | form |
|---|---|---|
| Uddannelse | Træn modellen og opnå vægten | 400, 10 |
| Evaluering | Evaluer ydelsen af modellen på usete data | 100, 10 |
| Forudsige | Brug modellen til at forudsige husværdi på nye data | 6, 10 |
Målet er at bruge funktionerne i datasættet til at forudsige husets værdi.
I løbet af anden del af selvstudiet lærer du, hvordan du bruger TensorFlow med tre forskellige måder at importere dataene på:
- Med pandaer
- Med Numpy
- Kun TF
Bemærk, at alle muligheder giver de samme resultater.
Du vil lære at bruge API'en på højt niveau til at opbygge, træne og evaluere en TensorFlow lineær regressionsmodel. Hvis du brugte API'en på lavt niveau, var du nødt til at definere:
- Tabsfunktion
- Optimer: Gradient nedstigning
- Multiplikation af matricer
- Graf og tensor
Dette er kedeligt og mere kompliceret for begyndere.
Pandaer
Du skal importere de nødvendige biblioteker for at træne modellen.
import pandas as pdfrom sklearn import datasetsimport tensorflow as tfimport itertools
Trin 1) Importer dataene med panda.
Du definerer kolonnenavnene og gemmer det i COLUMNS. Du kan bruge pd.read_csv () til at 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 = Sand, skiprows = 1, names = COLUMNS)
Du kan udskrive formen på dataene.
print(training_set.shape, test_set.shape, prediction_set.shape)
Produktion
(400, 10) (100, 10) (6, 10)
Bemærk, at etiketten, dvs. dit y, er inkluderet i datasættet. Så du skal definere to andre lister. En der kun indeholder funktionerne og en med kun navnet på etiketten. Disse to lister fortæller din estimator, hvad der er funktionerne i datasættet, og hvilket kolonnenavn er etiketten
Det gøres med nedenstående kode.
FEATURES = ["crim", "zn", "indus", "nox", "rm","age", "dis", "tax", "ptratio"]LABEL = "medv"
Trin 2) Konverter dataene
Du skal konvertere de numeriske variabler i det rigtige format. Tensorflow giver en metode til at konvertere kontinuerlig variabel: tf.feature_column.numeric_column ().
I det forrige trin definerer du en liste over en funktion, du vil medtage i modellen. Nu kan du bruge denne liste til at konvertere dem til numeriske data. Hvis du vil ekskludere funktioner i din model, er du velkommen til at droppe en eller flere variabler på listen FUNKTIONER, før du konstruerer feature_cols
Bemærk, at du vil bruge Python-listeforståelse med listen FUNKTIONER til at oprette en ny liste med navnet feature_cols. Det hjælper dig med at undgå at skrive ni gange tf.feature_column.numeric_column (). En listeforståelse er en hurtigere og renere måde at oprette nye lister på
feature_cols = [tf.feature_column.numeric_column(k) for k in FEATURES]
Trin 3) Definer estimatoren
I dette trin skal du definere estimatoren. Tensorflow leverer i øjeblikket 6 forudbyggede estimatorer, herunder 3 til klassificeringsopgave og 3 til TensorFlow-regressionsopgave:
- Regressor
- DNNRegressor
- Lineærregressor
- DNNLineaCombinedRegressor
- Klassifikator
- DNNClassifier
- Lineær klassifikator
- DNNLineaCombinedClassifier
I denne vejledning bruger du Linear Regressor. For at få adgang til denne funktion skal du bruge tf.estimator.
Funktionen har brug for to argumenter:
- feature_column: Indeholder de variabler, der skal medtages i modellen
- model_dir: sti til at gemme grafen, gemme modelparametrene osv
Tensorflow opretter automatisk en fil med navnet train i din arbejdsmappe. Du skal bruge denne sti for at få adgang til Tensorboard som vist i nedenstående TensorFlow-regressionseksempel.
estimator = tf.estimator.LinearRegressor(feature_columns=feature_cols,model_dir="train")
Produktion
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 del med TensorFlow er måden at fodre modellen på. Tensorflow er designet til at arbejde med parallel computing og meget stort datasæt. På grund af begrænsningen af maskinressourcerne er det umuligt at fodre modellen med alle data på én gang. Til det er du nødt til at fodre en batch af data hver gang. Bemærk, at vi taler om enorme datasæt med millioner eller flere poster. Hvis du ikke tilføjer batch, vil du ende med en hukommelsesfejl.
For eksempel, hvis dine data indeholder 100 observationer, og du definerer en batchstørrelse på 10, betyder det, at modellen vil se 10 observationer for hver iteration (10 * 10).
Når modellen har set alle data, afslutter den en epoke . En epoke definerer, hvor mange gange du vil have modellen til at se dataene. Det er bedre at indstille dette trin til intet og lade modellen udføre iteration antal tid.
En anden information, der skal tilføjes, er, hvis du vil blande dataene før hver iteration. Under træningen er det vigtigt at blande dataene, så modellen ikke lærer specifikt mønster af datasættet. Hvis modellen lærer detaljerne i det underliggende mønster af dataene, vil den have vanskeligheder med at generalisere forudsigelsen for usete data. Dette kaldes overmontering . Modellen klarer sig godt på træningsdataene, men kan ikke forudsige korrekt for usete data.
TensorFlow gør disse to trin nemme at gøre. Når dataene går til rørledningen, ved det, hvor mange observationer de har brug for (batch), og om de skal blande dataene.
For at instruere Tensorflow, hvordan man fodrer modellen, kan du bruge pandas_input_fn. Dette objekt har brug for 5 parametre:
- x: funktionsdata
- y: etiketdata
- batch_size: batch. Som standard 128
- num_epoch: Antal epoker, som standard 1
- shuffle: Bland dataene eller bland dem ikke. Som standard Ingen
Du skal fodre modellen mange gange, så du definerer en funktion til at gentage denne proces. al denne funktion 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 sædvanlige metode til at evaluere ydeevnen af en model er at:
- Træn modellen
- Evaluer modellen i et andet datasæt
- Forudsig
Tensorflow estimator giver tre forskellige funktioner til at udføre disse tre trin let.
Trin 4) : Træn modellen
Du kan bruge estimatortoget til at evaluere modellen. Togestimatoren har brug for et input_fn og et antal trin. Du kan bruge den funktion, du oprettede ovenfor, til at føde modellen. Derefter instruerer du modellen om at gentage 1000 gange. Bemærk, at du ikke angiver antallet af epoker, du lader modellen gentage 1000 gange. Hvis du indstiller antallet af epoker til 1, gentages modellen 4 gange: Der er 400 poster i træningssættet, og batchstørrelsen er 128
- 128 rækker
- 128 rækker
- 128 rækker
- 16 rækker
Derfor er det lettere at indstille antallet af epoker til ingen og definere antallet af iteration som vist i nedenstående TensorFlow klassificeringseksempel.
estimator.train(input_fn=get_input_fn(training_set,num_epochs=None,n_batch = 128,shuffle=False),steps=1000)
Produktion
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 kontrollere følgende kommando på Tensorboard:
activate hello-tf# For MacOStensorboard --logdir=./train# For Windowstensorboard --logdir=train
Trin 5) Evaluer din model
Du kan evaluere din models pasform på testsættet med nedenstående kode:
ev = estimator.evaluate(input_fn=get_input_fn(test_set,num_epochs=1,n_batch = 128,shuffle=False))
Produktion
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 udskrive tabet med nedenstående kode:
loss_score = ev["loss"]print("Loss: {0:f}".format(loss_score))
Produktion
Loss: 3215.895996
Modellen har et tab på 3215. Du kan kontrollere oversigtsstatistikken for at få en idé om, hvor stor fejlen er.
training_set['medv'].describe()
Produktion
count 400.000000mean 22.625500std 9.572593min 5.00000025% 16.60000050% 21.40000075% 25.025000max 50.000000Name: medv, dtype: float64
Fra ovenstående statistik ved du, at gennemsnitsprisen for et hus er 22 tusind, med en minimumspris på 9 tusind og maksimalt 50 tusind. Modellen laver en typisk fejl på 3k dollars.
Trin 6) Lav forudsigelsen
Endelig kan du bruge estimatoren TensorFlow forudsige til at estimere værdien af 6 Boston huse.
y = estimator.predict(input_fn=get_input_fn(prediction_set,num_epochs=1,n_batch = 128,shuffle=False))
For at udskrive de anslåede værdier af kan du bruge denne kode:
predictions = list(p["predictions"] for p in itertools.islice(y, 6))print("Predictions: {}".format(str(predictions)))
Produktion
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 forudsagde følgende værdier:
|
Hus |
Forudsigelse | |
|---|---|---|
|
1 |
32,29 | |
|
2 |
18,96 | |
|
3 |
27,27 | |
|
4 |
29.29 | |
|
5 |
16.43 | |
|
7 |
21.46 |
Bemærk, at vi ikke kender den sande værdi af. I vejledningen til dyb læring vil du prøve at slå den lineære model
Numpy løsning
Dette afsnit forklarer, hvordan man træner modellen ved hjælp af en bedøvet estimator til at føde dataene. Metoden er den samme undtagen at du bruger numpy_input_fn estimator.
training_set_n = pd.read_csv ("E: /boston_train.csv"). værdier
test_set_n = pd.read_csv ("E: /boston_test.csv"). værdier
prediction_set_n = pd.read_csv ("E: /boston_predict.csv") værdier.
Trin 1) Importer dataene
Først og fremmest skal du differentiere funktionsvariablerne fra etiketten. Du skal gøre dette til træningsdataene og evalueringen. Det er hurtigere at definere en funktion til at opdele dataene.
def prepare_data(df):X_train = df[:, :-3]y_train = df[:,-3]return X_train, y_train
Du kan bruge funktionen til at opdele etiketten fra funktionerne i toget / evaluere datasættet
X_train, y_train = prepare_data(training_set_n)X_test, y_test = prepare_data(test_set_n)
Du skal udelukke den sidste kolonne i forudsigelsesdatasættet, fordi det kun indeholder NaN
x_predict = prediction_set_n[:, :-2]
Bekræft arrayets form. Bemærk, at etiketten ikke skal have en dimension, det betyder (400,).
print(X_train.shape, y_train.shape, x_predict.shape)
Produktion
(400, 9) (400,) (6, 9)
Du kan konstruere funktionskolonnerne som følger:
feature_columns = [ tf.feature_column.numeric_column('x', shape=X_train.shape[1:])]
Estimatoren er defineret som før, du instruerer funktionskolonnerne, og hvor grafen skal gemmes.
estimator = tf.estimator.LinearRegressor(feature_columns=feature_columns,model_dir="train1")
Produktion
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 bruge den bedøvede estimapor til at føje dataene til modellen og derefter træne modellen. Bemærk, at vi definerer input_fn-funktionen før for at lette læsbarheden.
# 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)
Produktion
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 trin med en anden estimator for at evaluere din model
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)
Produktion
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 forudsigelsen. 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)))
Produktion
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
Det sidste afsnit er dedikeret til en TensorFlow-løsning. Denne metode er lidt mere kompliceret end den anden.
Bemærk, at hvis du bruger Jupyter-notesbog, skal du genstarte og rense kernen for at køre denne session.
TensorFlow har bygget et fantastisk værktøj til at overføre dataene til rørledningen. I dette afsnit opbygger du selv input_fn-funktionen.
Trin 1) Definer stien og formatet på dataene
Først og fremmest erklærer du to variabler med stien til csv-filen. Bemærk, at du har to filer, en til træningssættet og en til testsættet.
import tensorflow as tf
df_train = "E:/boston_train.csv"
df_eval = "E:/boston_test.csv"
Derefter skal du definere de kolonner, du vil bruge, fra csv-filen. Vi bruger alt. Derefter skal du erklære den type variabel, den er.
Flydende variabel er defineret med [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]]
Trin 2) Definer input_fn-funktionen
Funktionen kan opdeles i tre dele:
- Importer dataene
- Opret iteratoren
- Forbruge data
Nedenfor er den overal kode, der definerer funktionen. Koden forklares efter
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 læser datasætmetoden en linje ad gangen. For at oprette datasættet skal du bruge objektet TextLineDataset. Dit datasæt har en overskrift, så du skal bruge spring (1) til at springe over den første linje. På dette tidspunkt læser du kun dataene og ekskluderer overskriften i pipelinen. For at fodre modellen skal du adskille funktionerne fra etiketten. Metoden, der bruges til at anvende enhver transformation til dataene, er kort.
Denne metode kalder en funktion, som du opretter for at instruere, hvordan dataene transformeres. I en nøddeskal skal du videregive dataene i TextLineDataset-objektet, udelukke overskriften og anvende en transformation, som er instrueret af en funktion.
- tf.data.TextLineDataset (data_file): Denne linje læser csv-filen
- .skip (1): spring over overskriften
- .map (parse_csv)): parse poster i tensorer Du skal definere en funktion for at instruere kortobjektet. Du kan kalde denne funktion parse_csv.
Denne funktion parser csv-filen med metoden tf.decode_csv og erklærer funktionerne og etiketten. Funktionerne kan erklæres som en ordbog eller en tuple. Du bruger ordbogsmetoden, fordi den er mere bekvem. Kode forklaring
- tf.decode_csv (værdi, record_defaults = RECORDS_ALL): metoden decode_csv bruger output fra TextLineDataset til at læse csv-filen. record_defaults instruerer TensorFlow om kolonnetypen.
- dict (zip (_CSV_COLUMNS, kolonner)): Udfyld ordbogen med alle de kolonner, der er ekstraheret under denne databehandling
- features.pop ('median_house_value'): Ekskluder målvariablen fra funktionsvariablen og opret en etiketvariabel
Datasættet har brug for yderligere elementer til iterativt at føde Tensorerne. Faktisk skal du tilføje metoden gentagelse for at tillade datasættet at fortsætte på ubestemt tid for at føde modellen. Hvis du ikke tilføjer metoden, gentager modellen kun én gang og kaster derefter en fejl, fordi der ikke føres flere data i rørledningen.
Derefter kan du kontrollere batchstørrelsen med batchmetoden. Det betyder, at du fortæller datasættet, hvor mange data du vil sende i pipelinen for hver iteration. Hvis du indstiller en stor batchstørrelse, går modellen langsomt.
Trin 3) Opret iteratoren
Nu er du klar til det andet trin: Opret en iterator for at returnere elementerne i datasættet.
Den enkleste måde at oprette en operatør på er ved hjælp af metoden make_one_shot_iterator.
Derefter kan du oprette funktionerne og etiketterne fra iteratoren.
Trin 4) Brug dataene
Du kan kontrollere, hvad der sker med input_fn-funktionen. Du skal ringe til funktionen i en session for at forbruge dataene. Du prøver med en batchstørrelse svarende til 1.
Bemærk, at det udskriver funktionerne i en ordbog og etiketten som en matrix.
Det viser den første linje i csv-filen. Du kan prøve at køre denne kode mange gange med forskellige 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)
Produktion
({'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))
Trin 4) Definer funktionskolonnen
Du skal definere de numeriske kolonner 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')
Bemærk, at du skal kombinere alle variablerne i en spand
base_columns = [X1, X2, X3,X4, X5, X6,X7, X8, X9]
Trin 5) Byg modellen
Du kan træne modellen med estimatoren LinearRegressor.
model = tf.estimator.LinearRegressor(feature_columns=base_columns, model_dir='train3')
Produktion
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 skal bruge en lambda-funktion for at tillade at skrive argumentet i funktionen inpu_fn. Hvis du ikke bruger en lambda-funktion, kan du ikke træne modellen.
# Train the estimatormodel.train(steps =1000,input_fn= lambda : input_fn(df_train,batch_size=128, num_epoch = None))
Produktion
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 pasformen af din model på testsættet med nedenstående kode:
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]))
Produktion
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 sidste trin er at forudsige værdien af baseret på værdien af funktionerne. Du kan skrive en ordbog med de værdier, du vil forudsige. Din model har 9 funktioner, så du skal angive en værdi for hver. Modellen giver en forudsigelse for hver af dem.
I koden nedenfor skrev du værdierne for hver funktion, der er indeholdt i df_predict csv-filen.
Du skal skrive en ny input_fn-funktion, fordi der ikke er nogen etiket i datasættet. Du kan bruge API'en fra_tensor fra datasættet.
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 udskriver forudsigelserne.
for pred in enumerate(pred_results):print(pred)
Produktion
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)})
Resumé
For at træne en model skal du:
- Definer funktionerne: Uafhængige variabler: X
- Definer etiketten: Afhængig variabel: y
- Konstruer et tog / testsæt
- Definer den indledende vægt
- Definer tabsfunktionen: MSE
- Optimer modellen: Gradient nedstigning
- Definere:
- Læringsgrad
- Antal epoker
- Batchstørrelse
I denne vejledning lærte du, hvordan du bruger API'en på højt niveau til en lineær regression TensorFlow estimator. Du skal definere:
- Funktionskolonner. Hvis kontinuerlig: tf.feature_column.numeric_column (). Du kan udfylde en liste med pythonlisteforståelse
- Estimatoren: tf.estimator.LinearRegressor (feature_column, model_dir)
- En funktion til at importere data, batchstørrelse og epoke: input_fn ()
Derefter er du klar til at træne, evaluere og forudsige med tog (), evaluere () og forudsige ()
