Lineáris regresszió a TensorFlow segítségével (példák)

Tartalomjegyzék:

Anonim

Mi a lineáris regresszió?

A lineáris regresszió a statisztikák egyik megközelítése két változó közötti kapcsolatok modellezésére. Ez a modellezés skaláris válasz és egy vagy több magyarázó változó között történik. Az egy magyarázó változóval való kapcsolatot egyszerű lineáris regressziónak, egynél több magyarázó változó esetén pedig többszörös lineáris regressziónak nevezzük.

A TensorFlow eszközöket biztosít a számítások teljes irányításához. Ez az alacsony szintű API-val történik. Ezen felül a TensorFlow számos API-val rendelkezik, amelyek sok gépi tanulási algoritmus végrehajtására szolgálnak. Ez a magas szintű API. A TensorFlow becslőknek hívja őket

  • Alacsony szintű API: Építse fel a modell architektúráját, optimalizálását a semmiből. Kezdő számára bonyolult
  • Magas szintű API: Adja meg az algoritmust. Könnyebb barát. TensorFlow rendelkező eszközkészlet hívások Becslő a konstrukciót, a vonat, értékeli, és előrejelzést készít.

Ebben az oktatóanyagban csak a becslőket használja . A számítások gyorsabbak és könnyebben megvalósíthatók. Az oktatóanyag első része elmagyarázza, hogy a gradiens süllyedés optimalizáló segítségével miként lehet lineáris regressziót oktatni a TensorFlow-ban. A második részben a bostoni adatkészlettel fogja megjósolni a ház árát a TensorFlow becslő segítségével.

Töltse le a Boston DataSet alkalmazást

Ebben a TensorFlow regressziós oktatóanyagban megtudhatja:

  • Mi a lineáris regresszió?
  • Hogyan képezzünk lineáris regressziós modellt
  • Hogyan képezzünk lineáris regressziót a TensorFlow segítségével
  • Pandák
  • Dögös megoldás
  • Tensorflow oldat

Hogyan képezzünk lineáris regressziós modellt

Mielőtt elkezdenénk edzeni a modellt, nézzük meg, mi a lineáris regresszió.

Képzelje el, hogy van két változója, az x és az y, és a feladata az, hogy megjósolja az érték ismeretének értékét. Ha ábrázolja az adatokat, akkor pozitív összefüggést láthat az önálló x változó és a függő y változó között.

Megfigyelheti, hogy ha x = 1, y nagyjából egyenlő lesz 6-val, és ha x = 2, akkor y körülbelül 8,5 lesz.

Ez nem túl pontos és hibára hajlamos módszer, különösen egy több százezer pontot tartalmazó adatkészlet esetén.

A lineáris regressziót egyenlettel értékeljük. Az y változót egy vagy több kovariáns magyarázza. A példádban csak egy függő változó létezik. Ha meg kell írnia ezt az egyenletet, az a következő lesz:

Val vel:

  • az x-hez társított súly
  • a modell maradéka vagy hibája. Azt tartalmazza, amit a modell nem tanulhat meg az adatokból

Képzelje el, hogy megfelel a modellnek, és a következő megoldást találja:

  • = 3,8
  • = 2,78

Helyettesítheti ezeket a számokat az egyenletben, és így válik:

y = 3,8 + 2,78x

Most már jobb módja van az y értékeinek megkeresésére. Vagyis helyettesítheti az x értéket bármely olyan értékkel, amelyet meg akar jósolni y. Az alábbi képen az egyenletben szereplő x-et kicseréljük az adatkészlet összes értékére, és ábrázoljuk az eredményt.

A piros vonal az illesztett értéket jelöli, azaz y értéke minden egyes x értékre. Az y megjóslásához nem kell látnia az x értékét, minden egyes x esetében van olyan, amely a piros vonalhoz tartozik. Megjósolhatja 2-nél nagyobb x értékeket is!

Ha a lineáris regressziót több kovariánsra szeretné kiterjeszteni, akkor további változókat adhat hozzá a modellhez. A hagyományos elemzés és a lineáris regresszió közötti különbség az, hogy a lineáris regresszió azt vizsgálja, hogy y hogyan fog reagálni minden egyes x változóra, függetlenül.

Lássunk egy példát. Képzelje el, hogy meg szeretné jósolni egy fagylaltozó eladásait. Az adatkészlet különböző információkat tartalmaz, például az időjárást (azaz esős, napos, felhős), az ügyfelek tájékoztatását (azaz fizetés, nem, családi állapot).

A hagyományos elemzés megpróbálja megjósolni az eladást úgy, hogy kiszámítja az egyes változók átlagát, és megpróbálja megbecsülni az eladást különböző forgatókönyvek esetén. Ez rossz előrejelzésekhez vezet, és az elemzést a választott forgatókönyvre korlátozza.

Ha lineáris regressziót használ, megírhatja ezt az egyenletet:

Az algoritmus megtalálja a legjobb megoldást a súlyokra; ez azt jelenti, hogy megpróbálja minimalizálni a költségeket (az illesztett vonal és az adatpontok közötti különbség).

Az algoritmus működése

Az algoritmus kiválaszt egy véletlen számot mindegyikhez és helyettesíti az x értékét, hogy megkapja y megjósolt értékét. Ha az adatkészlet 100 megfigyeléssel rendelkezik, az algoritmus 100 előre jelzett értéket számol.

Kiszámíthatjuk a modell által észlelt hibát, amely a megjósolt és a valós érték közötti különbség. A pozitív hiba azt jelenti, hogy a modell alulbecsüli az y előrejelzését, a negatív hiba pedig azt, hogy a modell túlbecsüli az y előrejelzését.

A cél a hiba négyzetének minimalizálása. Az algoritmus kiszámítja a négyzethiba átlagát. Ezt a lépést hívjuk a hiba minimalizálásának. A lineáris regresszió az átlagos négyzethiba , más néven MSE. Matematikailag:

Hol:

  • utalnak a megjósolt értékre
  • y a valódi értékek
  • m a megfigyelések száma

Megjegyzés az átlag matematikai jelölése.

A cél az, hogy megtaláljuk a legjobbakat, amelyek minimalizálják az MSE-t

Ha az átlagos hiba nagy, az azt jelenti, hogy a modell rosszul teljesít, és a súlyokat nem megfelelően választják meg. A súlyok korrigálásához optimalizálót kell használnia. A hagyományos optimalizáló neve Gradient Descent .

A gradiens süllyedés veszi a deriváltat, és csökkenti vagy növeli a súlyt. Ha a származék pozitív, akkor a súly csökken. Ha a származék negatív, akkor a súly nő. A modell frissíti a súlyokat és kiszámítja a hibát. Ezt a folyamatot addig ismételjük, amíg a hiba már nem változik. Minden folyamatot iterációnak nevezünk . Ezenkívül a színátmeneteket megszorozzuk egy tanulási rátával. Jelzi a tanulás sebességét.

Ha a tanulási arány túl kicsi, akkor nagyon sok időbe telik, míg az algoritmus konvergál (vagyis sokszorosítást igényel). Ha a tanulási arány túl magas, akkor az algoritmus soha nem fog közeledni.

A fenti képből látható, hogy a modell körülbelül 20-szor megismételte a folyamatot, hogy stabil értéket találjon a súlyokra, így elérve a legalacsonyabb hibát.

Ne feledje, hogy a hiba nem egyenlő nulla, hanem 5 körül stabilizálódik. Ez azt jelenti, hogy a modell tipikus 5-ös hibát követ el. Ha csökkenteni szeretné a hibát, akkor további információkat kell hozzáadnia a modellhez, például több változót vagy különböző becslők.

Emlékszel az első egyenletre

A végső súlyok 3,8 és 2,78. Az alábbi videó bemutatja, hogy a gradiens süllyedés hogyan optimalizálja a veszteségfüggvényt, hogy megtalálja ezeket a súlyokat

Hogyan képezzünk lineáris regressziót a TensorFlow segítségével

Most, hogy jobban megértette, mi történik a motorháztető mögött, készen áll a TensorFlow által biztosított becslő API használatára az első lineáris regresszió edzéséhez a TensorFlow segítségével.

A Boston Dataset-et fogja használni, amely a következő változókat tartalmazza

krim az egy főre eső bűnözés mértéke városonként
zn a 25.000 négyzetméter feletti telkekre elosztott lakóterület aránya
indus városonként a nem kiskereskedelmi üzletek aránya.
nox nitrogén-oxid-koncentráció
rm lakásonkénti átlagos szobák száma
kor az 1940 előtt épített tulajdonosok által használt egységek aránya
dis súlyozott távolságok öt bostoni munkaügyi központig
adó teljes értékű ingatlanadó mértéke dollárenként 10 000
ptratio tanuló-tanár arány városonként
medv A tulajdonosok által használt lakások mediánértéke ezer dollárban

Három különböző adatkészletet hoz létre:

adatkészlet célkitűzés alak
Kiképzés Képezze ki a modellt és szerezze meg a súlyokat 400, 10
Értékelés Értékelje a modell teljesítményét láthatatlan adatok alapján 100, 10
Megjósolni Használja a modellt a ház értékének előrejelzésére új adatok alapján 6, 10

A cél az adatkészlet jellemzőinek felhasználása a ház értékének előrejelzésére.

Az oktatóanyag második része során megtanulja, hogyan kell használni a TensorFlow-t az adatok importálásának három különböző módjával:

  • Pandással
  • Numpyvel
  • Csak a TF

Ne feledje, hogy az összes opció ugyanazokat az eredményeket biztosítja.

Megtanulja, hogyan kell használni a magas szintű API-t a TensorFlow lineáris regressziós modell kiépítéséhez, értékeléséhez. Ha alacsony szintű API-t használt, kézzel kellett meghatároznia a következőket:

  • Veszteség funkció
  • Optimalizálás: gradiens süllyedés
  • Mátrixok szorzása
  • Grafikon és tenzor

Ez unalmas és bonyolultabb a kezdők számára.

Pandák

A modell betanításához be kell importálnia a szükséges könyvtárakat.

import pandas as pdfrom sklearn import datasetsimport tensorflow as tfimport itertools

1. lépés: Importálja az adatokat pandával.

Megadhatja az oszlopneveket, és eltárolja a OSZLOPOKBAN. Az adatok importálásához használhatja a pd.read_csv () fájlt.

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

képzés_készlet = pd.read_csv ("E: /boston_train.csv", skipinitialspace = Igaz, skiprows = 1, nevek = OSZLOPOK)

test_set = pd.read_csv ("E: /boston_test.csv", skipinitialspace = Igaz, skiprows = 1, nevek = OSZLOPOK)

prediction_set = pd.read_csv ("E: /boston_predict.csv", skipinitialspace = True, skiprows = 1, nevek = COLUMNS)

Kinyomtathatja az adatok alakját.

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

Kimenet

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

Ne feledje, hogy a címke, azaz az y értéke szerepel az adatkészletben. Tehát meg kell határoznia két másik listát. Az egyik csak a funkciókat tartalmazza, a másik pedig csak a címke nevét tartalmazza. Ez a két lista megmondja becslőjének, hogy melyek az adatkészlet jellemzői, és milyen oszlopnév a címke

Az alábbi kóddal történik.

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

2. lépés: Konvertálja az adatokat

Át kell alakítania a numerikus változókat a megfelelő formátumban. A Tensorflow egy módszert biztosít a folyamatos változó átalakítására: tf.feature_column.numeric_column ().

Az előző lépésben meghatároz egy listát egy olyan szolgáltatásról, amelyet be kíván venni a modellbe. Most ezt a listát használhatja, hogy numerikus adatokká alakítsa őket. Ha ki akarja zárni a funkciókat a modelljéből, nyugodtan dobjon el egy vagy több változót a FEATURES listába, mielőtt elkészítené a feature_cols

Ne feledje, hogy a Python lista megértését a FEATURES listával fogja létrehozni egy új listának, amelynek neve: feature_cols. Segít elkerülni a kilencszeres tf.feature_column.numeric_column () írást. A listamegértés gyorsabb és tisztább módszer új listák létrehozására

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

3. lépés: Határozza meg a becslőt

Ebben a lépésben meg kell határoznia a becslőt. A Tensorflow jelenleg 6 előre elkészített becslőt nyújt, köztük 3 osztályozási feladathoz és 3 TensorFlow regressziós feladathoz:

  • Regresszor
    • DNNRegresszor
    • Lineáris regresszor
    • DNNLineaCombinedRegressor
  • Osztályozó
    • DNN osztályozó
    • LinearClassifier
    • DNNLineaCombinedClassifier

Ebben az oktatóanyagban a lineáris regresszort használja. A funkció eléréséhez a tf.estimator programot kell használnia.

A függvénynek két argumentumra van szüksége:

  • feature_columns: A modellbe beépítendő változókat tartalmazza
  • model_dir: elérési út a grafikon tárolásához, a modell paramétereinek mentéséhez stb

A Tensorflow automatikusan létrehoz egy vonat nevű fájlt a munkakönyvtárában. Ezt az utat kell használnia a Tensorboard eléréséhez, amint az az alábbi TensorFlow regressziós példában látható.

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

Kimenet

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}

A TensorFlow-val való trükkös rész a modell etetésének módja. A Tensorflow párhuzamos számítástechnikával és nagyon nagy adatkészlettel működik. A gépi erőforrások korlátozottsága miatt lehetetlen az összes adatot egyszerre betáplálni. Ehhez minden alkalommal meg kell adnia egy köteg adatot. Vegye figyelembe, hogy hatalmas, több millió vagy több rekordot tartalmazó adatkészletről beszélünk. Ha nem ad hozzá köteget, memóriahibát okozhat.

Például, ha az adatai 100 megfigyelést tartalmaznak, és 10 kötegméretet határoz meg, az azt jelenti, hogy a modell minden egyes iterációnál 10 megfigyelést fog látni (10 * 10).

Amikor a modell megnézte az összes adatot, befejezi az egyik korszakot . Egy korszak határozza meg, hogy hányszor szeretné látni a modell az adatokat. Jobb, ha ezt a lépést nullára állítja, és hagyja, hogy a modell többször elvégezze az iterációt.

Második hozzáadandó információ az, ha az adatokat minden egyes iteráció előtt meg kívánja keverni. A képzés során fontos az adatok keverése, hogy a modell ne tanulja meg az adatkészlet meghatározott mintázatát. Ha a modell megismeri az adatok mögöttes mintázatának részleteit, akkor nehézségei vannak a láthatatlan adatokra vonatkozó előrejelzés általánosításával. Ezt nevezzük túlillesztésnek . A modell jól teljesít az edzésadatokon, de nem tudja megjósolni helyesen a nem látott adatokat.

A TensorFlow megkönnyíti ezt a két lépést. Amikor az adatok a folyamatba kerülnek, tudja, hogy hány megfigyelésre van szüksége (kötegelt), és hogy kevernie kell-e az adatokat.

A pandas_input_fn paranccsal utasíthatja a Tensorflow-t a modell betáplálásáról. Ennek az objektumnak 5 paraméterre van szüksége:

  • x: jellemző adatok
  • y: címke adatok
  • batch_size: köteg. Alapértelmezés szerint 128
  • num_epoch: Korszakok száma alapértelmezés szerint 1
  • shuffle: Az adatok keverése vagy sem. Alapértelmezés szerint Nincs

Sokszor kell betáplálnia a modellt, hogy meghatározzon egy funkciót ennek a folyamatnak az ismétléséhez. mindez a függvény 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)

A modell teljesítményének értékeléséhez a szokásos módszer a következő:

  • Képezze ki a modellt
  • Értékelje a modellt egy másik adatkészletben
  • Tegyen jóslatot

A Tensorflow becslő három különböző funkciót biztosít ennek a három lépésnek a könnyű végrehajtásához.

4. lépés) : Képezze ki a modellt

Használhatja a becslő vonatot a modell értékeléséhez. A vonatbecslőnek input_fn-re és számos lépésre van szüksége. Használhatja a fent létrehozott függvényt a modell etetéséhez. Ezután utasítja a modellt, hogy ismételje meg 1000-szer. Ne feledje, hogy nem adja meg a korszakok számát, hanem hagyja, hogy a modell 1000-szer ismétlődjön. Ha 1-re állítja a korszakok számát, akkor a modell négyszer ismétlődik: 400 rekord van a képzési készletben, és a köteg mérete 128

  1. 128 sor
  2. 128 sor
  3. 128 sor
  4. 16 sor

Ezért könnyebb a korszakok számát nullára állítani, és meghatározni az iteráció számát, ahogy azt a TensorFlow osztályozási példa mutatja.

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

Kimenet

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.

Ellenőrizheti a Tensorboard a következő parancsot:

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

5. lépés: Értékelje a modelljét

Az alábbi kóddal értékelheti modelljének megfelelőségét a tesztkészleten:

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

Kimenet

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

A veszteséget az alábbi kóddal nyomtathatja ki:

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

Kimenet

Loss: 3215.895996

A modell vesztesége 3215. Ellenőrizheti az összefoglaló statisztikát, hogy képet kapjon a hiba nagyságáról.

training_set['medv'].describe()

Kimenet

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

A fenti összefoglaló statisztikából tudod, hogy egy ház átlagos ára 22 ezer, minimális ára 9 ezer, maximum 50 ezer. A modell tipikus hibája 3 ezer dollár.

6. lépés: Tegye meg az előrejelzést

Végül használhatja a TensorFlow előrejelző becslést 6 bostoni ház értékének becslésére.

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

A becsült értékek kinyomtatásához használja ezt a kódot:

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

Kimenet

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

A modell a következő értékeket jósolja:

Ház

Jóslás

1

32.29

2

18.96

3

27.27

4

29.29

5.

16.43

7

21.46

Vegye figyelembe, hogy nem ismerjük a. A mély tanulás oktatóanyagában megpróbálja legyőzni a lineáris modellt

Dögös megoldás

Ez a szakasz elmagyarázza, hogyan kell betanítani a modellt egy numpy-becslő segítségével az adatok betáplálására. A módszer ugyanaz, kivéve, hogy a numpy_input_fn becslőt fogja használni.

training_set_n = pd.read_csv ("E: /boston_train.csv"). értékek

test_set_n = pd.read_csv ("E: /boston_test.csv"). értékek

prediction_set_n = pd.read_csv ("E: /boston_predict.csv"). értékek

1. lépés: Importálja az adatokat

Először is meg kell különböztetni a funkcióváltozókat a címkétől. Ezt meg kell tennie a képzési adatok és az értékelés szempontjából. Gyorsabb meghatározni egy funkciót az adatok felosztásához.

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

A függvény segítségével feloszthatja a címkét a vonat / értékelő adatkészlet jellemzőitől

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

Kizárnia kell a jóslat-adatkészlet utolsó oszlopát, mert csak NaN-t tartalmaz

x_predict = prediction_set_n[:, :-2]

Erősítse meg a tömb alakját. Ne feledje, hogy a címkének nem lehet dimenziója, ez azt jelenti (400,).

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

Kimenet

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

A jellemző oszlopokat a következőképpen szerkesztheti:

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

A becslő a korábbiakhoz hasonlóan van megadva, Ön utasítja a jellemző oszlopokat és a grafikon mentési helyét.

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

Kimenet

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}

Használhatja a numpy becslést az adatok betáplálására a modellbe, majd betaníthatja a modellt. Ne feledje, hogy az input_fn függvényt korábban definiáltuk az olvashatóság megkönnyítése érdekében.

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

Kimenet

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

A modell kiértékeléséhez ugyanazt a lépést más becslővel megismétli

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)

Kimenet

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}

Végül kiszámíthatja az előrejelzést. A pandákhoz hasonlónak kell lennie.

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

Kimenet

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 oldat

Az utolsó szakasz egy TensorFlow megoldásnak szól. Ez a módszer finoman bonyolultabb, mint a másik.

Ne feledje, hogy ha Jupyter notebookot használ, akkor a munkamenet futtatásához újra kell indítania és meg kell tisztítania a kernelt.

A TensorFlow nagyszerű eszközt épített az adatok továbbítására a folyamatba. Ebben a szakaszban egyedül készíti el az input_fn függvényt.

1. lépés: Adja meg az adatok elérési útját és formátumát

Először két változót deklarál a csv fájl elérési útjával. Ne feledje, hogy két fájlja van, egy az oktatási készlethez és egy a tesztkészlethez.

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

Ezután meg kell határoznia a használni kívánt oszlopokat a csv fájlból. Mindent felhasználunk. Ezt követően be kell jelentenie a változó típusát.

Az úszó változót a [0] határozza meg

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

2. lépés: Határozza meg az input_fn függvényt

A funkció három részre bontható:

  1. Importálja az adatokat
  2. Hozza létre az iterátort
  3. Fogyassza az adatokat

Az alábbiakban a függvény definiálására szolgáló általános kód található. A kódot ezután magyarázzuk el

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

** Importálja az adatokat **

Egy csv fájl esetén az adatkészlet metódus egyenként sorokat olvas. Az adatkészlet felépítéséhez a TextLineDataset objektumot kell használnia. Az adatkészletnek van fejléce, ezért az első sor kihagyásához a skip (1) billentyűt kell használnia. Ezen a ponton csak az adatokat olvassa el, és kizárja a folyamatban lévő fejlécet. A modell betáplálásához el kell különíteni a szolgáltatásokat a címkétől. Az adatok bármilyen transzformációjára alkalmazott módszer a térkép.

Ez a módszer meghív egy függvényt, amelyet létrehozni fog az adatok átalakításának eligazításához. Dióhéjban át kell adnia az adatokat a TextLineDataset objektumban, ki kell zárnia a fejlécet, és egy olyan átalakítást kell alkalmazni, amelyet egy függvény utasít.

  • tf.data.TextLineDataset (data_file): Ez a sor olvassa el a csv fájlt
  • .skip (1): hagyja ki a fejlécet
  • .map (parse_csv)): a rekordok elemzése a tenzorokba Meg kell határoznia egy funkciót a térképobjektum utasításához. Hívhatja ezt a függvényt parse_csv.

Ez a függvény elemzi a csv fájlt a tf.decode_csv módszerrel, és deklarálja a szolgáltatásokat és a címkét. A funkciók szótárként vagy duplaként deklarálhatók. A szótár módszerét azért használja, mert ez kényelmesebb. Kódmagyarázat

  • tf.decode_csv (érték, rekord_defaults = RECORDS_ALL): A decode_csv metódus a TextLineDataset kimenetét használja a csv fájl olvasására. A record_defaults utasítja a TensorFlow-t az oszlopok típusáról.
  • dict (zip (_CSV_COLUMNS, oszlopok)): Töltse fel a szótárt az összes oszlopkal, amelyeket kibontott az adatkezelés
  • features.pop ('median_house_value'): A célváltozó kizárása a jellemzőváltozóból és címkeváltozó létrehozása

Az adatkészletnek további elemekre van szüksége a tenzorok iteratív táplálásához. Valójában hozzá kell adnia a metódusismétlést, hogy az adatkészlet korlátlanul folytatódhasson a modell betáplálása érdekében. Ha nem adja hozzá a módszert, a modell csak egyszer fog ismétlődni, majd hibát dob, mert nincs több adat a folyamatban.

Ezt követően a kötegelt méretet a kötegelt módszerrel szabályozhatja. Ez azt jelenti, hogy elmondja az adatkészletnek, hogy hány adatot szeretne átadni a folyamatban az egyes iterációkhoz. Ha nagy tételméretet állít be, a modell lassú lesz.

3. lépés: Hozza létre az iterátort

Most már készen áll a második lépésre: hozzon létre egy iterátort az adatkészlet elemeinek visszaadásához.

Az operátor létrehozásának legegyszerűbb módja a make_one_shot_iterator metódus.

Ezt követően az iterátorból létrehozhatja a szolgáltatásokat és a címkéket.

4. lépés: Fogyassza az adatokat

Ellenőrizheti, hogy mi történik az input_fn függvénnyel. Az adatok felhasználása érdekében egy munkamenetben meg kell hívnia a függvényt. 1-es tételmérettel próbálkozik.

Ne feledje, hogy egy szótárban található funkciókat és a címkét tömbként nyomtatja ki.

Megjeleníti a csv fájl első sorát. Megpróbálhatja sokszor futtatni ezt a kódot különböző kötegmérettel.

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)

Kimenet

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

4. lépés: Határozza meg a szolgáltatás oszlopot

A numerikus oszlopokat a következőképpen kell meghatároznia:

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

Ne feledje, hogy az összes változót egy vödörben kell egyesítenie

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

5. lépés: Készítse el a modellt

Betaníthatja a modellt a LinearRegressor becslővel.

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

Kimenet

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}

A lambda függvény használatával engedélyezheti az argumentum írását az inpu_fn függvénybe. Ha nem használ lambda funkciót, akkor nem képezheti ki a modellt.

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

Kimenet

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

Az alábbi kóddal értékelheti modelljének megfelelőségét a tesztkészleten:

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

Kimenet

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

Az utolsó lépés az érték előrejelzése a tulajdonságok mátrixainak értéke alapján. Szótárat írhat a megjósolni kívánt értékekkel. A modelled 9 funkcióval rendelkezik, ezért mindegyikhez meg kell adni egy értéket. A modell előrejelzést ad mindegyikükre.

Az alábbi kódba írta az egyes funkciók értékeit, amelyek a df_predict csv fájlban találhatók.

Új input_fn függvényt kell írnia, mert az adatkészletben nincs címke. Használhatja az API from_tensor eszközt az adatkészletből.

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)

Végül kinyomtatja az előrejelzéseket.

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

Kimenet

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

Összegzés

A modell kiképzéséhez:

  • Definiálja a jellemzőket: Független változók: X
  • Határozza meg a címkét: Függő változó: y
  • Készítsen vonatot / tesztkészletet
  • Határozza meg a kezdeti súlyt
  • Definiálja a veszteségfüggvényt: MSE
  • Optimalizálja a modellt: gradiens süllyedés
  • Határozza meg:
    • Tanulási arány
    • Korszakok száma
    • Csomó méret

Ebben az oktatóanyagban megtanulta, hogyan kell használni a magas szintű API-t egy lineáris regressziós TensorFlow becslőhöz. Meg kell határoznia:

  1. Feature oszlopok. Ha folyamatos: tf.feature_column.numeric_column (). A listát python lista megértésével töltheti fel
  2. A becslő: tf.estimator.LinearRegressor (feature_columns, model_dir)
  3. Az adatok, a kötegméret és a korszak importálására szolgáló függvény: input_fn ()

Ezt követően készen áll arra, hogy edzen, értékelje és jósoljon a vonattal (), értékelje () és megjósolja ()