TensorFlow bináris osztályozás: Lineáris osztályozó példa

⚡ Okos összefoglaló

A lineáris osztályozók minden megfigyelést egy osztályba sorolnak a jellemzőinek súlyozott összege alapján. Ez a bemutató egy TensorFlow bináris osztályozót épít a népszámlálási adathalmazra, és 0.76-ról 0.84-re növeli a pontosságot.

  • 🔘 Alapdefiníció: Egy lineáris osztályozó a jellemzőértékek lineáris kombinációjából egy diszkrét osztályt jósol.
  • ☑️ Valószínűségi lépés: A logisztikus függvény a lineáris modell kimenetét 0 és 1 közötti valószínűségértékké alakítja.
  • ✅ A metrikák számítanak: A pontosság önmagában félrevezető a kiegyensúlyozatlan címkéknél, ezért párosítsd a zavaró mátrixszal, a pontossággal és a visszaidézhetőséggel.
  • 🧪 Népszámlálási útmutató: Hat folytonos és nyolc kategorikus oszlop tenzorrá válik, mielőtt a becslő egyáltalán meglátná őket.
  • 🇧🇷 Funkciótervezés: A kor négyzetre emelése, csoportosítása, majd az iskolai végzettség és a foglalkozás keresztezése 0.7616-ról 0.8358-ra növeli a pontosságot.
  • 📈 Szabályozás: Egy Ftrl optimalizáló, ahol az L1 értéke 0.9, az L2 pedig 5, a végső pontosságot 0.8383-ra csökkenti.

TensorFlow bináris osztályozás Lineáris osztályozó

A két leggyakoribb felügyelt tanulás feladatok a lineáris regresszió és a lineáris osztályozó. A lineáris regresszió egy értéket, míg a lineáris osztályozó egy osztályt jósol. Ez az oktatóanyag a lineáris osztályozókra összpontosít.

Mi az a lineáris osztályozó?

A Lineáris osztályozó A Machine Learning egy módszer az objektumok osztályának megtalálására a statisztikai osztályozáshoz szükséges jellemzői alapján. Az osztályozási döntést egy objektum jellemzőinek lineáris kombinációjának értéke alapján hozza meg. A lineáris osztályozót olyan gyakorlati problémákban használják, mint a dokumentumok osztályozása és a sok változót tartalmazó problémák.

Az osztályozási problémák a gépi tanulási feladat nagyjából 80 százalékát teszik ki. Az osztályozás célja, hogy előre jelezze az egyes osztályok valószínűségét egy adott bemeneti halmaz mellett. A címke (azaz a függő változó) egy diszkrét érték, amelyet osztálynak nevezünk.

  1. Ha a címkének csak két osztálya van, a tanulási algoritmus egy bináris osztályozó.
  2. A többosztályú osztályozó a kettőnél több osztályt tartalmazó címkéket kezeli.

Például egy tipikus bináris besorolási probléma annak megjóslása, hogy a vásárló mekkora valószínűséggel hajt végre második vásárlást. A képen megjelenő állat típusának megjóslása többosztályú osztályozási probléma, mivel kettőnél több állatfaj létezik.

Ennek az oktatóanyagnak az elméleti része elsődlegesen a bináris osztályra helyezi a hangsúlyt. Egy későbbi oktatóanyagban többet megtudhat a többosztályú kimeneti funkcióról.

Miután a definíció megvan, a következő lépés annak vizsgálata, hogy az algoritmus hogyan alakítja át a nyers jellemzőket osztálydöntéssé.

Hogyan működik a bináris osztályozó?

Az előző oktatóanyagban megtanulta, hogy egy függvény kétféle változóból áll, egy függő változóból és egy tulajdonsághalmazból (független változókból). A lineáris regresszióban a függő változó tartomány nélküli valós szám. Az elsődleges cél az érték előrejelzése az átlagos négyzetes hiba minimalizálásával.

Minden TensorFlow Bináris osztályozó, a címkének két lehetséges egész értéke lehet. A legtöbb esetben [0,1] vagy [1,2]. Például a cél annak előrejelzése, hogy egy vásárló megvásárol-e egy terméket vagy sem. A címke a következőképpen van definiálva:

  • I = 1 (az ügyfél megvásárolta a terméket)
  • I = 0 (az ügyfél nem vásárolja meg a terméket)

A modell az X jellemzőket használja arra, hogy minden vásárlót abba a legvalószínűbb osztályba soroljon, amelybe tartozik, nevezetesen, hogy potenciális vásárló vagy sem.

A siker valószínűsége kiszámításra kerül logisztikus regresszió. Az algoritmus az X jellemző alapján számítja ki a valószínűséget, és akkor jósol sikert, ha ez a valószínűség 50 százalék felett van. Formálisabban a valószínűség kiszámítása az alábbi TensorFlow bináris osztályozási példában látható:

TensorFlow bináris osztályozó által használt szigmoid valószínűségi képlet

ahol 0 a súlyok, a jellemzők halmaza és b a torzítás.

A függvény két részre bontható:

  • A lineáris modell
  • A logisztikai funkció

Lineáris modell

Ön már ismeri a súlyok kiszámításának módját. A súlyok kiszámítása pontszorzat segítségével történik:A súlyvektor és a jellemzővektor skaláris szorzata Y az összes x jellemző lineáris függvényei. Ha a modell nem rendelkezik jellemzőkkel, az előrejelzés egyenlő a torzítással, b.

A súlyok jelzik az x jellemzők közötti korreláció irányáti és az y címkét. A pozitív korreláció növeli a pozitív osztály valószínűségét, míg a negatív korreláció közelebb viszi a valószínűséget a 0-hoz (azaz negatív osztályhoz).

A lineáris modell csak valós számot ad vissza, ami nincs összhangban a [0,1] tartomány valószínűségi mértékével. A logisztikai függvény szükséges a lineáris modell kimenetének valószínűségre konvertálásához,

Logisztikai funkció

A logisztikai függvény vagy szigmoid függvény S-alakú, és ennek a függvénynek a kimenete mindig 0 és 1 között van.

Az alábbi képlet a transzformációt írja le, az azt követő ábra pedig a kapott görbe balra 0, jobbra pedig 1 felé laposodását mutatja.

Logisztikus függvényképlet, amely egy lineáris pontszámot egy valószínűséghez rendel

S alakú szigmoid görbe, 0 és 1 között határolva
Példa a logisztikai funkcióra

A lineáris regresszió kimenetét könnyű behelyettesíteni a szigmoid függvénybe. Ez egy új számot eredményez 0 és 1 közötti valószínűséggel.

Az osztályozó a valószínűséget osztályba tudja alakítani

  • A 0 és 0.49 közötti értékek 0 osztályúvá válnak
  • A 0.5 és 1 közötti értékek 1 osztályúvá válnak

Miután a modell osztályokat állít elő, szükséged van egy módszerre annak megítélésére, hogy ezek az osztályok jók-e.

Hogyan mérjük a lineáris osztályozó teljesítményét?

Pontosság

Az osztályozó általános teljesítményét a pontossági mérőszámmal mérik. A pontosság összegyűjti az összes helyes értéket elosztva a megfigyelések teljes számával. Például a 80 százalékos pontossági érték azt jelenti, hogy a modell az esetek 80 százalékában helyes.

A pontossági képlet a helyes előrejelzéseket az összes megfigyeléshez viszonyítva számolja

Mérje meg a lineáris osztályozó teljesítményét a pontossági mérőszám segítségével

Hiányosság figyelhető meg ezzel a mérőszámmal, különösen az egyensúlyhiány-osztály esetében. Kiegyensúlyozatlansági adatkészlet akkor fordul elő, ha a megfigyelések száma csoportonként nem egyenlő. Mondjuk; egy ritka eseményt próbál logisztikai funkcióval besorolni. Képzelje el, hogy az osztályozó megpróbálja megbecsülni a beteg halálát egy betegség után. Az adatok szerint a betegek 5 százaléka elhal. Betaníthat egy osztályozót a halálozások számának előrejelzésére, és a pontossági mérőszám segítségével értékelheti a teljesítményt. Ha az osztályozó a teljes adathalmazra 0 halált jósol, akkor az esetek 95 százalékában helyes lesz.

Zavart mátrix

Egy osztályozó teljesítményének jobb értékelése a zavaros mátrix vizsgálata.

Bináris zavarmátrix, amely a TP, FP, FN és TN négyzeteket mutatja

Mérje meg a Lineáris Osztályozó teljesítményét a Confusion mátrix segítségével

Az zavart mátrix megjeleníti egy osztályozó pontosságát a tényleges és az előre jelzett osztályok összehasonlításával, ahogy az a fenti Lineáris osztályozó példában látható. A bináris összetévesztési mátrix négyzetekből áll:

  • TP: True Positive: A megjósolt értékek helyesen jósolva tényleges pozitívnak
  • FP: A becsült értékek hibásan jósoltak tényleges pozitívat. azaz a negatív értékeket pozitívnak jósolták
  • FN: Hamis negatív: A pozitív értékek negatívnak jósolhatók
  • TN: True Negative: A becsült értékek tényleges negatívként jósolva helyesen

A zavaros mátrixból könnyen összehasonlítható a tényleges osztály és az előre jelzett osztály.

Precizitás és érzékenység

A zavaros mátrix jó betekintést nyújt a valódi pozitív és a hamis pozitívumokba. Egyes esetekben célszerű tömörebb mérőszámot használni.

Pontosság

A precíziós metrika a pozitív osztály pontosságát mutatja. Azt méri, hogy a pozitív osztály előrejelzése mennyire valószínű.

Precíziós képlet, valódi pozitív eredmények a várt pozitív eredményekkel szemben

A maximális pontszám 1, ha az osztályozó az összes pozitív értéket tökéletesen osztályozza. A pontosság önmagában nem nagyon hasznos, mert figyelmen kívül hagyja a negatív osztályt. A metrika általában a visszahívási metrikával párosul. A visszahívást érzékenységnek vagy valódi pozitív aránynak is nevezik.

Érzékenység

Az érzékenység a helyesen észlelt pozitív osztályok arányát számítja ki. Ez a mérőszám megmutatja, hogy a modell mennyire alkalmas egy pozitív osztály felismerésére.

Érzékenységi képlet, valódi pozitív eredmények a tényleges pozitív eredményekkel szemben

Az elmélet most már a helyén van, így a bemutató további részében a kódban a végétől a végéig alkalmazzuk.

Lineáris osztályozó TensorFlow-val

Ehhez az oktatóanyaghoz a népszámlálási adatkészletet fogjuk használni. A cél az, hogy a népszámlálási adatkészlet változóit felhasználjuk a jövedelemszint előrejelzésére. Vegye figyelembe, hogy a jövedelem egy bináris változó

  • 1-es értékkel, ha a bevétel > 50k
  • 0, ha a bevétel < 50k.

Ez a változó az Ön címkéje

Ez az adatkészlet nyolc kategorikus változót tartalmaz:

  • munkahelyen
  • szabott oktatás
  • házastársi
  • foglalkozás
  • kapcsolat
  • verseny
  • szex
  • Szülőföld

továbbá hat folytonos változó:

  • kor
  • fnlwgt
  • oktatási_szám
  • tőkenyereség
  • tőke_veszteség
  • óra_hét

Ezen a TensorFlow osztályozási példán keresztül meg fogja érteni, hogyan lehet lineáris TensorFlow osztályozókat tanítani TensorFlow becsléssel, és hogyan javíthatja a pontossági mérőszámot.

Verzió megjegyzés: Az alábbi kód a TensorFlow 1.x Estimator API-t használja. A tf-estimator A csomag a TensorFlow 2.15-ös verziójával érkezett véglegesen, és nem érhető el a TensorFlow 2.16-os vagy újabb verziójában, ezért futtassa ezeket a kódrészleteket a TensorFlow 1.x-en, vagy portolja őket a hivatalos verzióval. előre elkészített becslő migrációs útmutatójaA koncepciók, a funkciótervezés és a metrikák változatlanok maradnak.

A következőképpen járunk el:

  • 1. lépés) Importálja az adatokat
  • 2. lépés: Adatkonverzió
  • 3. lépés) Tanítsa meg az osztályozót
  • 4. lépés) Javítsa a modellt
  • 5. lépés) Hiperparaméter: Lasso & Ridge

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

Először importálja az oktatóprogram során használt könyvtárakat.

import tensorflow as tf
import pandas as pd

Ezután importálja az adatokat az UCI archívumából, és meghatározza az oszlopok nevét. Az OSZLOPOK segítségével elnevezheti az oszlopokat egy panda adatkeretben.

Vegye figyelembe, hogy az osztályozót egy Pandas adatkeret segítségével fogja betanítani.

## Define path data
COLUMNS = ['age','workclass', 'fnlwgt', 'education', 'education_num', 'marital',
           'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss',
           'hours_week', 'native_country', 'label']
PATH = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data"
PATH_test = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.test"

Az online tárolt adatok már fel vannak osztva egy vonatszerelvény és a tesztkészlet között.

df_train = pd.read_csv(PATH, skipinitialspace=True, names = COLUMNS, index_col=False)
df_test = pd.read_csv(PATH_test,skiprows = 1, skipinitialspace=True, names = COLUMNS, index_col=False)

A vonatkészlet 32,561 ​​16,281 megfigyelést tartalmaz, a tesztkészlet pedig XNUMX XNUMX megfigyelést

print(df_train.shape, df_test.shape)
print(df_train.dtypes)
(32561, 15) (16281, 15)
age                int64
workclass         object
fnlwgt             int64
education         object
education_num      int64
marital           object
occupation        object
relationship      object
race              object
sex               object
capital_gain       int64
capital_loss       int64
hours_week         int64
native_country    object
label             object
dtype: object

A TensorFlow logikai értéket igényel az osztályozó betanításához. A karakterlánc értékeket egész számmá kell alakítani. A címkét objektumként tárolja a rendszer, de numerikus értékké kell konvertálni. Az alábbi kód létrehoz egy szótárat az átalakítandó értékekkel, és végigmegy az oszlopelemen. Fontos megjegyezni, hogy ezt a műveletet kétszer kell végrehajtani, egyszer a vonatteszthez, egyszer a teszthalmazhoz.

label = {'<=50K': 0,'>50K': 1}
df_train.label = [label[item] for item in df_train.label]
label_t = {'<=50K.': 0,'>50K.': 1}
df_test.label = [label_t[item] for item in df_test.label]

A vonatadatokban 24 720 olyan jövedelem szerepel, amely 50 ezer alatt van, és 7841 olyan, amely 50 ezer felett van. Az arány majdnem azonos a teszthalmaz esetében, tehát mindkét osztás nagyjából 76 százaléka a negatív osztályba tartozik.

print(df_train["label"].value_counts())
### The model will be correct in atleast 70% of the case
print(df_test["label"].value_counts())
## Unbalanced label
print(df_train.dtypes)
0    24720
1     7841
Name: label, dtype: int64
0    12435
1     3846
Name: label, dtype: int64
age                int64
workclass         object
fnlwgt             int64
education         object
education_num      int64
marital           object
occupation        object
relationship      object
race              object
sex               object
capital_gain       int64
capital_loss       int64
hours_week         int64
native_country    object
label              int64
dtype: object

2. lépés: Adatkonverzió

Néhány lépésre van szükség, mielőtt egy lineáris osztályozót betanítanál a TensorFlow-val. Elő kell készítened a modellbe foglalandó jellemzőket. A benchmark regresszióban az eredeti adatokat transzformáció alkalmazása nélkül fogod használni, pontosan úgy, ahogy egy scikit elsajátítható A folyamat nyers oszlopokból indulna ki.

A becslőnek rendelkeznie kell a funkciók listájával a modell betanításához. Ezért az oszlop adatait tenzorrá kell konvertálni.

A jó gyakorlat az, hogy két jellemzőlistát definiál a típusuk alapján, majd átadja őket a becslő feature_columns részében.

Kezdje a folyamatos jellemzők konvertálásával, majd definiáljon egy gyűjtőt a kategorikus adatokkal.

Az adatkészlet funkciói kétféle formátummal rendelkeznek:

  • Egész szám
  • tárgy

Mindegyik jellemző típusa szerint a következő két változóban szerepel.

## Add features to the bucket: 
### Define continuous list
CONTI_FEATURES  = ['age', 'fnlwgt','capital_gain', 'education_num', 'capital_loss', 'hours_week']
### Define the categorical list
CATE_FEATURES = ['workclass', 'education', 'marital', 'occupation', 'relationship', 'race', 'sex', 'native_country']

A feature_column egy numeric_column objektummal van ellátva, amely segít a folytonos változók tenzorrá alakításában. Az alábbi kódban a CONTI_FEATURES összes változóját számértékkel rendelkező tenzorrá konvertálja. Ez kötelező a modell elkészítéséhez. Minden független változót át kell alakítani a megfelelő típusú tenzorra.

Az alábbiakban egy kódot írunk, amely megmutatja, mi történik a feature_column.numeric_column mögött. Kinyomtatjuk az életkor konvertált értékét. Ez magyarázó jellegű, ezért nem kell megérteni a Python kód. A kódok megértéséhez tekintse meg a hivatalos dokumentációt.

def print_transformation(feature = "age", continuous = True, size = 2): 
    #X = fc.numeric_column(feature)
    ## Create feature name
    feature_names = [
    feature]

    ## Create dict with the data
    d = dict(zip(feature_names, [df_train[feature]]))

    ## Convert age
    if continuous == True:
        c = tf.feature_column.numeric_column(feature)
        feature_columns = [c]
    else: 
        c = tf.feature_column.categorical_column_with_hash_bucket(feature, hash_bucket_size=size) 
        c_indicator = tf.feature_column.indicator_column(c)
        feature_columns = [c_indicator]
    
## Use input_layer to print the value
    input_layer = tf.feature_column.input_layer(
        features=d,
        feature_columns=feature_columns
        )
    ## Create lookup table
    zero = tf.constant(0, dtype=tf.float32)
    where = tf.not_equal(input_layer, zero)
    ## Return lookup tble
    indices = tf.where(where)
    values = tf.gather_nd(input_layer, indices)
    ## Initiate graph
    sess = tf.Session()
    ## Print value
    print(sess.run(input_layer))
print_transformation(feature = "age", continuous = True) 
[[39.]
 [50.]
 [38.]
 ...
 [58.]
 [22.]
 [52.]]

Az értékek pontosan megegyeznek a df_train értékével

continuous_features = [tf.feature_column.numeric_column(k) for k in CONTI_FEATURES]

A TensorFlow dokumentációja szerint különböző módokon lehet kategorikus adatokat konvertálni. Ha egy jellemző szókincslistája ismert, és nem rendelkezik sok értékkel, akkor létrehozható a kategorikus oszlop a kategorikus_oszlop_szójegyzékkel. Minden egyedi szókincslistához azonosítót rendel.

Például, ha egy változó állapotának három különböző értéke van:

  • Férj
  • Feleség
  • egyetlen

Ezután három azonosító lesz hozzárendelve. Például a férjnek lesz az 1-es azonosítója, a feleségnek a 2-es azonosítója és így tovább.

Illusztráció céljából ezt a kódot használhatja egy objektumváltozó kategorikus oszlopává konvertálására a TensorFlow-ban.

A nemnek csak két értéke lehet: férfi vagy nő. Amikor a nemet konvertáljuk, a TensorFlow két új oszlopot hoz létre, egyet a férfinak és egyet a nőnek. Ha a nem egyenlő a férfival, akkor az új „férfi” oszlop értéke 1, a „nő” pedig 0 lesz. Ez a példa az alábbi táblázatban látható:

sorok szex átalakulás után férfi női
1 férfi => 1 0
2 férfi => 1 0
3 női => 0 1

Tenzorfolyamban:

print_transformation(feature = "sex", continuous = False, size = 2)
[[1. 0.]
 [1. 0.]
 [1. 0.]
 ...
 [0. 1.]
 [1. 0.]
 [0. 1.]]

relationship = tf.feature_column.categorical_column_with_vocabulary_list(
    'relationship', [
        'Husband', 'Not-in-family', 'Wife', 'Own-child', 'Unmarried',
        'Other-relative'])

Az alábbiakban hozzáadtuk Python kódot a kódolás kinyomtatásához. Ismétlem, nem kell értened a kódot, a cél az, hogy lásd az átalakítást

Azonban az adatok átalakításának gyorsabb módja a categoric_column_with_hash_bucket metódus használata. A ritka mátrixban a karakterláncváltozók módosítása hasznos lesz. A ritka mátrix egy olyan mátrix, amelyben többnyire nullák vannak. A metódus mindent kezel. Csak a vödrök számát és a kulcsoszlopot kell megadni. A vödrök száma a TensorFlow által létrehozható csoportok maximális száma. A kulcsoszlop egyszerűen a konvertálandó oszlop neve.

Az alábbi kódban hurkot hoz létre az összes kategorikus jellemző felett.

categorical_features = [tf.feature_column.categorical_column_with_hash_bucket(k, hash_bucket_size=1000) for k in CATE_FEATURES]

3. lépés) Tanítsa meg az osztályozót

A TensorFlow jelenleg egy becslést biztosít a lineáris regresszióhoz és a lineáris osztályozáshoz.

  • Lineáris regresszió: Lineáris regresszió
  • Lineáris osztályozás: LinearClassifier

A lineáris osztályozó szintaxisa ugyanaz, mint az oktatóanyagban lineáris regresszió kivéve egy argumentumot, n_class. Meg kell határoznia a jellemző oszlopot, a modellkönyvtárat, és összehasonlítani kell a lineáris regresszorral; meg kell határoznia az osztályok számát. Logit regresszió esetén az osztályok száma egyenlő 2-vel.

A modell kiszámítja a folyamatos_jellemzők és a kategorikus_jellemzők oszlopok súlyát.

model = tf.estimator.LinearClassifier(
    n_classes = 2,
    model_dir="ongoing/train", 
    feature_columns=categorical_features+ continuous_features)

teljesítmény

INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'ongoing/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 0x181f24c898>, '_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}

Most, hogy az osztályozó definiált, létrehozhatja a bemeneti függvényt. A módszer ugyanaz, mint a lineáris regresszor oktatóanyagában. Itt 128-as kötegméretet használ, és megkeveri az adatokat.

FEATURES = ['age','workclass', 'fnlwgt', 'education', 'education_num', 'marital', 'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss', 'hours_week', 'native_country']
LABEL= 'label'
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)

Létrehoz egy függvényt a lineáris becslő által megkövetelt argumentumokkal, azaz a korszakok számával, a kötegek számával, és megkeveri az adatkészletet vagy megjegyzést. Mivel használod a pandák Az adatok modellbe való átadásához az X változókat panda adatkeretként kell definiálnia. Ne feledje, hogy a FEATURES-ban tárolt összes adatot végighurkolja.

Tanítsuk meg a modellt az objektummodell.train segítségével. A korábban definiált függvény segítségével a megfelelő értékekkel táplálja a modellt. Vegye figyelembe, hogy a köteg méretét 128-ra, az epochok számát pedig Nincs értékre állítja. A modellt ezer lépésen keresztül képezik ki.

model.train(input_fn=get_input_fn(df_train, 
                                      num_epochs=None,
                                      n_batch = 128,
                                      shuffle=False),
                                      steps=1000)
									 
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 ongoing/train/model.ckpt.
INFO:tensorflow:loss = 88.722855, step = 1
INFO:tensorflow:global_step/sec: 65.8282
INFO:tensorflow:loss = 52583.64, step = 101 (1.528 sec)
INFO:tensorflow:global_step/sec: 118.386
INFO:tensorflow:loss = 25203.816, step = 201 (0.837 sec)
INFO:tensorflow:global_step/sec: 110.542
INFO:tensorflow:loss = 54924.312, step = 301 (0.905 sec)
INFO:tensorflow:global_step/sec: 199.03
INFO:tensorflow:loss = 68509.31, step = 401 (0.502 sec)
INFO:tensorflow:global_step/sec: 167.488
INFO:tensorflow:loss = 9151.754, step = 501 (0.599 sec)
INFO:tensorflow:global_step/sec: 220.155
INFO:tensorflow:loss = 34576.06, step = 601 (0.453 sec)
INFO:tensorflow:global_step/sec: 199.016
INFO:tensorflow:loss = 36047.117, step = 701 (0.503 sec)
INFO:tensorflow:global_step/sec: 197.531
INFO:tensorflow:loss = 22608.148, step = 801 (0.505 sec)
INFO:tensorflow:global_step/sec: 208.479
INFO:tensorflow:loss = 22201.918, step = 901 (0.479 sec)
INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train/model.ckpt.
INFO:tensorflow:Loss for final step: 5444.363.

<tensorflow.python.estimator.canned.linear.LinearClassifier at 0x181f223630>

Ne feledje, hogy a veszteség az utolsó 100 lépésben később csökkent, azaz 901-ről 1000-re.

A végső veszteség ezer iteráció után 5444. A tesztkészleten megbecsülheti modelljét, és láthatja a teljesítményt. A modell teljesítményének értékeléséhez az objektumértékelést kell használnia. Betáplálod a modellt a tesztkészlettel, és az epochok számát 1-re állítod, azaz az adatok csak egyszer jutnak el a modellhez.

model.evaluate(input_fn=get_input_fn(df_test, 
                                      num_epochs=1,
                                      n_batch = 128,
                                      shuffle=False),
                                      steps=1000)
									  
INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-06-02-08:28:22
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from ongoing/train/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [100/1000]
INFO:tensorflow:Finished evaluation at 2018-06-02-08:28:23
INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.7615626, accuracy_baseline = 0.76377374, auc = 0.63300294, auc_precision_recall = 0.50891197, average_loss = 47.12155, global_step = 1000, label/mean = 0.23622628, loss = 5993.6406, precision = 0.49401596, prediction/mean = 0.18454961, recall = 0.38637546

{'accuracy': 0.7615626,
 'accuracy_baseline': 0.76377374,
 'auc': 0.63300294,
 'auc_precision_recall': 0.50891197,
 'average_loss': 47.12155,
 'global_step': 1000,
 'label/mean': 0.23622628,
 'loss': 5993.6406,
 'precision': 0.49401596,
 'prediction/mean': 0.18454961,
 'recall': 0.38637546}

A TensorFlow visszaadja az elméleti részben tanult összes mérőszámot. Nem meglepő, hogy a pontosság nagy a kiegyensúlyozatlan címke miatt. Valójában a modell valamivel jobban teljesít, mint egy véletlenszerű találgatás. Képzelje el, hogy a modell minden 50 70-nál alacsonyabb jövedelemmel rendelkező háztartást jósol, akkor a modell XNUMX százalékos pontossággal rendelkezik. Közelebbi elemzés során láthatja, hogy az előrejelzés és a visszahívás meglehetősen alacsony.

4. lépés) Javítsa a modellt

Most, hogy van benchmark modellje, megpróbálhatja javítani, vagyis növelni a pontosságot. Az előző oktatóanyagban megtanulta, hogyan javíthatja az előrejelzési teljesítményt interakciós kifejezéssel. Ebben az oktatóanyagban újra átgondolja ezt az ötletet úgy, hogy hozzáad egy polinomi tagot a regresszióhoz.

A polinomiális regresszió akkor hasznos, ha az adatok nemlinearitást mutatnak. Az adatok nemlinearitása kétféleképpen rögzíthető.

  • Polinom tag hozzáadása
  • Csoportosítsa a folytonos változót kategorikus változóvá

Polinom tag

Az alábbi képen láthatja, mi az a polinomiális regresszió. Ez egy X változót tartalmazó egyenlet, amelyek különböző erősségűek. A másodfokú polinomiális regressziónak két változója van, X és X négyzet. A harmadik fokozatnak három változója van, X, X2és X3

Másod- és harmadfokú polinomiális regressziós egyenletek

Mi a polinomiális regresszió

A fenti diagram egy másodfokú görbét ábrázol az alapjául szolgáló egyenlet függvényében. Alább egy grafikont készítettünk két változóval, X-szel és Y-nal. Nyilvánvaló, hogy a kapcsolat nem lineáris. Ha lineáris regressziót adunk hozzá, láthatjuk, hogy a modell nem tudja megragadni a mintázatot (bal oldali kép).

Most nézd meg a bal oldali képet az alábbi képről, a regresszióhoz öttagot adtunk (azaz y=x+x2+x3+x4+x5. A modell most sokkal jobban rögzíti a mintát. Ez a polinomiális regresszió ereje.

Lineáris illesztés versus öttagú polinom illesztés ugyanazon a szóródási diagramon

Térjünk vissza példánkhoz. Az életkor nincs lineáris kapcsolatban a jövedelemmel. Előfordulhat, hogy a korai életkorban nullához közeli egyenértékű jövedelem jár, mert a gyerekek vagy a fiatalok nem dolgoznak. Aztán munkaképes korban nő, nyugdíjkor pedig csökken. Általában fordított U alakú. Ennek a mintának az egyik módja a kettős hatvány hozzáadása a regresszióhoz.

Lássuk, növeli-e a pontosságot.

Ezt az új funkciót hozzá kell adni az adatkészlethez és a folyamatos szolgáltatás listájához.

Hozzáadja az új változót a vonat és a teszt adatkészlethez, így kényelmesebb egy függvényt írni.

def square_var(df_t, df_te, var_name = 'age'):
    df_t['new'] = df_t[var_name].pow(2) 
    df_te['new'] = df_te[var_name].pow(2) 
    return df_t, df_te

A függvénynek 3 argumentuma van:

  • df_t: határozza meg az edzéskészletet
  • df_te: határozza meg a tesztkészletet
  • var_name = 'age': Határozza meg az átalakítandó változót

Használhatja a pow(2) objektumot az életkor négyzetére. Vegye figyelembe, hogy az új változó neve "new"

Most, hogy a square_var függvény meg van írva, létrehozhatja az új adatkészleteket.

df_train_new, df_test_new = square_var(df_train, df_test, var_name = 'age')

Amint látja, az új adatkészlet még egy funkcióval rendelkezik.

print(df_train_new.shape, df_test_new.shape)			
(32561, 16) (16281, 16)

A négyzetes változót újnak nevezzük az adatkészletben. Hozzá kell adnia a folyamatos szolgáltatások listájához.

CONTI_FEATURES_NEW  = ['age', 'fnlwgt','capital_gain', 'education_num', 'capital_loss', 'hours_week', 'new']
continuous_features_new = [tf.feature_column.numeric_column(k) for k in CONTI_FEATURES_NEW]

Megjegyzések hogy megváltoztatta a Graph könyvtárát. Nem taníthat be különböző modelleket ugyanabban a könyvtárban. Ez azt jelenti, hogy módosítania kell a model_dir argumentum elérési útját. Ha nem, a TensorFlow hibát jelez.

model_1 = tf.estimator.LinearClassifier(
    model_dir="ongoing/train1", 
    feature_columns=categorical_features+ continuous_features_new)
INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'ongoing/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 0x1820f04b70>, '_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}
FEATURES_NEW = ['age','workclass', 'fnlwgt', 'education', 'education_num', 'marital', 'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss', 'hours_week', 'native_country', 'new']
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_NEW}),
       y = pd.Series(data_set[LABEL].values),
       batch_size=n_batch,   
       num_epochs=num_epochs,
       shuffle=shuffle)

Most, hogy az osztályozót az új adatkészlettel tervezték, betaníthatja és értékelheti a modellt.

model_1.train(input_fn=get_input_fn(df_train, 
                                      num_epochs=None,
                                      n_batch = 128,
                                      shuffle=False),
                                      steps=1000)
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 ongoing/train1/model.ckpt.
INFO:tensorflow:loss = 88.722855, step = 1
INFO:tensorflow:global_step/sec: 81.487
INFO:tensorflow:loss = 70077.66, step = 101 (1.228 sec)
INFO:tensorflow:global_step/sec: 111.169
INFO:tensorflow:loss = 49522.082, step = 201 (0.899 sec)
INFO:tensorflow:global_step/sec: 128.91
INFO:tensorflow:loss = 107120.57, step = 301 (0.776 sec)
INFO:tensorflow:global_step/sec: 132.546
INFO:tensorflow:loss = 12814.152, step = 401 (0.755 sec)
INFO:tensorflow:global_step/sec: 162.194
INFO:tensorflow:loss = 19573.898, step = 501 (0.617 sec)
INFO:tensorflow:global_step/sec: 204.852
INFO:tensorflow:loss = 26381.986, step = 601 (0.488 sec)
INFO:tensorflow:global_step/sec: 188.923
INFO:tensorflow:loss = 23417.719, step = 701 (0.529 sec)
INFO:tensorflow:global_step/sec: 192.041
INFO:tensorflow:loss = 23946.049, step = 801 (0.521 sec)
INFO:tensorflow:global_step/sec: 197.025
INFO:tensorflow:loss = 3309.5786, step = 901 (0.507 sec)
INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train1/model.ckpt.
INFO:tensorflow:Loss for final step: 28861.898.

<tensorflow.python.estimator.canned.linear.LinearClassifier at 0x1820f04c88>
model_1.evaluate(input_fn=get_input_fn(df_test_new, 
                                      num_epochs=1,
                                      n_batch = 128,
                                      shuffle=False),
                                      steps=1000)
INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-06-02-08:28:37
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from ongoing/train1/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [100/1000]
INFO:tensorflow:Finished evaluation at 2018-06-02-08:28:39
INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.7944229, accuracy_baseline = 0.76377374, auc = 0.6093755, auc_precision_recall = 0.54885805, average_loss = 111.0046, global_step = 1000, label/mean = 0.23622628, loss = 14119.265, precision = 0.6682401, prediction/mean = 0.09116262, recall = 0.2576703

{'accuracy': 0.7944229,
 'accuracy_baseline': 0.76377374,
 'auc': 0.6093755,
 'auc_precision_recall': 0.54885805,
 'average_loss': 111.0046,
 'global_step': 1000,
 'label/mean': 0.23622628,
 'loss': 14119.265,
 'precision': 0.6682401,
 'prediction/mean': 0.09116262,
 'recall': 0.2576703}

A négyzetes változó 0.76-ról 0.79-re javította a pontosságot. Lássuk, tud-e jobb eredményt elérni, ha kombinálja a csoportosítást és az interakciós kifejezést.

Vödörbe helyezés és interakció

Ahogy korábban láthatta, a lineáris osztályozó nem képes helyesen rögzíteni az életkor-jövedelem mintázatot. Ennek az az oka, hogy minden funkcióhoz egyetlen súlyt tanul meg. Az osztályozó munkájának megkönnyítése érdekében egy dolog, amit tehetünk, az, hogy gyűjtőhelyre helyezzük a funkciót. A csoportosítás egy numerikus jellemzőt több bizonyos jellemzővé alakít át attól függően, hogy milyen tartományba esik, és ezen új jellemzők mindegyike jelzi, hogy egy személy életkora ebbe a tartományba esik-e.

Ezekkel az új funkciókkal a lineáris modell képes megragadni a kapcsolatot azáltal, hogy minden egyes gyűjtőedényhez különböző súlyokat tanul meg.

A TensorFlow-ban ez a bucketized_column segítségével történik. Hozzá kell adnia az értéktartományt a határokhoz.

age = tf.feature_column.numeric_column('age')
age_buckets = tf.feature_column.bucketized_column(
    age, boundaries=[18, 25, 30, 35, 40, 45, 50, 55, 60, 65])

Már tudja, hogy az életkor nem lineáris a jövedelemmel. A modell fejlesztésének másik módja az interakció. A TensorFlow szavaival élve ez a jellemzők keresztezése. A jellemzők keresztezése olyan új funkciók létrehozásának egyik módja, amelyek a meglévők kombinációiból állnak, ami hasznos lehet olyan lineáris osztályozó esetében, amely nem képes modellezni a funkciók közötti interakciókat.

Lebonthatja az életkort egy másik funkcióval, például az oktatással. Vagyis egyes csoportok valószínűleg magas, mások alacsony jövedelműek (Gondolj a Ph.D. hallgatóra).

education_x_occupation = [tf.feature_column.crossed_column(
    ['education', 'occupation'], hash_bucket_size=1000)]
age_buckets_x_education_x_occupation = [tf.feature_column.crossed_column(
    [age_buckets, 'education', 'occupation'], hash_bucket_size=1000)]

Keresztező oszlop létrehozásához használja a crossed_column paramétert, és a változókat zárójelben kell keresztezni. A hash_bucket_size a maximális keresztezési lehetőségeket jelzi. A változók közötti interakció létrehozásához (legalább egy változónak kategorikusnak kell lennie) használhatja a tf.feature_column.crossed_column fájlt. Az objektum használatához hozzá kell adnia szögletes zárójelben az interakcióhoz szükséges változót és egy második argumentumot, a vödör méretét. A vödör mérete a változóban lehetséges csoportok maximális száma. Itt 1000-re állítod, mivel nem tudod a csoportok pontos számát

Az age_buckets értéket négyzetre kell emelni, hogy hozzáadhassuk a jellemzőoszlopokhoz. Ezenkívül hozzáadhatja az új funkciókat a szolgáltatások oszlopaihoz, és elkészítheti a becslést

base_columns = [
    age_buckets,
]

model_imp = tf.estimator.LinearClassifier(
    model_dir="ongoing/train3", 
    feature_columns=categorical_features+base_columns+education_x_occupation+age_buckets_x_education_x_occupation)

teljesítmény

INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'ongoing/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 0x1823021be0>, '_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}
FEATURES_imp = ['age','workclass', 'education', 'education_num', 'marital',
                'occupation', 'relationship', 'race', 'sex', 'native_country', 'new']

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_imp}),
       y = pd.Series(data_set[LABEL].values),
       batch_size=n_batch,   
       num_epochs=num_epochs,
       shuffle=shuffle)

Készen áll az új modell becslésére, és meglátja, javítja-e a pontosságot.

model_imp.train(input_fn=get_input_fn(df_train_new, 
                                      num_epochs=None,
                                      n_batch = 128,
                                      shuffle=False),
                                      steps=1000)
									  
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 ongoing/train3/model.ckpt.
INFO:tensorflow:loss = 88.722855, step = 1
INFO:tensorflow:global_step/sec: 94.969
INFO:tensorflow:loss = 50.334488, step = 101 (1.054 sec)
INFO:tensorflow:global_step/sec: 242.342
INFO:tensorflow:loss = 56.153225, step = 201 (0.414 sec)
INFO:tensorflow:global_step/sec: 213.686
INFO:tensorflow:loss = 45.792007, step = 301 (0.470 sec)
INFO:tensorflow:global_step/sec: 174.084
INFO:tensorflow:loss = 37.485672, step = 401 (0.572 sec)
INFO:tensorflow:global_step/sec: 191.78
INFO:tensorflow:loss = 56.48449, step = 501 (0.524 sec)
INFO:tensorflow:global_step/sec: 163.436
INFO:tensorflow:loss = 32.528934, step = 601 (0.612 sec)
INFO:tensorflow:global_step/sec: 164.347
INFO:tensorflow:loss = 37.438057, step = 701 (0.607 sec)
INFO:tensorflow:global_step/sec: 154.274
INFO:tensorflow:loss = 61.1075, step = 801 (0.647 sec)
INFO:tensorflow:global_step/sec: 189.14
INFO:tensorflow:loss = 44.69645, step = 901 (0.531 sec)
INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train3/model.ckpt.
INFO:tensorflow:Loss for final step: 44.18133.

<tensorflow.python.estimator.canned.linear.LinearClassifier at 0x1823021cf8>
model_imp.evaluate(input_fn=get_input_fn(df_test_new, 
                                      num_epochs=1,
                                      n_batch = 128,
                                      shuffle=False),
                                      steps=1000)
									  
INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-06-02-08:28:52
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from ongoing/train3/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [100/1000]
INFO:tensorflow:Finished evaluation at 2018-06-02-08:28:54
INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.8358209, accuracy_baseline = 0.76377374, auc = 0.88401634, auc_precision_recall = 0.69599575, average_loss = 0.35122654, global_step = 1000, label/mean = 0.23622628, loss = 44.67437, precision = 0.68986726, prediction/mean = 0.23320661, recall = 0.55408216


{'accuracy': 0.8358209,
 'accuracy_baseline': 0.76377374,
 'auc': 0.88401634,
 'auc_precision_recall': 0.69599575,
 'average_loss': 0.35122654,
 'global_step': 1000,
 'label/mean': 0.23622628,
 'loss': 44.67437,
 'precision': 0.68986726,
 'prediction/mean': 0.23320661,
 'recall': 0.55408216}

Az új pontossági szint 83.58 százalék. Négy százalékkal magasabb az előző modellnél.

Végül hozzáadhat egy szabályosító kifejezést a túlillesztés elkerülése érdekében.

5. lépés) Hiperparaméter: Lasso & Ridge

Az Ön modellje szenvedhet túlfeszített or alulszerelés.

  • Túlillesztés: A modell nem tudja általánosítani az előrejelzést új adatokra
  • Alulillesztés: A modell nem tudja rögzíteni az adatok mintáját. azaz lineáris regresszió, ha az adatok nem lineárisak

Ha egy modell sok paraméterrel és viszonylag kevés adattal rendelkezik, az rossz előrejelzésekhez vezet. Képzeld el, egy csoportnak csak három megfigyelése van; a modell kiszámítja ennek a csoportnak a súlyát. A súlyt jóslat készítésére használják; ha az adott csoportra vonatkozó tesztkészlet megfigyelései teljesen eltérnek a képzési halmazétól, akkor a modell rossz előrejelzést ad. Az edzéskészlettel végzett értékelés során a pontosság jó, de a tesztkészlettel nem jó, mert a kiszámított súlyok nem az igaziak a minta általánosításához. Ebben az esetben nem ad ésszerű előrejelzést nem látott adatok alapján.

A túlillesztés elkerülése érdekében a rendszeresítés lehetőséget ad az ilyen összetettség ellenőrzésére és általánosíthatóságára. Két szabályosítási technika létezik:

  • L1: Lasszó
  • L2: Ridge

A TensorFlow-ban ezt a két hiperparamétert hozzáadhatja az optimalizálóhoz. Például minél magasabb az L2 hiperparaméter, a súly általában nagyon alacsony és nullához közeli. Az illesztett egyenes nagyon lapos lesz, míg a nullához közeli L2 azt jelenti, hogy a súlyok közel vannak a szabályos lineáris regresszióhoz.

Kipróbálhatja egyedül a hiperparaméterek különböző értékét, és megnézheti, hogy növelheti-e a pontossági szintet.

Megjegyzések hogy ha módosítja a hiperparamétert, akkor törölnie kell a folyamatban lévő/train4 mappát, különben a modell a korábban betanított modellel indul.

Lássuk, milyen a pontosság a hírveréssel

model_regu = tf.estimator.LinearClassifier(
    model_dir="ongoing/train4", feature_columns=categorical_features+base_columns+education_x_occupation+age_buckets_x_education_x_occupation,
    optimizer=tf.train.FtrlOptimizer(
        learning_rate=0.1,
        l1_regularization_strength=0.9,
        l2_regularization_strength=5))

teljesítmény

INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'ongoing/train4', '_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 0x1820d9c128>, '_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}
model_regu.train(input_fn=get_input_fn(df_train_new, 
                                      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 ongoing/train4/model.ckpt.
INFO:tensorflow:loss = 88.722855, step = 1
INFO:tensorflow:global_step/sec: 77.4165
INFO:tensorflow:loss = 50.38778, step = 101 (1.294 sec)
INFO:tensorflow:global_step/sec: 187.889
INFO:tensorflow:loss = 55.38014, step = 201 (0.535 sec)
INFO:tensorflow:global_step/sec: 201.895
INFO:tensorflow:loss = 46.806694, step = 301 (0.491 sec)
INFO:tensorflow:global_step/sec: 217.992
INFO:tensorflow:loss = 38.68271, step = 401 (0.460 sec)
INFO:tensorflow:global_step/sec: 193.676
INFO:tensorflow:loss = 56.99398, step = 501 (0.516 sec)
INFO:tensorflow:global_step/sec: 202.195
INFO:tensorflow:loss = 33.263622, step = 601 (0.497 sec)
INFO:tensorflow:global_step/sec: 216.756
INFO:tensorflow:loss = 37.7902, step = 701 (0.459 sec)
INFO:tensorflow:global_step/sec: 240.215
INFO:tensorflow:loss = 61.732605, step = 801 (0.416 sec)
INFO:tensorflow:global_step/sec: 220.336
INFO:tensorflow:loss = 46.938225, step = 901 (0.456 sec)
INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train4/model.ckpt.
INFO:tensorflow:Loss for final step: 43.4942.


<tensorflow.python.estimator.canned.linear.LinearClassifier at 0x181ff39e48>
model_regu.evaluate(input_fn=get_input_fn(df_test_new, 
                                      num_epochs=1,
                                      n_batch = 128,
                                      shuffle=False),
                                      steps=1000)

teljesítmény

INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-06-02-08:29:07
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from ongoing/train4/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [100/1000]
INFO:tensorflow:Finished evaluation at 2018-06-02-08:29:09
INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.83833915, accuracy_baseline = 0.76377374, auc = 0.8869794, auc_precision_recall = 0.7014905, average_loss = 0.34691378, global_step = 1000, label/mean = 0.23622628, loss = 44.12581, precision = 0.69720596, prediction/mean = 0.23662092, recall = 0.5579823





{'accuracy': 0.83833915,
 'accuracy_baseline': 0.76377374,
 'auc': 0.8869794,
 'auc_precision_recall': 0.7014905,
 'average_loss': 0.34691378,
 'global_step': 1000,
 'label/mean': 0.23622628,
 'loss': 44.12581,
 'precision': 0.69720596,
 'prediction/mean': 0.23662092,
 'recall': 0.5579823}

Ezzel a hiperparaméterrel kismértékben növelheted a pontossági metrikák értékét. Az alábbi táblázat összegyűjti az ebben az oktatóanyagban szereplő négy kiértékelési hívás által jelentett összes metrikát.

Modell Funkciókészlet Pontosság AUC Pontosság visszahívás
modell Alapvonal folytonos + kategorikus 0.7615626 0.63300294 0.49401596 0.38637546
modell_1 Alapérték plusz a négyzetes életkor 0.7944229 0.6093755 0.6682401 0.2576703
modell_imp Vödörbe sorolt ​​életkor plusz keresztezett oszlopok 0.8358209 0.88401634 0.68986726 0.55408216
modell_szabály Keresztezett oszlopok, valamint L1 és L2 0.83833915 0.8869794 0.69720596 0.5579823

Megjegyzendő, hogy egy olyan modell alappontossága, amely mindig a többségi osztályt jósolja, 0.76377374, tehát csak az utolsó két modell múlja felül hasznos különbséggel egy triviális becslést.

A következő oktatóanyagban megtanulod, hogyan fejleszthetsz egy lineáris osztályozót egy kernel módszer.

GYIK

A logisztikus regresszió a lineáris osztályozók egyik fajtája. Egy lineáris pontszámot illeszt, majd egy szigmoidon keresztül összenyomja, hogy kalibrált valószínűségeket adjon vissza. Más lineáris osztályozók, mint például a lineáris SVM vagy a perceptron, osztoznak a lineáris határon, de más veszteséget optimalizálnak.

Egy lineáris SVM optimalizálja a zsanérveszteséget, és csak a margópontok befolyásolják a határt, ami kis, zajos adathalmazokon segít. A logisztikus regresszió gyorsabban tanul meg nagyon nagy adatokon, és valószínűségi becsléseket ad vissza, amelyek akkor számítanak, ha hangolható döntési küszöbértékre van szükség.

Nem. A tf-estimator csomag utolsó kiadása a TensorFlow 2.15-ös verziójával együtt jelent meg, és a TensorFlow 2.16-os és újabb verzióiban hiányzik. Futtassa ezt az oktatóanyagot a TensorFlow 1.x verzióján, vagy migrálja a konzerv becslőt egy Keras lineáris modellre a hivatalos migrációs útmutató segítségével.

Az automatizált keresőkönyvtárak az L1-et, L2-t, a tanulási rátát és a vödörhatárokat keresési térként kezelik, majd Bayes-optimalizálást vagy bandit módszereket használnak a gyenge próbák korai kiszűrésére. Ez helyettesíti a bemutatóban javasolt manuális söprést, és általában jobb regularizációs párt talál.

A Copilot gyorsan készít ismétlődő feature_column sablontervezeteket, beleértve a folyamatos oszlopok és a keresztezett oszlopok feletti listaértelmezéseket is. A kimenetet első vázlatként kell kezelni – minden API-nevet ellenőrizni kell a futtatott verzióval szemben, mivel a Copilot ötvözi a TensorFlow 1.x és 2.x idiómáit.

Ez állítja be, hogy egy kategorikus oszlop hány tárolóhelyre legyen besorolva. A túl kicsi érték arra kényszeríti a nem kapcsolódó kategóriákat, hogy ütközzenek és megosszák a súlyozást; a túl nagy érték pedig memóriát pazarol. Állítsa be kényelmesen a különböző értékek száma fölé, ahogy ez az oktatóanyag is teszi 1000-rel.

A négyzetes tag hozzáadása a modellt a többségi osztály magabiztosabb előrejelzése felé tolja el. A pontosság 0.6682-re nő, míg a visszahívási arány 0.2577-re csökken, ami inkább a kiegyensúlyozatlan címkék esetén a szokásos pontosság-visszahívási kompromisszum, mintsem kódolási hiba.

Használjon kernelt, ha a vödrözés és a jellemzők keresztezése után sem választja el az osztályokat lineáris határ. A kernelek implicit módon képezik le az adatokat egy magasabb dimenziós térbe, de lassabb betanítást és gyengébb értelmezhetőséget eredményeznek, mint az itt látható lineáris súlyok.

Foglald össze ezt a bejegyzést a következőképpen: