TensorFlow Binary Classification: Esimerkki lineaarisesta luokittimesta
Evelyn Clarke
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.
- Jos tunnisteessa on vain kaksi luokkaa, oppimisalgoritmi on binaarinen luokitin.
- 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ä 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.
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, X2, ja X3
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+x2+x3+x4+x5. 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ä:
- Ominaisuussarakkeet. Jos jatkuva: tf.feature_column.numeric_column(). Voit täyttää luettelon python-luetteloiden ymmärtämisellä
- Estimaattori: tf.estimator.LinearClassifier(feature_columns, model_dir, n_classes = 2)
- 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
