TensorFlow Binary Classification: Esimerkki lineaarisesta luokittimesta

Kaksi yleisintä valvottu oppiminen Tehtävät ovat lineaarinen regressio ja lineaarinen luokitin. Lineaarinen regressio ennustaa arvon, kun taas lineaarinen luokitin ennustaa luokan. Tämä opetusohjelma keskittyy lineaarisiin luokittelijoihin.

Mikä on lineaarinen luokitin?

A Lineaarinen luokitin koneoppimisessa on menetelmä löytää objektin luokka sen ominaisuuksien perusteella tilastollista luokittelua varten. Se tekee luokituspäätöksen objektin ominaisuuksien lineaarisen yhdistelmän arvon perusteella. Lineaarista luokittelijaa käytetään käytännön ongelmissa, kuten dokumenttien luokittelussa ja monimuuttujaongelmissa.

Luokitteluongelmat edustavat noin 80 prosenttia koneoppimistehtävästä. Luokittelun tarkoituksena on ennustaa kunkin luokan todennäköisyys tietyllä syötteellä. Tunniste (eli riippuva muuttuja) on diskreetti arvo, jota kutsutaan luokaksi.

1. Jos tunnisteessa on vain kaksi luokkaa, oppimisalgoritmi on binaarinen luokitin.
2. Moniluokkainen luokitin käsittelee tarroja, joissa on enemmän kuin kaksi luokkaa.

Esimerkiksi tyypillinen binääriluokitteluongelma on ennustaa todennäköisyyttä, että asiakas tekee toisen ostoksen. Kuvassa näkyvän eläimen tyypin ennustaminen on moniluokkainen luokitteluongelma, koska eläimiä on olemassa enemmän kuin kaksi lajiketta.

Tämän opetusohjelman teoreettisessa osassa keskitytään ensisijaisesti binääriluokkaan. Opit lisää multiclass-tulostustoiminnosta tulevassa opetusohjelmassa.

Kuinka binäärinen luokitin toimii?

Opit edellisessä opetusohjelmassa, että funktio koostuu kahdentyyppisistä muuttujista, riippuvaisesta muuttujasta ja joukosta ominaisuuksia (riippumattomia muuttujia). Lineaarisessa regressiossa riippuva muuttuja on reaaliluku ilman vaihteluväliä. Ensisijainen tavoite on ennustaa sen arvo minimoimalla keskineliövirhe.

TensorFlow Binary Classifier -luokittajassa etiketillä voi olla kaksi mahdollista kokonaislukuarvoa. Useimmissa tapauksissa se on joko [0,1] tai [1,2]. Tavoitteena on esimerkiksi ennustaa, ostaako asiakas tuotteen vai ei. Etiketti määritellään seuraavasti:

• K = 1 (asiakas osti tuotteen)
• K = 0 (asiakas ei osta tuotetta)

Malli käyttää ominaisuuksia X luokittelemaan jokaisen asiakkaan todennäköisimpään luokkaan, johon hän kuuluu, eli potentiaaliseen ostajaan vai ei.

Onnistumisen todennäköisyys lasketaan logistinen regressio. Algoritmi laskee todennäköisyyden ominaisuuden X perusteella ja ennustaa onnistumisen, kun tämä todennäköisyys on yli 50 prosenttia. Muodollisemmin todennäköisyys lasketaan alla olevan TensorFlow-binaariluokituksen esimerkin mukaisesti:

jossa 0 on joukko painotuksia, ominaisuuksia ja b bias.

Funktio voidaan jakaa kahteen osaan:

• Lineaarinen malli
• Logistiikkatoiminto

Lineaarinen malli

Olet jo perehtynyt tapaan, jolla painot lasketaan. Painot lasketaan pistetulolla: Y on lineaarinen funktio kaikista piirteistä x_i. Jos mallissa ei ole ominaisuuksia, ennuste on yhtä suuri kuin bias, b.

Painot osoittavat ominaisuuksien x välisen korrelaation suunnan_i ja etiketti y. Positiivinen korrelaatio lisää positiivisen luokan todennäköisyyttä, kun taas negatiivinen korrelaatio vie todennäköisyyden lähemmäksi arvoa 0 (eli negatiivinen luokka).

Lineaarinen malli palauttaa vain reaaliluvun, joka on ristiriidassa alueen [0,1] todennäköisyysmitan kanssa. Logistista toimintoa tarvitaan muuntamaan lineaarisen mallin tulos todennäköisyydeksi,

Logistinen toiminto

Logistisella funktiolla eli sigmoidifunktiolla on S-muotoinen muoto ja tämän funktion tulos on aina välillä 0 ja 1.

Lineaarisen regression tulos on helppo korvata sigmoidifunktiolla. Tuloksena on uusi luku todennäköisyydellä 0 ja 1.

Luokitin voi muuttaa todennäköisyyden luokaksi

• Arvoista 0–0.49 tulee luokka 0
• Arvoista 0.5–1 tulee luokka 1

Kuinka mitata lineaarisen luokittelulaitteen suorituskykyä?

tarkkuus

Luokittimen kokonaissuorituskykyä mitataan tarkkuusmittarilla. Tarkkuus kerää kaikki oikeat arvot jaettuna havaintojen kokonaismäärällä. Esimerkiksi 80 prosentin tarkkuusarvo tarkoittaa, että malli on oikea 80 prosentissa tapauksista.

Voit huomata tämän mittarin puutteen, erityisesti epätasapainoluokissa. Epätasapainotietojoukko syntyy, kun havaintojen määrä ryhmää kohti ei ole sama. Sanotaanpa; yrität luokitella harvinaista tapahtumaa logistisella funktiolla. Kuvittele, että luokitin yrittää arvioida potilaan kuoleman sairauden seurauksena. Tietojen mukaan 5 prosenttia potilaista kuolee. Voit kouluttaa luokittelijan ennustamaan kuolleiden lukumäärää ja käyttää tarkkuusmittaria suoritusten arvioimiseen. Jos luokitin ennustaa 0 kuolemaa koko tietojoukolle, se pitää paikkansa 95 prosentissa tapauksista.

Hämmennysmatriisi

Parempi tapa arvioida luokittelijan suorituskykyä on tarkastella sekaannusmatriisia.

- sekaannusmatriisi visualisoi luokittelijan tarkkuuden vertaamalla todellista ja ennustettua luokkia, kuten yllä olevassa Lineaarinen luokittelija -esimerkissä on esitetty. Binäärisekoitusmatriisi koostuu neliöistä:

• TP: True Positive: Ennustetut arvot on ennustettu oikein todellisina positiivisina
• FP: Ennustetut arvot ennustivat väärin todellisen positiivisen. eli negatiiviset arvot ennustetaan positiivisiksi
• FN: Väärä negatiivinen: Positiiviset arvot ennustetaan negatiivisiksi
• TN: True Negative: Ennustetut arvot on ennustettu oikein todellisiksi negatiivisiksi

Sekaannusmatriisista on helppo verrata todellista luokkaa ja ennustettua luokkaa.

Tarkkuus ja herkkyys

Sekaannusmatriisi tarjoaa hyvän käsityksen todellisista positiivisista ja vääristä positiivisista. Joissakin tapauksissa on parempi käyttää tiiviimpää mittaria.

Tarkkuus

Tarkkuusmetriikka näyttää positiivisen luokan tarkkuuden. Se mittaa, kuinka todennäköisesti positiivisen luokan ennuste on oikea.

Maksimipistemäärä on 1, kun luokitin luokittelee täydellisesti kaikki positiiviset arvot. Pelkästään tarkkuus ei ole kovin hyödyllinen, koska se jättää huomioimatta negatiivisen luokan. Mittari yhdistetään yleensä pariksi Recall-mittarin kanssa. Palautusta kutsutaan myös herkkyydeksi tai todelliseksi positiiviseksi koroksi.

Herkkyys

Herkkyys laskee oikein havaittujen positiivisten luokkien suhteen. Tämä mittari kertoo, kuinka hyvä malli tunnistaa positiivisen luokan.

Lineaarinen luokitin TensorFlow'lla

Tässä opetusohjelmassa käytämme väestönlaskentatietoa. Tarkoitus on käyttää väestönlaskentaaineiston muuttujia tulotason ennustamiseen. Huomaa, että tulot ovat binäärimuuttujia

• arvolla 1, jos tulot > 50k
• 0 jos tulot < 50k.

Tämä muuttuja on tunniste

Tämä tietojoukko sisältää kahdeksan kategorista muuttujaa:

• työpaikka
• koulutus
• avio-
• ammatti
• yhteys
• rotu
• sukupuoli
• Kotimaa

lisäksi kuusi jatkuvaa muuttujaa:

• ikä
• fnlwgt
• koulutus_nm
• myyntivoitto
• pääoma_tappio
• tuntia_viikko

Tämän TensorFlow-luokitteluesimerkin avulla ymmärrät, kuinka opettaa lineaarisia TensorFlow-luokittajia TensorFlow-estimaattorilla ja kuinka parantaa tarkkuusmetriikkaa.

Jatketaan seuraavasti:

• Vaihe 1) Tuo tiedot
• Vaihe 2) Tietojen muuntaminen
• Vaihe 3) Kouluta luokittelija
• Vaihe 4) Paranna mallia
• Vaihe 5) Hyperparametri: Lasso & Ridge

Vaihe 1) Tuo tiedot

Tuo ensin opetusohjelman aikana käytetyt kirjastot.

import tensorflow as tf
import pandas as pd

Seuraavaksi tuot tiedot UCI:n arkistosta ja määrität sarakkeiden nimet. Käytät sarakkeita nimeämään sarakkeet pandastietokehyksessä.

Huomaa, että koulutat luokittelijan käyttämällä Pandas-tietokehystä.

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

Verkkoon tallennetut tiedot on jo jaettu junasarjan ja testijoukon kesken.

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)

Junasarja sisältää 32,561 16,281 havaintoa ja testisarja XNUMX XNUMX

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

Tensorflow vaatii Boolen arvon luokittelijan kouluttamiseen. Arvot on välitettävä merkkijonosta kokonaisluvuksi. Tarra tallennetaan objektina, mutta sinun on muutettava se numeeriseksi arvoksi. Alla oleva koodi luo sanakirjan, joka sisältää muunnettavat arvot ja silmukan sarakekohteen yli. Huomaa, että suoritat tämän toiminnon kahdesti, yhden junatestille ja toisen testisarjalle

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]

Junatiedoissa on 24,720 50 alle 7841 XNUMX tuloa ja XNUMX XNUMX yli. Suhde on lähes sama testisarjassa. Katso tästä Facets-opetusohjelmasta lisää.

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

Vaihe 2) Tietojen muuntaminen

Muutama vaihe vaaditaan ennen kuin harjoitat lineaarista luokittelijaa Tensorflow:lla. Sinun on valmisteltava malliin sisällytettävät ominaisuudet. Vertailuregressiossa käytät alkuperäisiä tietoja ilman muunnoksia.

Estimaattorilla on oltava luettelo ominaisuuksista mallin kouluttamiseksi. Siksi sarakkeen tiedot on muutettava tensoriksi.

Hyvä käytäntö on määrittää kaksi ominaisuusluetteloa niiden tyypin perusteella ja välittää ne sitten estimaattorin feature_columns -kohdassa.

Aloitat muuntamalla jatkuvia ominaisuuksia ja määrität sitten ryhmän kategorisilla tiedoilla.

Tietojoukon ominaisuuksilla on kaksi muotoa:

• Kokonaisluku
• objekti

Jokainen ominaisuus on lueteltu kahdessa seuraavassa muuttujassa niiden tyyppien mukaan.

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

Feature_column on varustettu objektilla numeric_column, joka auttaa jatkuvien muuttujien muuntamisessa tensoriksi. Alla olevassa koodissa muutat kaikki muuttujat CONTI_FEATURES tensoriksi, jolla on numeerinen arvo. Tämä on pakollista mallin rakentamiseksi. Kaikki riippumattomat muuttujat on muutettava oikeantyyppisiksi tensoreiksi.

Alla kirjoitamme koodin, jonka avulla näet, mitä feature_column.numeric_column-kohdan takana tapahtuu. Tulostamme iän muunnetun arvon. Se on selittävä, joten python-koodia ei tarvitse ymmärtää. Voit katsoa koodit virallisesta dokumentaatiosta.

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

Arvot ovat täsmälleen samat kuin df_trainissa

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

TensorFlow-dokumentaation mukaan kategorisia tietoja voidaan muuntaa eri tavoin. Jos ominaisuuden sanasto on tiedossa eikä siinä ole paljon arvoja, on mahdollista luoda kategoriallinen sarake kategorisella_sarake_sanaluettelolla. Se määrittää kaikille ainutlaatuisille sanastoluetteloille tunnuksen.

Jos esimerkiksi muuttujan tilalla on kolme eri arvoa:

• aviomies
• Vaimo
• Yksi

Sitten annetaan kolme tunnusta. Esimerkiksi miehellä on tunnus 1, vaimolla tunnus 2 ja niin edelleen.

Havainnollistamistarkoituksessa voit käyttää tätä koodia muuntaaksesi objektimuuttujan kategoriseksi sarakkeeksi TensorFlowissa.

Ominaisuussukupuolella voi olla vain kaksi arvoa: mies tai nainen. Kun muunnamme ominaisuuden sukupuolen, Tensorflow luo 2 uutta saraketta, yhden miehille ja toisen naisille. Jos sukupuoli on yhtä suuri kuin mies, uuden sarakkeen mies on 1 ja nainen 0. Tämä esimerkki näkyy alla olevassa taulukossa:

riviä	sukupuoli	muutoksen jälkeen	uros-	naaras-
1	uros-	=>	1	0
2	uros-	=>	1	0
3	naaras-	=>	0	1

Tensorflow-tilassa:

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

Lisäsimme alle Python koodi koodauksen tulostamiseksi. Jälleen, sinun ei tarvitse ymmärtää koodia, tarkoituksena on nähdä muunnos

Nopeampi tapa muuttaa tiedot on kuitenkin käyttää menetelmää categorical_column_with_hash_bucket. Merkkijonomuuttujien muuttaminen harvassa matriisissa on hyödyllistä. Harva matriisi on matriisi, jossa on enimmäkseen nolla. Menetelmä hoitaa kaiken. Sinun tarvitsee vain määrittää ämpärien määrä ja avainsarake. Säilöiden määrä on suurin sallittu määrä ryhmiä, jotka Tensorflow voi luoda. Avainsarake on yksinkertaisesti muunnettavan sarakkeen nimi.

Alla olevassa koodissa luot silmukan kaikille kategorisille ominaisuuksille.

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

Vaihe 3) Kouluta luokittelija

TensorFlow tarjoaa tällä hetkellä estimaattorin lineaarista regressiota ja lineaarista luokittelua varten.

• Lineaarinen regressio: Lineaarinen regressio
• Lineaarinen luokitus: LinearClassifier

Lineaarisen luokittelijan syntaksi on sama kuin opetusohjelmassa lineaarinen regressio paitsi yksi argumentti, n_class. Sinun on määritettävä ominaisuussarake, mallihakemisto ja verrattava lineaariseen regressoriin; sinun on määritettävä luokan lukumäärä. Logit-regressiolle luokan lukumäärä on yhtä suuri kuin 2.

Malli laskee jatkuvat_ominaisuudet ja kategorialliset_ominaisuudet sisältämien sarakkeiden painot.

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

ulostulo

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}

Nyt kun luokitin on määritetty, voit luoda syöttöfunktion. Menetelmä on sama kuin lineaarisen regressorin opetusohjelmassa. Tässä käytät eräkokoa 128 ja sekoitat tiedot.

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)

Luot funktion lineaarisen estimaattorin vaatimilla argumenteilla, eli aikakausien lukumäärällä, erien lukumäärällä ja sekoitat tietojoukon tai muistiinpanon. Koska käytät Panda Menetelmä siirtääksesi tiedot malliin, sinun on määritettävä X-muuttujat panda-tietokehykseksi. Huomaa, että käyt läpi kaikki OMINAISUUDET-kansioon tallennetut tiedot.

Harjoitetaan mallia objektilla model.train. Käytät aiemmin määritettyä funktiota syöttämään malliin sopivat arvot. Huomaa, että asetat erän kooksi 128 ja aikakausien lukumääräksi Ei mitään. Mallia koulutetaan yli tuhat askelta.

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>

Huomaa, että tappio pieneni myöhemmin viimeisen 100 vaiheen aikana, eli 901:stä 1000:een.

Lopullinen häviö tuhannen iteroinnin jälkeen on 5444. Voit arvioida mallisi testisarjasta ja nähdä suorituskyvyn. Mallin suorituskyvyn arvioimiseksi sinun on käytettävä objektin arviointia. Syötät malliin testisarjan ja asetat epookkien lukumääräksi 1, eli data menee malliin vain kerran.

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}

TensorFlow palauttaa kaikki mittarit, jotka opit teoreettisessa osassa. Ilman yllätystä tarkkuus on suuri epätasapainoisen etiketin vuoksi. Itse asiassa malli toimii hieman paremmin kuin satunnainen arvaus. Kuvittele, että malli ennustaa kaikki kotitaloudet, joiden tulot ovat alle 50 70, niin mallin tarkkuus on XNUMX prosenttia. Tarkemmalla analyysillä voit nähdä, että ennuste ja muistaminen ovat melko alhaiset.

Vaihe 4) Paranna mallia

Nyt kun sinulla on vertailumalli, voit yrittää parantaa sitä, eli lisätä tarkkuutta. Edellisessä opetusohjelmassa opit parantamaan ennustetehoa vuorovaikutustermillä. Tässä opetusohjelmassa palaat tähän ajatukseen lisäämällä polynomitermin regressioon.

Polynomiregressio on hyödyllinen, kun tiedoissa on epälineaarisuutta. On kaksi tapaa siepata datan epälineaarisuus.

• Lisää polynomitermi
• Luokittele jatkuva muuttuja kategoriseksi muuttujaksi

Polynomitermi

Alla olevasta kuvasta näet, mikä polynomiregressio on. Se on yhtälö, jossa on eri tehoisia X-muuttujia. Toisen asteen polynomiregressiossa on kaksi muuttujaa, X ja X neliöity. Kolmannessa asteessa on kolme muuttujaa, X, X², ja X³

Alla rakensimme kaavion kahdella muuttujalla, X ja Y. On selvää, että suhde ei ole lineaarinen. Jos lisäämme lineaarisen regression, voimme nähdä, että malli ei pysty kaappaamaan kuviota (vasen kuva).

Katso nyt vasenta kuvaa alla olevasta kuvasta, lisäsimme regressioon viisi termiä (eli y=x+x²+x³+x⁴+x⁵. Malli vangitsee nyt paljon paremmin kuvion. Tämä on polynomiregression voima.

Palataanpa esimerkkiimme. Ikä ei ole lineaarisessa suhteessa tuloihin. Varhaisella iällä saattaa olla tasaiset tulot lähellä nollaa, koska lapset tai nuoret eivät käy töissä. Sitten se nousee työiässä ja laskee eläkkeelle siirtyessä. Se on tyypillisesti käänteinen U-muoto. Yksi tapa kaapata tämä kuvio on lisätä potenssi kaksi regressioon.

Katsotaan lisääkö se tarkkuutta.

Sinun on lisättävä tämä uusi ominaisuus tietojoukkoon ja jatkuvan ominaisuuden luetteloon.

Lisäät uuden muuttujan juna- ja testaustietojoukkoon, joten funktion kirjoittaminen on helpompaa.

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

Funktiolla on 3 argumenttia:

• df_t: määritä harjoitussarja
• df_te: määritä testijoukko
• var_name = 'age': Määritä muunnettava muuttuja

Voit käyttää objektia pow(2) neliöimään muuttujan iän. Huomaa, että uuden muuttujan nimi on "new"

Nyt kun funktio square_var on kirjoitettu, voit luoda uudet tietojoukot.

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

Kuten näet, uudessa tietojoukossa on vielä yksi ominaisuus.

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

Neliömäistä muuttujaa kutsutaan tietojoukossa uudeksi. Sinun on lisättävä se jatkuvien ominaisuuksien luetteloon.

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]

Huomautuksia että muutit Graphin hakemistoa. Et voi kouluttaa eri malleja samassa hakemistossa. Se tarkoittaa, että sinun on vaihdettava argumentin model_dir polku. Jos et, TensorFlow antaa virheilmoituksen.

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)

Nyt kun luokitin on suunniteltu uuden tietojoukon kanssa, voit harjoitella ja arvioida mallia.

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}

Neliömuuttuja paransi tarkkuutta 0.76:sta 0.79:ään. Katsotaan, voitko tehdä paremmin yhdistämällä ryhmittelyn ja vuorovaikutustermit yhteen.

Bucketization ja vuorovaikutus

Kuten aiemmin näit, lineaarinen luokitin ei pysty kuvaamaan ikä-tulokuviota oikein. Tämä johtuu siitä, että se oppii yhden painon jokaiselle ominaisuudelle. Luokittelijan toiminnan helpottamiseksi voit tehdä ominaisuuden ämpäriin. Säilöntä muuntaa numeerisen ominaisuuden useiksi tietyiksi sen alueen perusteella, jolle se kuuluu, ja jokainen näistä uusista ominaisuuksista osoittaa, kuuluuko henkilön ikä tälle alueelle.

Näiden uusien ominaisuuksien avulla lineaarinen malli voi vangita suhteen oppimalla eri painot jokaiselle ämpärille.

TensorFlowissa se tehdään bucketized_columnilla. Sinun on lisättävä arvoalue rajoihin.

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

Tiedät jo, että ikä ei ole lineaarinen tulojen kanssa. Toinen tapa parantaa mallia on vuorovaikutus. TensorFlow'n sanalla se on ominaisuuden rajaamista. Ominaisuuksien ristiin on tapa luoda uusia ominaisuuksia, jotka ovat yhdistelmiä olemassa olevista, mikä voi olla hyödyllistä lineaariselle luokittelijalle, joka ei pysty mallintamaan ominaisuuksien välistä vuorovaikutusta.

Voit laskea ikää toisella ominaisuudella, kuten koulutuksella. Toisin sanoen joillakin ryhmillä on todennäköisesti korkeat tulot ja toisilla alhaiset (ajattele tohtoriopiskelijaa).

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

Jos haluat luoda ristikkäispiirresarakkeen, käytä crossed_column-muuttujia, joiden muuttujat ovat rajattavissa suluissa. Hash_bucket_size osoittaa suurimmat ylitysmahdollisuudet. Voit luoda muuttujien välisen vuorovaikutuksen (ainakin yhden muuttujan on oltava kategorinen) käyttämällä tf.feature_column.crossed_column. Jotta voit käyttää tätä objektia, sinun on lisättävä hakasulkeisiin muuttuja vuorovaikutuksessa ja toinen argumentti, segmentin koko. Astian koko on suurin mahdollinen ryhmien lukumäärä muuttujan sisällä. Tässä asetat sen arvoksi 1000, koska et tiedä tarkkaa ryhmien määrää

age_buckets on neliöitävä ennen sen lisäämistä ominaisuussarakkeisiin. Voit myös lisätä uudet ominaisuudet ominaisuussarakkeisiin ja valmistella estimaattorin

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)

ulostulo

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)

Olet valmis arvioimaan uutta mallia ja katsomaan, parantaako se tarkkuutta.

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}

Uusi tarkkuustaso on 83.58 prosenttia. Se on neljä prosenttia edellistä mallia korkeampi.

Lopuksi voit lisätä säännöstelytermin liiallisen sovituksen estämiseksi.

Vaihe 5) Hyperparametri: Lasso & Ridge

Mallisi voi kärsiä liikaa or alasovitus.

• Ylisovitus: Malli ei pysty yleistämään ennustetta uusille tiedoille
• Alasovitus: Malli ei pysty kaappaamaan tietojen mallia. eli lineaarinen regressio, kun data on epälineaarinen

Kun mallissa on paljon parametreja ja suhteellisen vähän dataa, se johtaa huonoihin ennusteisiin. Kuvittele, että yhdellä ryhmällä on vain kolme havaintoa; malli laskee painon tälle ryhmälle. Painoa käytetään ennustamiseen; jos tämän tietyn ryhmän testijoukon havainnot poikkeavat täysin harjoitusjoukosta, malli tekee väärän ennusteen. Harjoittelusarjan arvioinnin aikana tarkkuus on hyvä, mutta ei hyvä testisarjalla, koska lasketut painot eivät ole oikeat kuvion yleistämiseksi. Tässä tapauksessa se ei tee järkevää ennustetta näkymättömille tiedoille.

Liiallisen sovituksen estämiseksi regularisointi antaa sinulle mahdollisuuden hallita tällaista monimutkaisuutta ja tehdä siitä yleistettävämpi. On olemassa kaksi säännöstelytekniikkaa:

• L1: Lasso
• L2: Ridge

TensorFlow'ssa voit lisätä nämä kaksi hyperparametria optimoijaan. Esimerkiksi mitä korkeampi hyperparametri L2, paino on yleensä hyvin alhainen ja lähellä nollaa. Sovitettu viiva on hyvin tasainen, kun taas L2 lähellä nollaa tarkoittaa, että painot ovat lähellä säännöllistä lineaarista regressiota.

Voit kokeilla itse hyperparametrien eri arvoja ja katsoa, ​​voitko lisätä tarkkuustasoa.

Huomautuksia että jos muutat hyperparametria, sinun on poistettava kansio käynnissä/train4, muuten malli alkaa aiemmin opetetusta mallista.

Katsotaanpa kuinka tarkkuus hypeillä on

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

ULOS

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)

ULOS

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)

ulostulo

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}

Tällä hyperparametrilla lisäät hieman tarkkuusmittareita. Seuraavassa opetusohjelmassa opit parantamaan lineaarista luokittelijaa ydinmenetelmällä.

Yhteenveto

Mallin kouluttamiseksi sinun on:

• Määrittele ominaisuudet: Riippumattomat muuttujat: X
• Määrittele tunniste: Riippuva muuttuja: y
• Rakenna juna/koesarja
• Määritä alkuperäinen paino
• Määritä häviöfunktio: MSE
• Optimoi malli: Gradienttilasku
• Määritellä:
  • Oppimisnopeus
  • Epookin lukumäärä
  • Erän koko
  • Luokan lukumäärä

Tässä opetusohjelmassa opit käyttämään korkean tason API:ta lineaarisen regression luokittelijana. Sinun on määritettävä:

1. Ominaisuussarakkeet. Jos jatkuva: tf.feature_column.numeric_column(). Voit täyttää luettelon python-luetteloiden ymmärtämisellä
2. Estimaattori: tf.estimator.LinearClassifier(feature_columns, model_dir, n_classes = 2)
3. Funktio, jolla tuodaan tiedot, erän koko ja aikakausi: input_fn()

Sen jälkeen olet valmis harjoittelemaan, arvioimaan ja tekemään ennusteen train(), arvioi() ja ennusta()

Voit parantaa mallin suorituskykyä seuraavasti:

• Käytä polynomiregressiota
• Vuorovaikutustermi: tf.feature_column.crossed_column
• Lisää regularisointiparametri