Lineáris regressziós oktatóanyag a TensorFlow-val [Példák]
Evelyn Clarke
Mi az a lineáris regresszió?
Lineáris regresszió a statisztikai megközelítés két változó közötti kapcsolatok modellezésére. Ez a modellezés egy 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 ellenőrzéséhez. Ez az alacsony szintű API-val történik. Ezen felül a TensorFlow API-k széles skálájával van felszerelve, hogy sok mindent végrehajtson gépi tanulás algoritmusok. Ez a magas szintű API. A TensorFlow ezeket becsléseknek nevezi
- Alacsony szintű API: Építsd meg a modell architektúráját, optimalizálását a semmiből. Kezdőnek bonyolult
- Magas szintű API: Határozza meg az algoritmust. Könnyebbé válik. A TensorFlow egy olyan eszköztárat biztosít, melynek neve becslő konstruálni, betanítani, értékelni és jóslatokat készíteni.
Ebben az oktatóanyagban a csak becslések. A számítások gyorsabbak és könnyebben megvalósíthatók. Az oktatóanyag első része elmagyarázza, hogyan használhatja a gradiens süllyedés-optimalizálót a TensorFlow lineáris regressziójának betanításához. A második részben a Boston adatkészletet fogja használni egy ház árának megjósolására a TensorFlow becslés segítségével.
Hogyan tanítsunk lineáris regressziós modellt
Mielőtt elkezdené a modell betanítását, nézzük meg, mi az a lineáris regresszió.
Képzelje el, hogy két változója van, az x és az y, és az Ön feladata, hogy megjósolja az érték ismeretének értékét. Ha ábrázolja az adatokat, pozitív kapcsolatot láthat a független x és a függő y változó között.
Megfigyelhetjük, ha x=1,y nagyjából 6 lesz, és ha x=2,y 8.5 körül lesz.
Ez nem túl pontos módszer, és hajlamos a hibákra, különösen egy több százezer pontot tartalmazó adatkészlet esetén.
A lineáris regressziót egy egyenlettel értékeljük ki. Az y változót egy vagy több kovariáns magyarázza. A példádban csak egy függő változó van. Ha meg kell írni ezt az egyenletet, akkor ez lesz:
Val vel:
az elfogultság. azaz ha x=0, y=
az x-hez tartozó súly
a modell maradéka vagy hibája. Tartalmazza azt, amit a modell nem tud megtanulni az adatokból
Képzelje el, hogy megfelel a modellnek, és a következő megoldást találja:
- = 3.8
- = 2.78
Behelyettesítheti ezeket a számokat az egyenletben, és ez lesz:
y= 3.8 + 2.78x
Most egy jobb módszerrel keresheti meg y értékeit. Vagyis lecserélheti x-et tetszőleges értékre, amellyel meg akarja jósolni y-t. Az alábbi képen az egyenletben az x-et lecseréltük az adatkészlet összes értékére, és ábrázoltuk az eredményt.
A piros vonal az illesztett értéket jelöli, vagyis az y értékeit minden x értékhez. Nem kell x értékét látnia y előrejelzéséhez, minden x-hez van olyan, amelyik a piros vonalhoz tartozik. 2-nél nagyobb x értékekre is megjósolhat!
Ha a lineáris regressziót több kovariánsra szeretné kiterjeszteni, akkor több változót ad hozzá a modellhez. A különbség a hagyományos elemzés és a lineáris regresszió között az, hogy a lineáris regresszió azt vizsgálja, hogy y hogyan fog reagálni az egyes x változókra egymástól függetlenül.
Lássunk egy példát. Képzelje el, hogy meg akarja jósolni egy fagylaltbolt eladásait. Az adatkészlet különböző információkat tartalmaz, mint például az időjárás (pl. esős, napos, felhős), ügyfélinformációkat (pl. fizetés, nem, családi állapot).
A hagyományos elemzés megpróbálja megjósolni az eladást úgy, hogy mondjuk kiszámolja az egyes változók átlagát, és megpróbálja megbecsülni az eladást különböző forgatókönyvekre. Ez rossz előrejelzésekhez vezet, és az elemzést a kiválasztott forgatókönyvre korlátozza.
Ha lineáris regressziót használ, felí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éget).
Hogyan működik az algoritmus
Az algoritmus mindegyikhez kiválaszt egy véletlen számot 
és a 
és cserélje ki x értékét, hogy megkapja y előrejelzett értékét. Ha az adatkészlet 100 megfigyelést tartalmaz, az algoritmus 100 előrejelzett értéket számít ki.
Ki tudjuk számítani a hibát, jegyezte meg 
a modell értéke, amely a becsült érték és a valós érték különbsége. A pozitív hiba azt jelenti, hogy a modell alulbecsüli y előrejelzését, a negatív hiba pedig azt, hogy a modell túlbecsüli y előrejelzését.
A cél a hiba négyzetének minimalizálása. Az algoritmus kiszámítja a négyzetes hiba átlagát. Ezt a lépést a hiba minimalizálásának nevezik. A lineáris regresszióhoz az Mean Square Error, más néven MSE. Matematikailag ez:
Ahol:
a súlyok olyanok-e 
az előre jelzett értékre utal- y a valós értékek
- m a megfigyelések száma
az előre jelzett értékre utalNe feledje, hogy 
azt jelenti, hogy a mátrixok transzponálását használja. A 
az átlag matematikai jelölése.
A cél a legjobb megtalálása 
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álasztották meg. A súlyok kijavításához optimalizálót kell használni. A hagyományos optimalizáló ún Gradiens Descent.
A gradiens süllyedés veszi a deriváltot, és csökkenti vagy növeli a súlyt. Ha a derivált pozitív, a súly csökken. Ha a derivált negatív, a súly növekszik. A modell frissíti a súlyokat, és újraszámolja a hibát. Ezt a folyamatot addig ismételjük, amíg a hiba már nem változik. Minden folyamatot an ismétlés. Ezenkívül a gradienseket megszorozzák a tanulási sebességgel. A tanulás sebességét jelzi.
Ha a tanulási sebesség túl kicsi, nagyon hosszú időbe telik, amíg az algoritmus konvergál (azaz sok iterációt igényel). Ha a tanulási arány túl magas, előfordulhat, hogy az algoritmus soha nem konvergál.
A fenti képen látható, hogy a modell ezt megelőzően körülbelül 20-szor megismétli a folyamatot, hogy stabil értéket találjon a súlyoknak, így elérve a legalacsonyabb hibát.
Ne feledje, hogy, a hiba nem egyenlő nullával, 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, több információt kell hozzáadnia a modellhez, például több változót, vagy különböző becsléseket kell használnia. .
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 ezt a súlyt
Hogyan tanítsunk 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ó képzésére a TensorFlow segítségével.
A Boston Dataset-et fogja használni, amely a következő változókat tartalmazza
| krimi | az egy főre jutó bűnözési ráta városonként |
|---|---|
| zn | a 25,000 XNUMX négyzetméter feletti telkekre övezett lakóterület aránya. |
| indus | városonkénti nem kiskereskedelmi üzleti hektárok aránya. |
| nox | nitrogén-oxidok koncentrációja |
| rm | átlagos szobaszám lakásonként |
| kor | az 1940 előtt épült, saját tulajdonú egységek aránya |
| dis | súlyozott távolságok öt bostoni munkaügyi központtól |
| adó | teljes értékű ingatlanadó kulcsa dolláronként 10,000 XNUMX |
| ptratio | tanuló-tanár arány városonként |
| medv | A tulajdonos által használt házak medián értéke ezer dollárban |
Három különböző adatkészletet fog létrehozni:
| adatbázisba | célkitűzés | formálják |
|---|---|---|
| Képzések | Tanítsd meg a modellt és szerezd meg a súlyokat | 400, 10 |
| Értékelés | Értékelje a modell teljesítményét nem látott adatokon | 100, 10 |
| Tippelje | Használja a modellt a ház értékének előrejelzésére új adatok alapján | 6, 10 |
A cél az, hogy az adatkészlet jellemzőit felhasználva előre jelezzék a ház értékét.
Az oktatóanyag második részében megtudhatja, hogyan használhatja a TensorFlow-t három különböző módon az adatok importálására:
- Pandákkal
- A Hülye
- Csak TF
Vegye figyelembe, hogy minden lehetőség ugyanazokat az eredményeket nyújtani.
Megtanulja, hogyan használhatja a magas szintű API-t TensorFlow lineáris regressziós modell felépítéséhez, kié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 fárasztó és bonyolultabb a kezdő számára.
pandák
A modell betanításához importálnia kell a szükséges könyvtárakat.
import pandas as pd from sklearn import datasets import tensorflow as tf import itertools
Step 1) Importálja az adatokat ezzel panda.
Ön határozza meg az oszlopneveket, és tárolja a COLUMNS-ban. A pd.read_csv() segítségével importálhatja az adatokat.
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)
predikciós_készlet = pd.read_csv(“E:/boston_predict.csv”, skipinitialspace=True,skiprows=1, names=COLUMNS)
Kinyomtathatja az adatok alakját.
print(training_set.shape, test_set.shape, prediction_set.shape)
teljesítmény
(400, 10) (100, 10) (6, 10)
Vegye figyelembe, hogy a címke, azaz az Ön y, benne van az adatkészletben. Tehát két másik listát kell meghatároznia. Az egyik csak a funkciókat tartalmazza, a másik pedig csak a címke nevét. Ez a két lista megmondja a becslőnek, hogy melyek az adatkészlet jellemzői, és melyik oszlopnév a címke
Ez az alábbi kóddal történik.
FEATURES = ["crim", "zn", "indus", "nox", "rm",
"age", "dis", "tax", "ptratio"]
LABEL = "medv"
Step 2) Konvertálja az adatokat
A numerikus változókat a megfelelő formátumba kell konvertálnia. A Tensorflow módszert biztosít a folytonos változó konvertálására: tf.feature_column.numeric_column().
Az előző lépésben meghatározza a modellbe felvenni kívánt jellemzők listáját. Most ezt a listát használhatja számadatokká konvertálásához. Ha ki szeretne zárni szolgáltatásokat a modellből, nyugodtan dobjon egy vagy több változót a FEATURES listába, mielőtt létrehozza a feature_cols.
Vegye figyelembe, hogy használni fogja Python lista értelmezése a FEATURES listával egy új, feature_cols nevű lista létrehozásához. Segít elkerülni, hogy kilencszer írja le a tf.feature_column.numeric_column(). A listaértelmezés gyorsabb és tisztább módja új listák létrehozásának
feature_cols = [tf.feature_column.numeric_column(k) for k in FEATURES]
Step 3) Határozza meg a becslést
Ebben a lépésben meg kell határoznia a becslést. A Tensorflow jelenleg 6 előre elkészített becslőt biztosít, ebből 3 az osztályozási feladathoz és 3 a TensorFlow regressziós feladathoz:
- Regresszor
- DNNRegressor
- Lineáris regresszor
- DNNLineaCombinedRegressor
- osztályoz
- DNNC osztályozó
- Lineáris osztályozó
- DNNLineaCombinedClassifier
Ebben az oktatóanyagban a Lineáris regresszort fogja használni. 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 foglalandó változókat tartalmazza
- model_dir: elérési út a grafikon tárolásához, a modellparaméterek mentéséhez stb
A Tensorflow automatikusan létrehoz egy train nevű fájlt a munkakönyvtárában. Ezt az elérési utat kell használnia a Tensorboard eléréséhez, ahogy az az alábbi TensorFlow regressziós példában látható.
estimator = tf.estimator.LinearRegressor(
feature_columns=feature_cols,
model_dir="train")
teljesítmény
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}
A TensorFlow trükkös része a modell táplálásának módja. A Tensorflow-t úgy tervezték, hogy párhuzamos számítástechnikával és nagyon nagy adatkészlettel működjön. A gépi erőforrások korlátozottsága miatt lehetetlen a modellt egyszerre az összes adattal betáplálni. Ehhez minden alkalommal egy köteg adatot kell betáplálnia. Vegye figyelembe, hogy hatalmas adathalmazról beszélünk, több millió rekorddal. Ha nem ad hozzá köteget, memóriahiba lesz a végén.
Ha például az adatok 100 megfigyelést tartalmaznak, és 10-es kötegméretet ad meg, az azt jelenti, hogy a modell 10 megfigyelést fog látni minden iterációhoz (10*10).
Amikor a modell az összes adatot látta, befejez egyet korszak. Egy korszak határozza meg, hogy hányszor szeretné, hogy a modell lássa az adatokat. Jobb, ha ezt a lépést semmire állítja, és hagyja, hogy a modell többszöri iterációt hajtson végre.
Egy másik információ, amelyet hozzá kell adni, ha meg szeretné keverni az adatokat minden iteráció előtt. A képzés során fontos az adatok megkeverése, hogy a modell ne tanulja meg az adatkészlet konkrét mintáját. Ha a modell megtanulja az adatok mögöttes mintázatának részleteit, akkor nehézségei lesznek a nem látott adatok előrejelzésének általánosításában. Ezt hívják túlfeszített. A modell jól teljesít a betanítási adatokon, de nem tud megfelelően előre jelezni 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 kell-e megkevernie az adatokat.
A Tensorflow utasítására a modell betáplálására használhatja a pandas_input_fn parancsot. Ennek az objektumnak 5 paraméterre van szüksége:
- x: jellemző adatok
- y: címkeadatok
- batch_size: köteg. Alapértelmezés szerint 128
- num_epoch: Korszak 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 definiáljon egy függvényt a folyamat megismé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ének szokásos módszere a következő:
- Tanítsd meg a modellt
- Értékelje a modellt egy másik adatkészletben
- Készítsen jóslatot
A Tensorflow becslő három különböző funkciót biztosít a három lépés egyszerű végrehajtásához.
Step 4): Tanítsa meg a modellt
A modell értékeléséhez használhatja a becslő sorozatot. A vonatbecslőnek szüksége van egy input_fn paraméterre és számos lépésre. Használhatja a fent létrehozott függvényt a modell betáplálásához. Ezután utasítja a modellt, hogy 1000-szer iteráljon. Ne feledje, hogy nem adja meg az epochák számát, hagyja, hogy a modell 1000-szer iteráljon. Ha az epocha számát 1-re állítja, akkor a modell 4-szer ismétlődik: 400 rekord van a betanítási készletben, a köteg mérete 128
- 128 sorok
- 128 sorok
- 128 sorok
- 16 sorok
Ezért könnyebb beállítani az epochok számát none-ra, és meghatározni az iterációk számát az alábbi TensorFlow osztályozási példában látható módon.
estimator.train(input_fn=get_input_fn(training_set,
num_epochs=None,
n_batch = 128,
shuffle=False),
steps=1000)
teljesítmény
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.
Ellenőrizheti, hogy a Tensorboard a következő parancsot adja:
activate hello-tf # For MacOS tensorboard --logdir=./train # For Windows tensorboard --logdir=train
Step 5) Értékelje a modelljét
Az alábbi kóddal értékelheti modellje tesztkészlethez való illeszkedését:
ev = estimator.evaluate(
input_fn=get_input_fn(test_set,
num_epochs=1,
n_batch = 128,
shuffle=False))
teljesítmény
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
A veszteséget az alábbi kóddal nyomtathatja ki:
loss_score = ev["loss"]
print("Loss: {0:f}".format(loss_score))
teljesítmény
Loss: 3215.895996
A modell vesztesége 3215. Ellenőrizheti az összesítő statisztikát, hogy képet kapjon a hiba nagyságáról.
training_set['medv'].describe()
teljesítmény
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
A fenti összesítő statisztikából tudja, hogy egy ház átlagos ára 22 ezer, minimum 9 ezer, maximum 50 ezer. A modell tipikusan 3 ezer dolláros hibát követ el.
Step 6) Tedd meg a jóslatot
Végül használhatja a TensorFlow 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ékeinek 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)))
teljesítmény
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)]
A modell a következő értékeket prognosztizálja:
| 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 valódi értékét. A mély tanulás oktatóanyagában megpróbálja legyőzni a lineáris modellt
Numpy megoldás
Ez a rész elmagyarázza, hogyan lehet betanítani a modellt egy számszerű becslő segítségével az adatok betáplálásához. A módszer ugyanaz, kivéve a numpy_input_fn becslőt.
training_set_n = pd.read_csv(“E:/boston_train.csv”).values
test_set_n = pd.read_csv(“E:/boston_test.csv”).values
predikciós_készlet_n = pd.read_csv(“E:/boston_predict.csv”).values
Step 1) Importálja az adatokat
Először is meg kell különböztetnie a jellemző változóit a címkétől. Ezt meg kell tennie a képzési adatokhoz és az értékeléshez. Gyorsabb az adatok felosztására szolgáló függvény meghatározása.
def prepare_data(df):
X_train = df[:, :-3]
y_train = df[:,-3]
return X_train, y_train
A funkció segítségével leválaszthatja a címkét a vonat/kiértékelés adatkészlet jellemzőiről
X_train, y_train = prepare_data(training_set_n) X_test, y_test = prepare_data(test_set_n)
Ki kell zárnia az előrejelzési adatkészlet utolsó oszlopát, mert az csak NaN-t tartalmaz
x_predict = prediction_set_n[:, :-2]
Erősítse meg a tömb alakját. Vegye figyelembe, hogy a címkének nem szabad méretet adnia, ez azt jelenti, hogy (400,).
print(X_train.shape, y_train.shape, x_predict.shape)
teljesítmény
(400, 9) (400,) (6, 9)
A jellemzőoszlopokat a következőképpen állíthatja össze:
feature_columns = [ tf.feature_column.numeric_column('x', shape=X_train.shape[1:])]
A becslő a korábbiak szerint van definiálva, Ön utasítja a jellemző oszlopokat és a grafikon mentésének helyét.
estimator = tf.estimator.LinearRegressor(
feature_columns=feature_columns,
model_dir="train1")
teljesítmény
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}
A numpy estimapor segítségével betáplálhatja az adatokat a modellbe, majd betaníthatja a modellt. Ne feledje, hogy az olvashatóság megkönnyítése érdekében korábban definiáljuk az input_fn függvényt.
# 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)
teljesítmény
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>
A modell kiértékeléséhez ugyanazt a lépést meg kell ismételnie egy másik becslővel
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)
teljesítmény
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}
Végül kiszámíthatja az előrejelzést. Hasonlónak kell lennie, mint a pandák.
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)))
teljesítmény
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 oldat
Az utolsó rész egy TensorFlow megoldással foglalkozik. Ez a módszer valamivel bonyolultabb, mint a másik.
Vegye figyelembe, hogy ha használja Jupyter jegyzetfüzet, a munkamenet futtatásához újra kell indítania és meg kell tisztítania a kernelt.
TensorFlow kiépített egy nagyszerű eszközt az adatok átadására a folyamatban. Ebben a részben az input_fn függvényt saját maga készíti el.
Step 1) Határozza meg az adatok elérési útját és formátumát
Először is deklarál két változót a csv fájl elérési útjával. Ne feledje, hogy két fájlja van, egy az edzéskészlethez, egy pedig 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. Mindet felhasználjuk. Ezt követően meg kell határoznia a változó típusát.
A lebegő változókat [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]]
Step 2) Határozza meg az input_fn függvényt
A függvény három részre bontható:
- Importálja az adatokat
- Hozd létre az iterátort
- Fogyassza az adatokat
Az alábbiakban található a funkció meghatározásához szükséges általános kód. A kódot ezután ismertetjük
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
** Importálja az adatokat**
Csv-fájl esetén a dataset metódus egy sort olvas be. Az adatkészlet felépítéséhez az objektumot kell használni TextLineAdatkészlet. Az adatkészletnek van fejléce, ezért az első sor kihagyásához a skip(1)-et kell használnia. Ezen a ponton csak az adatokat olvassa el, és kizárja a fejlécet a folyamatban. A modell betáplálásához el kell választani a funkciókat a címkétől. Az adatok bármilyen transzformációjának alkalmazására használt módszer a térkép.
Ez a metódus meghív egy függvényt, amelyet létre kell hozni, hogy utasításokat adjon az adatok átalakítására. Dióhéjban, át kell adnia az adatokat a TextLineDataset objektum, zárja ki a fejlécet, és alkalmazzon egy függvény által utasított transzformációt.Kód magyarázata
- tf.data.TextLineDataset(data_file): Ez a sor olvassa be a csv fájlt
- .skip(1) : a fejléc kihagyása
- .map(parse_csv)): elemzi a rekordokat a tenzorokba. Meg kell határoznia egy függvényt, amely utasítást ad a térképobjektumnak. Meghívhatja ezt a függvényt parse_csv.
Ez a függvény a tf.decode_csv metódussal elemzi a csv fájlt, és deklarálja a szolgáltatásokat és a címkét. A jellemzők deklarálhatók szótárként vagy sorként. A szótár módszert használod, mert kényelmesebb.Kódmagyarázat
- tf.decode_csv(value, record_defaults= RECORDS_ALL): a decode_csv metódus a TextLineAdatkészlet a csv fájl olvasásához. A record_defaults utasítja a TensorFlow-t az oszlopok típusára vonatkozóan.
- dict(zip(_CSV_COLUMNS, oszlopok)): A szótár feltöltése az adatfeldolgozás során kibontott összes oszloptal
- features.pop('median_house_value'): Zárja ki a célváltozót a jellemzőváltozóból, és hozzon létre egy címkeváltozót
Az adatkészletnek további elemekre van szüksége a tenzorok iteratív táplálásához. Valójában hozzá kell adni a metódusismétlést, hogy az adatkészlet korlátlan ideig folytathassa a modell táplálását. Ha nem adja hozzá a metódust, a modell csak egyszer ismétlődik, majd hibát ad, mert a folyamatban nincs több adat.
Ezt követően kötegelt módszerrel szabályozhatja a köteg méretét. Ez azt jelenti, hogy meg kell adnia az adatkészletnek, hogy hány adatot szeretne átadni a folyamatban minden iterációhoz. Ha nagy tételméretet állít be, a modell lassú lesz.
3. lépés) Hozza létre az iterátort
Most 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 el az adatokat
Ellenőrizheti, hogy mi történik az input_fn függvénnyel. Az adatok felhasználásához meg kell hívnia a függvényt egy munkamenetben. Próbálkozzon 1-es tételmérettel.
Vegye figyelembe, hogy a szótár jellemzőit és a címkét tömbként nyomtatja ki.
Megjelenik a csv fájl első sora. Megpróbálhatja többször futtatni ezt a kódot különböző kötegméretekkel.
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)
teljesítmény
({'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))
Step 4) Határozza meg a jellemző 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')
Vegye figyelembe, hogy az összes változót egy vödörben kell kombinálnia
base_columns = [X1, X2, X3,X4, X5, X6,X7, X8, X9]
Step 5) Építsd meg a modellt
A modellt a LinearRegressor becslővel taníthatja.
model = tf.estimator.LinearRegressor(feature_columns=base_columns, model_dir='train3')
teljesítmény
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}
Használnia kell egy lambda függvényt, hogy engedélyezze az argumentum beírását az inpu_fn függvényben. Ha nem használ a lambda funkció, 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))
teljesítmény
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>
Az alábbi kóddal értékelheti a modell illeszkedését a tesztkészletre:
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]))
teljesítmény
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
Az utolsó lépés az érték megjóslása a jellemzők mátrixai alapján. Írhat egy szótárt a megjósolni kívánt értékekkel. Modellje 9 funkcióval rendelkezik, így mindegyikhez meg kell adnia egy értéket. A modell mindegyikre előrejelzést ad.
Az alábbi kódban megadta a df_predict csv fájlban található összes szolgáltatás értékét.
Új input_fn függvényt kell írnia, mert nincs címke az adatkészletben. Használhatja a from_tensor API-t 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)
teljesítmény
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)})
Összegzésként
A modell betanításához a következőket kell tennie:
- Határozza meg 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/próbakészletet
- Határozza meg a kezdeti súlyt
- Határozza meg a veszteségfüggvényt: MSE
- A modell optimalizálása: Gradiens süllyedés
- Határozza meg:
- Tanulási arány
- Korszak 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éshez. Meg kell határoznia:
- Funkcióoszlopok. Ha folyamatos: tf.feature_column.numeric_column(). Feltölthet egy listát a python listaértelmezéssel
- A becslő: tf.estimator.LinearRegressor(feature_columns, model_dir)
- Egy függvény az adatok importálására, a köteg méretére és korszakára: input_fn()
Ezt követően készen áll a képzésre, a kiértékelésre és a jóslatok készítésére a train(), az értékelés() és az előrejelzés() segítségével.
