TensorFlow binaarne klassifikatsioon: lineaarse klassifikaatori näide
Evelyn Clarke
Kaks kõige tavalisemat juhendatud õppimine ülesanneteks on lineaarne regressioon ja lineaarne klassifikaator. Lineaarne regressioon ennustab väärtust, lineaarne klassifikaator aga klassi. See õpetus keskendub lineaarsetele klassifikaatoritele.
Mis on lineaarne klassifikaator?
A Lineaarne klassifikaator masinõppes on meetod objekti klassi leidmiseks selle karakteristikute põhjal statistilise klassifitseerimise jaoks. See teeb klassifitseerimisotsuse objekti omaduste lineaarse kombinatsiooni väärtuse põhjal. Lineaarset klassifikaatorit kasutatakse praktilistes probleemides, nagu dokumentide klassifitseerimine ja paljude muutujatega probleemid.
Klassifitseerimisprobleemid moodustavad ligikaudu 80 protsenti masinõppe ülesandest. Klassifikatsiooni eesmärk on ennustada iga klassi tõenäosust teatud sisendite kogumi korral. Silt (st sõltuv muutuja) on diskreetne väärtus, mida nimetatakse klassiks.
- Kui sildil on ainult kaks klassi, on õppimisalgoritmiks binaarne klassifikaator.
- Mitmeklassiline klassifikaator käsitleb enam kui kahe klassiga silte.
Näiteks on tüüpiline binaarse klassifikatsiooni probleem ennustada tõenäosust, et klient teeb teise ostu. Pildil kuvatava looma tüübi ennustamine on mitme klassi klassifikatsiooni probleem, kuna loomi on rohkem kui kaks liiki.
Selle õpetuse teoreetiline osa keskendub peamiselt kahendklassile. Lisateavet mitme klassi väljundfunktsiooni kohta saate tulevases õpetuses.
Kuidas binaarne klassifikaator töötab?
Eelmises õpetuses õppisite, et funktsioon koosneb kahte tüüpi muutujatest, sõltuvast muutujast ja funktsioonide komplektist (sõltumatutest muutujatest). Lineaarses regressioonis on sõltuvaks muutujaks reaalarv ilma vahemikuta. Esmane eesmärk on ennustada selle väärtust, minimeerides keskmise ruudu vea.
TensorFlow binaarklassifikaatori puhul võib sildil olla kaks võimalikku täisarvu väärtust. Enamasti on see kas [0,1] või [1,2]. Näiteks eesmärk on ennustada, kas klient ostab toote või mitte. Märgistus on määratletud järgmiselt:
- Y = 1 (klient ostis toote)
- Y = 0 (klient ei osta toodet)
Mudel kasutab funktsioone X, et liigitada iga klient kõige tõenäolisemasse klassi, kuhu ta kuulub, nimelt, kas potentsiaalne ostja või mitte.
Edu tõenäosust arvutatakse logistiline regressioon. Algoritm arvutab tõenäosuse välja funktsiooni X põhjal ja ennustab edu, kui see tõenäosus on üle 50 protsendi. Formaalsemalt arvutatakse tõenäosus, nagu on näidatud allolevas TensorFlow binaarse klassifikatsiooni näites:
kus 0 on kaalude, tunnuste kogum ja b nihe.
Funktsiooni saab jagada kaheks osaks:
- Lineaarne mudel
- Logistiline funktsioon
Lineaarne mudel
Olete juba tuttav kaalude arvutamise viisiga. Kaalud arvutatakse punktkorrutise abil:
Y on kõigi tunnuste x lineaarfunktsiooni. Kui mudelil puuduvad tunnused, on ennustus võrdne nihkega, b.
Kaalud näitavad tunnuste x vahelise korrelatsiooni suundai ja silt y. Positiivne korrelatsioon suurendab positiivse klassi tõenäosust, samas kui negatiivne korrelatsioon viib tõenäosuse lähemale 0-le (st negatiivsele klassile).
Lineaarne mudel tagastab ainult reaalarvu, mis on vastuolus vahemiku [0,1] tõenäosusmõõduga. Logistiline funktsioon on vajalik lineaarse mudeli väljundi teisendamiseks tõenäosuseks,
Logistiline funktsioon
Logistiline funktsioon ehk sigmoidfunktsioon on S-kujuline ja selle funktsiooni väljund on alati vahemikus 0 kuni 1.
Lineaarse regressiooni väljundit on lihtne asendada sigmoidfunktsiooniga. Tulemuseks on uus arv tõenäosusega vahemikus 0 kuni 1.
Klassifikaator võib teisendada tõenäosuse klassiks
- Väärtused vahemikus 0 kuni 0.49 muutuvad klassiks 0
- Väärtused vahemikus 0.5 kuni 1 muutuvad klassiks 1
Kuidas mõõta lineaarse klassifikaatori jõudlust?
Täpsus
Klassifikaatori üldist jõudlust mõõdetakse täpsuse mõõdikuga. Täpsus kogub kõik õiged väärtused jagatud vaatluste koguarvuga. Näiteks 80-protsendiline täpsus tähendab, et mudel on 80 protsendil juhtudest õige.
Selle mõõdiku puhul võite märkida puudust, eriti tasakaalustamatuse klassi puhul. Tasakaalustamatuse andmestik tekib siis, kui vaatluste arv rühma kohta ei ole võrdne. Ütleme nii; proovite liigitada haruldast sündmust logistilise funktsiooniga. Kujutage ette, et klassifikaator püüab hinnata patsiendi surma pärast haigust. Andmete kohaselt sureb 5 protsenti patsientidest. Saate koolitada klassifikaatorit, et ennustada surmajuhtumite arvu ja kasutada soorituste hindamiseks täpsusmõõdikut. Kui klassifikaator ennustab kogu andmekogumi jaoks 0 surma, on see õige 95 protsendil juhtudest.
Segadusmaatriks
Parem viis klassifikaatori toimivuse hindamiseks on vaadata segadusmaatriksit.
. segaduse maatriks visualiseerib klassifikaatori täpsust, võrreldes tegelikke ja ennustatud klasse, nagu on näidatud ülaltoodud lineaarse klassifikaatori näites. Binaarne segadusmaatriks koosneb ruutudest:
- TP: tõene positiivne: prognoositud väärtused on õigesti ennustatud tegelike positiivsetena
- FP: prognoositud väärtused ennustasid valesti tegelikku positiivset. st negatiivsed väärtused on ennustatud positiivseteks
- FN: Valenegatiivne: positiivsed väärtused on prognoositud negatiivseteks
- TN: Tõene negatiivne: prognoositud väärtused on õigesti ennustatud tegelike negatiivsetena
Segadusmaatriksist on lihtne võrrelda tegelikku klassi ja prognoositavat klassi.
Täpsus ja tundlikkus
Segadusmaatriks annab hea ülevaate tõelisest positiivsest ja valepositiivsest. Mõnel juhul on parem kasutada täpsemat mõõdikut.
Täpsus
Täpsusmõõdik näitab positiivse klassi täpsust. See mõõdab, kui tõenäoliselt on positiivse klassi ennustus õige.
Maksimaalne punktisumma on 1, kui klassifikaator klassifitseerib kõik positiivsed väärtused ideaalselt. Ainuüksi täpsusest pole suurt abi, sest see ignoreerib negatiivset klassi. Mõõdik on tavaliselt seotud tagasikutsumise mõõdikuga. Meenutamist nimetatakse ka tundlikkuseks või tõeliseks positiivseks määraks.
Tundlikkus
Tundlikkus arvutab õigesti tuvastatud positiivsete klasside suhte. See mõõdik näitab, kui hea on mudel positiivse klassi tuvastamiseks.
Lineaarne klassifikaator TensorFlow'ga
Selle õpetuse jaoks kasutame rahvaloenduse andmestikku. Eesmärk on kasutada loendusandmestiku muutujaid sissetulekutaseme ennustamiseks. Pange tähele, et sissetulek on binaarne muutuja
- väärtusega 1, kui sissetulek > 50k
- 0, kui sissetulek < 50k.
See muutuja on teie silt
See andmekogum sisaldab kaheksat kategoorilist muutujat:
- töökoha
- haridus
- abielu-
- okupatsioon
- suhe
- rass
- sugu
- kodumaa
lisaks kuus pidevat muutujat:
- vanus
- fnlwgt
- hariduse_nr
- kapitalikasum
- kapitali_kahjum
- tundi_nädal
Selle TensorFlow klassifikatsiooni näite kaudu saate aru, kuidas treenida TensorFlow hinnanguga lineaarseid TensorFlow klassifikaatoreid ja kuidas parandada täpsuse mõõdikut.
Toimime järgmiselt:
- Samm 1) Importige andmed
- 2. samm) andmete teisendamine
- 3. samm) Treenige klassifikaatorit
- 4. samm) Täiustage mudelit
- Samm 5) Hüperparameeter: Lasso & Ridge
Samm 1) Importige andmed
Esmalt importige õpetuse ajal kasutatud teegid.
import tensorflow as tf import pandas as pd
Järgmisena impordite andmed UCI arhiivist ja määrate veergude nimed. Pandade andmeraami veergude nimetamiseks kasutate veerge COLUMNS.
Pange tähele, et koolitate klassifikaatorit Pandase andmeraami abil.
## 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"
Internetis salvestatud andmed on juba jagatud rongikoosseisu ja katsekomplekti vahel.
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)
Rongikomplekt sisaldab 32,561 16,281 vaatlust ja katsekomplekt 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 nõuab klassifikaatori treenimiseks Boole'i väärtust. Peate väärtused stringist täisarvuni üle kandma. Silt salvestatakse objektina, kuid peate selle teisendama numbriliseks väärtuseks. Allolev kood loob sõnastiku väärtustega, mida teisendada ja veeru üksusel üle käia. Pange tähele, et teete seda toimingut kaks korda, ühe rongikatse ja teise katsekomplekti jaoks
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]
Rongiandmetes on 24,720 50 sissetulekut alla 7841 XNUMX ja XNUMX üle selle. Testikomplekti puhul on suhe peaaegu sama. Lisateabe saamiseks vaadake seda aspektide õpetust.
print(df_train["label"].value_counts()) ### The model will be correct in atleast 70% of the case print(df_test["label"].value_counts()) ## Unbalanced label print(df_train.dtypes) 0 24720 1 7841 Name: label, dtype: int64 0 12435 1 3846 Name: label, dtype: int64 age int64 workclass object fnlwgt int64 education object education_num int64 marital object occupation object relationship object race object sex object capital_gain int64 capital_loss int64 hours_week int64 native_country object label int64 dtype: object
2. samm) andmete teisendamine
Enne lineaarse klassifikaatori Tensorflow abil treenimist on vaja teha paar sammu. Peate ette valmistama funktsioonid, mida mudelisse lisada. Võrdlusregressioonis kasutate algandmeid ilma teisendusi rakendamata.
Hindajal peab mudeli koolitamiseks olema funktsioonide loend. Seetõttu tuleb veeru andmed teisendada tensoriks.
Hea tava on määratleda kaks funktsioonide loendit nende tüübi alusel ja seejärel edastada need hindaja veergudesse feature_columns.
Alustuseks teisendate pidevad funktsioonid, seejärel määrate kategooriliste andmetega ämbri.
Andmestiku funktsioonidel on kaks vormingut:
- Täisarv
- objekt
Iga funktsioon on loetletud kahes järgmises muutujas vastavalt nende tüüpidele.
## 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']
Funktsioon_veerg on varustatud objektiga numeric_column, mis aitab pidevaid muutujaid tenoriks teisendada. Allolevas koodis teisendate kõik CONTI_FEATURES muutujad numbrilise väärtusega tensoriks. See on mudeli koostamiseks kohustuslik. Kõik sõltumatud muutujad tuleb teisendada õiget tüüpi tensoriks.
Allpool kirjutame koodi, mis võimaldab teil näha, mis toimub funktsiooni feature_column.numeric_column taga. Prindime vanuse teisendatud väärtuse. See on selgitav eesmärk, seega pole vaja Pythoni koodi mõista. Koodide mõistmiseks võite vaadata ametlikku dokumentatsiooni.
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.]]
Väärtused on täpselt samad, mis failis df_train
continuous_features = [tf.feature_column.numeric_column(k) for k in CONTI_FEATURES]
TensorFlow dokumentatsiooni kohaselt on kategooriliste andmete teisendamiseks erinevaid viise. Kui tunnuse sõnavaraloend on teada ja sellel pole palju väärtusi, on võimalik luua kategooria veerg kategooriaga_veerg_koos_sõnavara_loendiga. See määrab kõigile ainulaadsetele sõnavarade loendile ID.
Näiteks kui muutuja olekul on kolm erinevat väärtust:
- mees
- Naine
- Ühepikkused
Seejärel omistatakse kolm ID-d. Näiteks on mehel ID 1, naisel ID 2 ja nii edasi.
Illustreerimise eesmärgil saate seda koodi kasutada objektimuutuja teisendamiseks TensorFlow's kategooriliseks veerguks.
Tunnussool võib olla ainult kaks väärtust: mees või naine. Funktsiooni soo teisendamisel loob Tensorflow kaks uut veergu, ühe meeste ja teise naiste jaoks. Kui sugu on võrdne meessoost, siis uus veerg mees on 2 ja naine 1. See näide on näidatud allolevas tabelis:
| rida | sugu | pärast transformatsiooni | mees | naine |
|---|---|---|---|---|
| 1 | mees | => | 1 | 0 |
| 2 | mees | => | 1 | 0 |
| 3 | naine | => | 0 | 1 |
Tensorvoos:
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'])
Allpool lisasime Python kood kodeeringu printimiseks. Jällegi ei pea te koodist aru saama, eesmärk on näha teisendust
Kuid kiirem viis andmete teisendamiseks on kasutada meetodit categorical_column_with_hash_bucket. Stringi muutujate muutmine hõredas maatriksis on kasulik. Hõreda maatriks on maatriks, millel on enamasti null. Meetod hoolitseb kõige eest. Peate määrama ainult ämbrite arvu ja võtme veeru. Salvede arv on maksimaalne rühmade arv, mida Tensorflow saab luua. Võtmeveerg on lihtsalt teisendatava veeru nimi.
Allolevas koodis loote kõigi kategooriliste funktsioonide tsükli.
categorical_features = [tf.feature_column.categorical_column_with_hash_bucket(k, hash_bucket_size=1000) for k in CATE_FEATURES]
3. samm) Treenige klassifikaatorit
TensorFlow pakub praegu lineaarse regressiooni ja lineaarse klassifikatsiooni hinnangut.
- Lineaarne regressioon: Lineaarregressor
- Lineaarne klassifikatsioon: LinearClassifier
Lineaarse klassifikaatori süntaks on sama, mis õpetuses lineaarse regressiooni välja arvatud üks argument, n_class. Peate määratlema funktsioonide veeru, mudelikataloogi ja võrdlema lineaarse regressoriga; teil on määrata klasside arv. Logiti regressiooni korral on klasside arv võrdne 2-ga.
Mudel arvutab pidevate_funktsioonide ja kategoorialiste_funktsioonide veergude kaalud.
model = tf.estimator.LinearClassifier(
n_classes = 2,
model_dir="ongoing/train",
feature_columns=categorical_features+ continuous_features)
Väljund
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}
Nüüd, kui klassifikaator on määratletud, saate luua sisendfunktsiooni. Meetod on sama, mis lineaarse regresori õpetuses. Siin kasutate partii suurust 128 ja segate andmeid.
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)
Loote funktsiooni lineaarse hindaja nõutavate argumentidega, st ajastute arvu, partiide arvu ja segate andmekogumit või märkust. Kuna kasutate Pandad meetodil andmete mudelisse edastamiseks peate määratlema X-muutujad panda andmeraamina. Pange tähele, et vaatate üle kõik jaotisesse FEATURES salvestatud andmed.
Treenime mudelit objektiga model.train. Mudelile sobivate väärtustega varustamiseks kasutate eelnevalt määratletud funktsiooni. Pange tähele, et määrasite partii suuruseks 128 ja perioodide arvuks Puudub. Modelli treenitakse üle tuhande sammu.
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>
Pange tähele, et kaotus vähenes hiljem viimase 100 sammu jooksul, st 901-lt 1000-le.
Lõplik kadu pärast tuhat iteratsiooni on 5444. Saate oma mudelit testikomplektis hinnata ja jõudlust vaadata. Mudeli toimivuse hindamiseks peate kasutama objekti hindamist. Toidate mudelit testikomplektiga ja määrate epohhide arvuks 1, st andmed lähevad mudelile ainult ühe korra.
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 tagastab kõik teoreetilises osas õpitud mõõdikud. Ilma üllatuseta on täpsus tasakaalustamata sildi tõttu suur. Tegelikult toimib mudel pisut paremini kui juhuslik oletus. Kujutage ette, et mudel ennustab kõiki leibkondi, kelle sissetulek on alla 50 70, siis on mudeli täpsus XNUMX protsenti. Lähemal analüüsil näete, et ennustus ja meeldetuletus on üsna madalad.
4. samm) Täiustage mudelit
Nüüd, kui teil on võrdlusmudel, võite proovida seda täiustada, st täpsust suurendada. Eelmises õpetuses õppisite, kuidas interaktsioonitermini abil ennustusvõimsust parandada. Selles õpetuses käsitlete seda ideed uuesti, lisades regressioonile polünoomilise termini.
Polünoomi regressioon on oluline, kui andmed on mittelineaarsused. Andmete mittelineaarsuse jäädvustamiseks on kaks võimalust.
- Lisa polünoomtermin
- Jaotage pidev muutuja kategooriliseks muutujaks
Polünoomiline termin
Allolevalt pildilt näete, mis on polünoomregressioon. See on võrrand erineva võimsusega X muutujaga. Teise astme polünoomi regressioonil on kaks muutujat, X ja X ruudus. Kolmandal astmel on kolm muutujat, X, X2ja X3
Allpool koostasime graafiku kahe muutujaga X ja Y. On ilmne, et seos ei ole lineaarne. Kui lisame lineaarse regressiooni, näeme, et mudel ei suuda mustrit jäädvustada (vasakpoolne pilt).
Vaata nüüd allolevalt pildilt vasakpoolset pilti, lisasime regressioonile viieliikmelise (see on y=x+x2+x3+x4+x5. Mudel jäädvustab nüüd mustrit palju paremini. See on polünoomi regressiooni jõud.
Läheme tagasi meie näite juurde. Vanus ei ole lineaarses seoses sissetulekuga. Varajases eas võib sissetulek olla nullilähedane, kuna lapsed või noored ei tööta. Siis tõuseb see tööeas ja väheneb pensionile jäädes. Tavaliselt on see ümberpööratud U-kujuline. Üks viis selle mustri tabamiseks on lisada regressioonile võimsus kaks.
Vaatame, kas see suurendab täpsust.
Peate lisama selle uue funktsiooni andmestikku ja pidevate funktsioonide loendisse.
Lisate uue muutuja rongi ja testi andmekogusse, nii on funktsiooni kirjutamine mugavam.
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
Funktsioonil on 3 argumenti:
- df_t: määrake treeningkomplekt
- df_te: määrake testikomplekt
- var_name = 'vanus': määrake teisendatav muutuja
Muutuja vanuse ruudustamiseks saate kasutada objekti pow(2). Pange tähele, et uue muutuja nimi on "uus"
Nüüd, kui funktsioon square_var on kirjutatud, saate luua uued andmekogumid.
df_train_new, df_test_new = square_var(df_train, df_test, var_name = 'age')
Nagu näete, on uuel andmekogumil veel üks funktsioon.
print(df_train_new.shape, df_test_new.shape) (32561, 16) (16281, 16)
Ruutmuutujat nimetatakse andmekogumis uueks. Peate selle lisama pidevate funktsioonide loendisse.
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]
märkused et muutsite graafiku kataloogi. Samas kataloogis ei saa treenida erinevaid mudeleid. See tähendab, et peate muutma argumendi model_dir teed. Kui te seda ei tee, kuvab TensorFlow veateate.
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)
Nüüd, kui klassifikaator on koostatud uue andmestikuga, saate mudelit koolitada ja hinnata.
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}
Ruutmuutuja parandas täpsust 0.76-lt 0.79-le. Vaatame, kas saate paremini teha, kui kombineerite ämbrisse paigutamise ja interaktsioonitermini koos.
Ämbristamine ja interaktsioon
Nagu varem nägite, ei suuda lineaarne klassifikaator vanuse-sissetuleku mustrit õigesti tabada. Seda seetõttu, et see õpib iga funktsiooni jaoks ühe kaalu. Klassifikaatori töö hõlbustamiseks saate funktsiooni ämbrisse koondada. Jaotamine teisendab numbrilise tunnuse mitmeks teatud tunnuseks vastavalt vahemikule, kuhu see kuulub, ja kõik need uued funktsioonid näitavad, kas inimese vanus jääb sellesse vahemikku.
Nende uute funktsioonide abil saab lineaarne mudel seost tabada, õppides iga ämbri jaoks erinevaid kaalusid.
TensorFlow's tehakse seda bucketized_columniga. Peate piiridesse lisama väärtuste vahemiku.
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])
Te juba teate, et vanus ei ole sissetulekuga lineaarne. Teine võimalus mudelit täiustada on suhtlemine. TensorFlow sõnastuses on see funktsioonide ületamine. Funktsioonide ristamine on viis uute funktsioonide loomiseks, mis on olemasolevate kombinatsioonid. Sellest võib olla abi lineaarse klassifikaatori puhul, mis ei suuda modelleerida funktsioonide vahelisi koostoimeid.
Saate vanust alandada mõne muu funktsiooniga, nagu haridus. See tähendab, et mõnel rühmal on tõenäoliselt kõrge sissetulek ja teistel madal (mõelge doktorandile).
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)]
Ristfunktsiooni veeru loomiseks kasutage ristitud_veeru, mille muutujad on sulgudes ristuvad. Hash_bucket_size näitab maksimaalseid ületamise võimalusi. Muutujatevahelise interaktsiooni loomiseks (vähemalt üks muutuja peab olema kategooriline) võite kasutada faili tf.feature_column.crossed_column. Selle objekti kasutamiseks peate nurksulgudesse lisama interakteeruva muutuja ja teise argumendi, ämbri suuruse. Salve suurus on muutuja piires maksimaalne võimalik rühmade arv. Siin määrate selle väärtuseks 1000, kuna te ei tea rühmade täpset arvu
Vanus_buckets tuleb enne selle funktsiooni veergudesse lisamiseks ruudus teha. Samuti lisate uued funktsioonid funktsioonide veergudesse ja valmistate ette hinnangu
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)
Väljund
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)
Olete valmis hindama uut mudelit ja vaatama, kas see parandab täpsust.
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}
Uus täpsusaste on 83.58 protsenti. See on neli protsenti kõrgem kui eelmisel mudelil.
Lõpuks saate ülepaigutamise vältimiseks lisada reguleerimistermini.
Samm 5) Hüperparameeter: Lasso & Ridge
Teie mudel võib kannatada üleliigne or alamvarustuses.
- Ülesobitamine: mudel ei suuda ennustust uutele andmetele üldistada
- Alasobitus: mudel ei suuda jäädvustada andmete mustrit. st lineaarne regressioon, kui andmed on mittelineaarsed
Kui mudelil on palju parameetreid ja suhteliselt väike hulk andmeid, põhjustab see halbu ennustusi. Kujutage ette, ühel rühmal on ainult kolm vaatlust; mudel arvutab selle rühma kaalu. Kaalu kasutatakse ennustuse tegemiseks; kui selle konkreetse rühma katsekomplekti tähelepanekud on koolituskomplektist täiesti erinevad, teeb mudel vale ennustuse. Treeningkomplektiga hindamisel on täpsus hea, kuid testikomplekti puhul mitte hea, kuna arvutatud kaalud ei ole mustri üldistamiseks õiged. Sel juhul ei tee see nähtamatute andmete põhjal mõistlikku ennustust.
Ülesobitamise vältimiseks annab regulatsioon teile võimaluse sellist keerukust kontrollida ja üldistatavamaks muuta. Reguleerimistehnikaid on kaks:
- L1: Lasso
- L2: Ridge
TensorFlow's saate optimeerijasse lisada need kaks hüperparameetrit. Näiteks, mida kõrgem on hüperparameeter L2, kipub kaal olema väga madal ja nullilähedane. Sobitatud joon on väga tasane, samas kui nullilähedane L2 tähendab, et kaalud on lähedased tavalisele lineaarsele regressioonile.
Saate ise proovida hüperparameetrite erinevaid väärtusi ja vaadata, kas saate täpsust suurendada.
märkused et kui muudate hüperparameetrit, peate kustutama kausta käimasoleva/train4, vastasel juhul käivitub mudel eelnevalt koolitatud mudeliga.
Vaatame, kuidas on hype täpsus
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))
VÄLJASTUS
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)
VÄLJASTUS
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)
Väljund
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}
Selle hüperparameetriga suurendate veidi täpsusmõõdikuid. Järgmises õpetuses saate teada, kuidas kerneli meetodil lineaarset klassifikaatorit täiustada.
kokkuvõte
Modelli koolitamiseks peate:
- Määratlege omadused: Sõltumatud muutujad: X
- Määrake silt: Sõltuv muutuja: y
- Ehitage rong/katsekomplekt
- Määrake algkaal
- Defineerige kadufunktsioon: MSE
- Mudeli optimeerimine: gradient laskumine
- Määratlege:
- Õppimise määr
- Ajastu arv
- Partii suurus
- Klassi arv
Selles õpetuses õppisite kasutama kõrgetasemelist API-d lineaarse regressiooni klassifikaatori jaoks. Peate määratlema:
- Funktsiooniveerud. Kui pidev: tf.feature_column.numeric_column(). Saate täita loendi pythoni loendi mõistmisega
- Hindaja: tf.estimator.LinearClassifier(funktsiooni_veerud, mudeli_kataloog, n_klassid = 2)
- Funktsioon andmete, partii suuruse ja epohhi importimiseks: input_fn()
Pärast seda olete valmis treenima, hindama ja ennustama koos train(), hindama() ja ennustama() abil.
Mudeli jõudluse parandamiseks saate:
- Kasutage polünoomi regressiooni
- Interaktsioonitermin: tf.feature_column.crossed_column
- Lisage reguleerimisparameeter
