TensorFlow Binary Classification: Esimerkki lineaarisesta luokittimesta

⚡ Älykäs yhteenveto

Lineaariset luokittelijat määrittävät jokaisen havainnon luokkaan sen ominaisuuksien painotetun summan perusteella. Tämä läpikäynti rakentaa TensorFlow-binääriluokittimen väestönlaskenta-aineistolle ja nostaa tarkkuuden 0.76:sta 0.84:ään.

  • 🔘 Ydinmääritelmä: Lineaarinen luokittelija ennustaa diskreetin luokan ominaisuusarvojen lineaarisesta yhdistelmästä.
  • ☑️ Todennäköisyysaskel: Logistinen funktio muuntaa lineaarisen mallin tuotoksen todennäköisyydeksi välillä 0 ja 1.
  • ✅ Mittareilla on väliä: Pelkkä tarkkuus johtaa harhaan epätasapainoisissa etiketeissä, joten yhdistä se sekaannusmatriisiin, tarkkuuteen ja muistamiseen.
  • 🧪 Väestönlaskennan läpikäynti: Kuusi jatkuvaa ja kahdeksan kategorista saraketta muuttuvat tensoreiksi ennen kuin estimaattori edes näkee niitä.
  • 🛠️ Ominaisuussuunnittelu: Iän neliöiminen, sen luokittelu kategoriaan ja sitten koulutuksen ja ammatin yhdistäminen nostaa tarkkuuden 0.7616:sta 0.8358:aan.
  • 📈 Laillistaminen: Ftrl-optimoija, jonka L1 on 0.9 ja L2 5, pienentää lopullisen tarkkuuden arvoon 0.8383.

TensorFlow-binääriluokittelu Lineaarinen luokitin

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.

Kun määritelmä on vakiintunut, seuraava vaihe on nähdä, miten algoritmi muuttaa raakaominaisuudet luokkapäätökseksi.

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.

varten TensorFlow Binääriluokittelija, otsikolla voi olla kaksi mahdollista kokonaislukuarvoa. Useimmissa tapauksissa se on joko [0,1] tai [1,2]. Esimerkiksi tavoitteena on ennustaa, ostaako asiakas tuotteen vai ei. Otsikko 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:

TensorFlow-binääriluokittelijan käyttämä sigmoidinen todennäköisyyskaava

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:Painovektorin ja ominaisuusvektorin pistetulo Y on lineaarinen funktio kaikista piirteistä xi. Jos mallissa ei ole ominaisuuksia, ennuste on yhtä suuri kuin bias, b.

Painot osoittavat ominaisuuksien x välisen korrelaation suunnani 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.

Alla oleva kaava esittää muunnoksen, ja seuraava kuvaaja näyttää tuloksena olevan käyrän litistyvän kohti nollaa vasemmalla ja kohti ykköstä oikealla.

Logistisen funktion kaava, joka kuvaa lineaarisen pistemäärän todennäköisyyteen

S-muotoinen sigmoidikäyrä, joka on rajoitettu 0:n ja 1:n välille
Esimerkki logistiikkatoiminnosta

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

Kun malli tuottaa luokkia, tarvitset tavan arvioida, ovatko nämä luokat hyviä.

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.

Tarkkuuskaava laskee oikeat ennusteet kokonaishavaintojen perusteella

Mittaa Lineaarisen luokittelulaitteen suorituskykyä tarkkuusmittarin avulla

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.

Binäärinen sekaannusmatriisi, joka näyttää TP-, FP-, FN- ja TN-neliöt

Mittaa Lineaarisen luokittelulaitteen suorituskykyä Confusion-matriisin avulla

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.

Tarkkuuskaava, oikeat positiiviset tulokset ennustettujen positiivisten tulosten sijaan

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.

Herkkyyskaava, todelliset positiiviset verrattuna todellisiin positiivisiin

Teoria on nyt paikallaan, joten tämän läpikäynnin loppuosa soveltaa sitä koodissa alusta loppuun.

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.

Versiohuomautus: Alla oleva koodi käyttää TensorFlow 1.x Estimator API:a. tf-estimator paketti toimitettiin lopullisessa versiossaan TensorFlow 2.15:n mukana, eikä se ole saatavilla TensorFlow 2.16:ssa tai uudemmissa versioissa, joten suorita nämä koodinpätkät TensorFlow 1.x:ssä tai siirrä ne virallisella opas kiinteän estimaattorin siirtoonKäsitteet, ominaisuussuunnittelu ja mittarit pysyvät samoina.

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 luokittelijan kouluttamiseen totuusarvon. Sinun on muunnettava arvot merkkijonosta kokonaisluvuksi. Otsikko tallennetaan objektina, mutta sinun on muunnettava se numeeriseksi arvoksi. Alla oleva koodi luo sanakirjan muunnettavista arvoista ja käy läpi sarakekohdan. Huomaa, että suoritat tämän toiminnon kahdesti, kerran junatestiä ja kerran testijoukkoa varten.

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]

Junadatassa on 24 720 tulotasoa, jotka ovat alle 50 000, ja 7841 tulotasoa, jotka ovat yli 50 000. Suhde on lähes sama testijoukolle, joten noin 76 prosenttia molemmista jaoista on negatiivisessa luokkassa.

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

Ennen kuin voit kouluttaa lineaarista luokittelijaa TensorFlow'lla, sinun on tehtävä muutama vaihe. Sinun on valmisteltava malliin sisällytettävät ominaisuudet. Vertailuregressiossa käytät alkuperäistä dataa ilman muunnoksia, täsmälleen kuten scikit opittava putkisto alkaisi raakasarakkeista.

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_columnin takana tapahtuu. Tulostamme iän muunnetun arvon. Se on havainnollistamistarkoituksessa, joten sinun ei tarvitse ymmärtää Python koodi. Voit tutustua virallisiin dokumentaatioihin ymmärtääksesi koodit.

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.

Sukupuoliominaisuudella voi olla vain kaksi arvoa: mies tai nainen. Kun muunnamme sukupuolen, TensorFlow luo kaksi uutta saraketta, yhden miehelle ja toisen naiselle. Jos sukupuoli on yhtä kuin mies, uusi mies-sarake on yhtä kuin 1 ja nainen-sarake on 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 muuntaa dataa on kuitenkin käyttää categorical_column_with_hash_bucket-metodia. Harvan matriisin merkkijonomuuttujien muuttaminen on hyödyllistä. Harva matriisi on matriisi, jossa on enimmäkseen nolla. Metodi hoitaa kaiken. Sinun tarvitsee vain määrittää säiliöiden lukumäärä ja avainsarake. Säiliöiden lukumäärä on TensorFlow'n luomien ryhmien enimmäismäärä. 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, X2, ja X3

Toisen ja kolmannen asteen polynomiregressioyhtälöt

Mikä on polynomiregressio

Yllä oleva kaavio piirtää toisen asteen käyrän pohjana olevaa yhtälöä vasten. Alla konstruoimme kuvaajan kahdella muuttujalla, X:llä ja Y:llä. On selvää, että suhde ei ole lineaarinen. Jos lisäämme lineaarisen regression, voimme nähdä, että malli ei pysty kuvaamaan kuviota (vasen kuva).

Katso nyt vasenta kuvaa alla olevasta kuvasta, lisäsimme regressioon viisi termiä (eli y=x+x2+x3+x4+x5. Malli vangitsee nyt paljon paremmin kuvion. Tämä on polynomiregression voima.

Lineaarinen sovitus vs. viiden termin polynomi sovitus samalla sirontadiagrammilla

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

ulostulo

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)

ulostulo

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ämän hyperparametrin avulla parannat hieman tarkkuusmittareita. Alla oleva taulukko kerää kaikki tässä opetusohjelmassa neljän evaluate-kutsutoiminnon raportoimat mittarit.

Malli Ominaisuussarja tarkkuus AUC Tarkkuus Palauttaa mieleen
malli Lähtötilanteen jatkuva + kategorinen 0.7615626 0.63300294 0.49401596 0.38637546
malli_1 Lähtötilanteen ja iän neliöinti 0.7944229 0.6093755 0.6682401 0.2576703
malli_imp Kauhallinen ikä plus ristikkäiset sarakkeet 0.8358209 0.88401634 0.68986726 0.55408216
malli_säännös Ristikkäiset sarakkeet sekä L1 ja L2 0.83833915 0.8869794 0.69720596 0.5579823

Huomaa, että mallin, joka aina ennustaa enemmistöluokan, lähtötason tarkkuus on 0.76377374, joten vain kaksi viimeistä mallia ylittävät triviaalin arvion hyödyllisellä marginaalilla.

Seuraavassa opetusohjelmassa opit parantamaan lineaarista luokittelijaa käyttämällä ydinmenetelmä.

UKK

Logistinen regressio on eräänlainen lineaarinen luokittelija. Se sovittaa lineaarisen pistemäärän ja sitten puristaa sen sigmoidin läpi palauttaakseen kalibroidut todennäköisyydet. Muut lineaariset luokittelijat, kuten lineaarinen SVM tai perceptron, jakavat lineaarisen rajan, mutta optimoivat eri häviön.

Lineaarinen SVM optimoi saranahäviön ja vain marginaalipisteet vaikuttavat reunaan, mikä auttaa pienissä ja kohinaisissa datajoukoissa. Logistinen regressio harjoittelee nopeammin erittäin suurissa datajoukoissa ja palauttaa todennäköisyysarvioita, joilla on merkitystä, kun tarvitaan säädettävää päätöskynnystä.

Ei. tf-estimaattoripaketti julkaistiin viimeksi TensorFlow 2.15:n mukana, eikä sitä ole TensorFlow 2.16:sta alkaen. Suorita tämä tutoriaali TensorFlow 1.x:ssä tai siirrä valmiiksi ohjelmoitu estimaattori Keras-lineaarimalliin virallisen siirto-oppaan avulla.

Automaattiset hakukirjastot käsittelevät L1- ja L2-tasoja, oppimisnopeutta ja ämpärirajoja hakuavaruutena ja käyttävät sitten Bayesilaista optimointia tai rosvometodeja heikkojen kokeilujen karsimiseen varhaisessa vaiheessa. Tämä korvaa tässä opetusohjelmassa ehdotetun manuaalisen pyyhkäisyn ja löytää yleensä paremman regularisointiparin.

Copilot luonnostelee toistuvat feature_column-mallikaaviot nopeasti, mukaan lukien listan ymmärtämisen jatkuvien sarakkeiden ja ristikkäissarakkeiden lohkojen yli. Käsittele tulostetta ensimmäisenä luonnoksena – tarkista jokainen API-nimi käyttämääsi versiota vasten, koska Copilot yhdistää TensorFlow 1.x- ja 2.x-idiomeja.

Se asettaa, kuinka monen säilöön kategorinen sarake tiivistetään. Liian pieni arvo pakottaa toisiinsa liittymättömät kategoriat törmäämään ja jakamaan saman painon; liian suuri arvo tuhlaa muistia. Aseta se mukavasti erillisten arvojen määrän yläpuolelle, kuten tässä tutoriaalissa tehdään luvulla 1000.

Neliöidyn termin lisääminen siirtää mallia kohti enemmistöluokan ennustamista luotettavammin. Tarkkuus nousee 0.6682:een, kun taas kattavuus laskee 0.2577:ään, mikä on tavanomainen tarkkuuden ja kattavuussuhteen välinen kompromissi epätasapainoisessa etiketissä eikä koodausvirhe.

Käytä ydintä, kun luokkien välillä ei ole lineaarista rajaa edes ryhmittelyn ja ominaisuuksien ylityksen jälkeen. Ytimet kuvaavat dataa implisiittisesti korkeampaan ulottuvuuteen, mutta tämä johtaa hitaampaan koulutukseen ja heikompaan tulkittavuuteen kuin tässä esitetyt lineaariset painot.

Tiivistä tämä viesti seuraavasti: