Binární klasifikace TensorFlow: Příklad lineárního klasifikátoru

⚡ Chytré shrnutí

Lineární klasifikátory přiřazují každé pozorování do třídy na základě váženého součtu jeho rysů. Tento návod vytváří binární klasifikátor TensorFlow na datové sadě sčítání lidu a zvyšuje přesnost z 0.76 na 0.84.

🔘 Základní definice: Lineární klasifikátor predikuje diskrétní třídu z lineární kombinace hodnot rysů.
☑️ Krok pravděpodobnosti: Logistická funkce převádí výstup lineárního modelu na pravděpodobnost mezi 0 a 1.
(Tj. Na metrikách záleží: Samotná přesnost u nevyvážených popisků zavádí, proto ji spojte s maticí zmatku, přesností a zapamatovatelností.
🧪 Průvodce sčítáním lidu: Šest spojitých a osm kategorických sloupců se stane tenzory dříve, než je odhad vůbec uvidí.
🛠️ Technické inženýrství: Umocnění věku, jeho rozdělení do skupin a následné zkřížení vzdělání s povoláním zvyšuje přesnost z 0.7616 na 0.8358.
📈 Regulace: Optimalizátor Ftrl s L1 na 0.9 a L2 na 5 zvyšuje konečnou přesnost na 0.8383.

Přečíst více

Dva nejčastější učení pod dohledem úlohy jsou lineární regrese a lineární klasifikátor. Lineární regrese předpovídá hodnotu, zatímco lineární klasifikátor předpovídá třídu. Tento tutoriál je zaměřen na lineární klasifikátory.

Co je lineární klasifikátor?

A Lineární klasifikátor ve strojovém učení je metoda pro nalezení třídy objektu na základě jeho charakteristik pro statistickou klasifikaci. Rozhoduje o klasifikaci na základě hodnoty lineární kombinace charakteristik objektu. Lineární klasifikátor se používá v praktických problémech, jako je klasifikace dokumentů a problémy s mnoha proměnnými.

Problémy s klasifikací představují zhruba 80 procent úlohy strojového učení. Klasifikace se zaměřuje na předpovídání pravděpodobnosti každé třídy dané sadou vstupů. Návěští (tj. závislá proměnná) je diskrétní hodnota, nazývaná třída.

Pokud má štítek pouze dvě třídy, je algoritmem učení binární klasifikátor.
Vícetřídní klasifikátor se zabývá štítky s více než dvěma třídami.

Například typickým problémem binární klasifikace je předpovědět pravděpodobnost, že zákazník provede druhý nákup. Předpovědět typ zvířete zobrazeného na obrázku je problém klasifikace více tříd, protože existují více než dva druhy zvířat.

Teoretická část tohoto tutoriálu se primárně zaměřuje na binární třídu. Více o funkci multiclass output se dozvíte v budoucím tutoriálu.

Po stanovení definice je dalším krokem zjistit, jak algoritmus převádí nezpracované rysy na rozhodnutí o třídě.

Jak funguje binární klasifikátor?

V předchozím tutoriálu jste se naučili, že funkce se skládá ze dvou druhů proměnných, závislé proměnné a sady funkcí (nezávislých proměnných). V lineární regresi je závislá proměnná reálné číslo bez rozsahu. Primárním cílem je předpovědět jeho hodnotu minimalizací střední kvadratické chyby.

Pro TensorFlow Binární klasifikátor, popisek může mít dvě možné celočíselné hodnoty. Ve většině případů je to buď [0,1], nebo [1,2]. Cílem je například předpovědět, zda si zákazník produkt koupí či nikoli. Popisek je definován následovně:

Y = 1 (zákazník zakoupil produkt)
Y = 0 (zákazník si produkt nekoupí)

Model využívá funkce X ke klasifikaci každého zákazníka do nejpravděpodobnější třídy, do které patří, tedy do potenciálního kupce nebo ne.

S pravděpodobností úspěchu se počítá logistické regrese. Algoritmus vypočítá pravděpodobnost na základě prvku X a předpovídá úspěch, když je tato pravděpodobnost vyšší než 50 procent. Formálněji se pravděpodobnost vypočítá, jak je uvedeno v níže uvedeném příkladu binární klasifikace TensorFlow:

kde 0 je množina vah, vlastností ab vychýlení.

Funkci lze rozložit na dvě části:

Lineární model
Logistická funkce

Lineární model

Již jste obeznámeni se způsobem výpočtu vah. Hmotnosti se počítají pomocí bodového součinu: Y je lineární funkcí všech prvků x_i. Pokud model nemá vlastnosti, je předpověď rovna vychýlení, b.

Váhy udávají směr korelace mezi znaky x_i a štítek y. Kladná korelace zvyšuje pravděpodobnost pozitivní třídy, zatímco negativní korelace vede pravděpodobnost blíže k 0 (tj. záporná třída).

Lineární model vrací pouze reálné číslo, které není v souladu s pravděpodobnostní mírou rozsahu [0,1]. Logistická funkce je nutná k převodu výstupu lineárního modelu na pravděpodobnost,

Logistická funkce

Logistická funkce nebo sigmoidní funkce má tvar S a výstup této funkce je vždy mezi 0 a 1.

Níže uvedený vzorec uvádí transformaci a následující graf ukazuje zploštění výsledné křivky směrem k 0 vlevo a směrem k 1 vpravo.

S-tvarovaná sigmoidální křivka ohraničená mezi 0 a 1 — Příklad logistické funkce

Je snadné dosadit výstup lineární regrese do sigmoidní funkce. Výsledkem je nové číslo s pravděpodobností mezi 0 a 1.

Klasifikátor může transformovat pravděpodobnost na třídu

Hodnoty mezi 0 a 0.49 se stanou třídou 0
Hodnoty mezi 0.5 a 1 se stanou třídou 1

Jakmile model vygeneruje třídy, potřebujete způsob, jak posoudit, zda jsou tyto třídy dobré.

Jak měřit výkon lineárního klasifikátoru?

Přesnost

Celkový výkon klasifikátoru se měří pomocí metriky přesnosti. Přesnost shromažďuje všechny správné hodnoty vydělené celkovým počtem pozorování. Například hodnota přesnosti 80 procent znamená, že model je správný v 80 procentech případů.

U této metriky můžete zaznamenat nedostatek, zejména u třídy nevyváženosti. K nerovnováze dochází, když počet pozorování na skupinu není stejný. Řekněme; pokusíte se klasifikovat vzácnou událost s logistickou funkcí. Představte si, že se klasifikátor snaží odhadnout úmrtí pacienta po onemocnění. Podle údajů zemře 5 procent pacientů. Můžete trénovat klasifikátor pro předpovídání počtu úmrtí a používat metriku přesnosti k hodnocení výkonů. Pokud klasifikátor předpovídá 0 úmrtí pro celý soubor dat, bude to správné v 95 procentech případů.

Matice zmatení

Lepším způsobem, jak posoudit výkon klasifikátoru, je podívat se na matici zmatků.

Binární matice zmatku zobrazující čtverce TP, FP, FN a TN — Změřte výkon lineárního klasifikátoru pomocí matoucí matice

Jedno matoucí matice vizualizuje přesnost klasifikátoru porovnáním skutečných a předpokládaných tříd, jak je uvedeno ve výše uvedeném příkladu lineárního klasifikátoru. Binární konfuzní matice se skládá ze čtverců:

TP: True Positive: Předpokládané hodnoty správně předpovězené jako skutečně pozitivní
FP: Předpokládané hodnoty nesprávně předpověděly skutečný kladný výsledek. tj. záporné hodnoty predikované jako kladné
FN: Falešně negativní: Pozitivní hodnoty předpovězené jako negativní
TN: True Negative: Předpokládané hodnoty správně předpovězené jako skutečně negativní

Z matné matice je snadné porovnat skutečnou třídu a předpokládanou třídu.

Přesnost a citlivost

Matice zmatení poskytuje dobrý náhled na skutečně pozitivní a falešně pozitivní. V některých případech je vhodnější mít stručnější metriku.

Přesnost

Metrika přesnosti ukazuje přesnost kladné třídy. Měří, s jakou pravděpodobností je předpověď pozitivní třídy správná.

Maximální skóre je 1, když klasifikátor dokonale klasifikuje všechny kladné hodnoty. Samotná přesnost není příliš užitečná, protože ignoruje negativní třídu. Metrika je obvykle spárována s metrikou Vyvolání. Vyvolání se také nazývá citlivost nebo skutečně pozitivní míra.

Citlivost

Citlivost vypočítá poměr správně detekovaných pozitivních tříd. Tato metrika udává, jak dobře model rozpozná pozitivní třídu.

Teorie je nyní na místě, takže zbytek tohoto návodu ji aplikuje v kódu od začátku do konce.

Lineární klasifikátor s TensorFlow

V tomto tutoriálu použijeme datovou sadu ze sčítání lidu. Účelem je použít proměnné v souboru údajů ze sčítání k predikci úrovně příjmu. Všimněte si, že příjem je binární proměnná

s hodnotou 1, pokud je příjem > 50 tis
0, pokud příjem < 50 tis.

Tato proměnná je váš štítek

Tato datová sada obsahuje osm kategorických proměnných:

pracoviště
vzdělání
manželský
povolání
vztah
závod
pohlaví
rodná země

navíc šest spojitých proměnných:

stáří
fnlwgt
vzdělání_číslo
kapitálový zisk
kapitálová_ztráta
hodiny_týden

Prostřednictvím tohoto příkladu klasifikace TensorFlow pochopíte, jak trénovat lineární klasifikátory TensorFlow pomocí estimátoru TensorFlow a jak zlepšit metriku přesnosti.

Poznámka k verzi: Níže uvedený kód používá rozhraní TensorFlow 1.x Estimator API. tf-estimator Balíček byl dodán ve finální verzi s TensorFlow 2.15 a není k dispozici v TensorFlow 2.16 nebo novějších, proto spusťte tyto úryvky kódu na TensorFlow 1.x nebo je portujte s oficiálním balíčkem. Průvodce migrací předpřipraveného odhaduKoncepty, návrh funkcí a metriky zůstávají stejné.

Budeme postupovat následovně:

Krok 1) Importujte data
Krok 2) Konverze dat
Krok 3) Trénujte klasifikátor
Krok 4) Vylepšete model
Krok 5) Hyperparametr:Lasso & Ridge

Krok 1) Importujte data

Nejprve importujete knihovny použité během kurzu.

import tensorflow as tf
import pandas as pd

Dále importujete data z archivu UCI a definujete názvy sloupců. K pojmenování sloupců v datovém rámci panda použijete sloupce COLUMNS.

Všimněte si, že budete trénovat klasifikátor pomocí datového rámce Pandas.

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

Data uložená online jsou již rozdělena mezi vlakovou soupravu a testovací soupravu.

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)

Vlaková souprava obsahuje 32,561 16,281 pozorování a testovací souprava 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 vyžaduje pro trénování klasifikátoru booleovskou hodnotu. Hodnoty je třeba převést z řetězce na celé číslo. Popisek je uložen jako objekt, ale je třeba jej převést na číselnou hodnotu. Následující kód vytvoří slovník s hodnotami, které se mají převést, a provede smyčku přes položku sloupce. Tuto operaci provedete dvakrát, jednou pro trénovací test a jednou pro testovací sadu.

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]

V datech z vlaku je 24 720 osob s příjmy nižšími než 50 tisíc a 7 841 osob s příjmy vyššími. Poměr je pro testovací sadu téměř stejný, takže zhruba 76 procent obou rozdělení nese negativní třídu.

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

Krok 2) Konverze dat

Před trénováním lineárního klasifikátoru pomocí TensorFlow je nutné provést několik kroků. Je třeba připravit prvky, které chcete zahrnout do modelu. V benchmarkové regresi použijete původní data bez jakékoli transformace, přesně tak, jak... scikit-učit se Potrubí by začínalo od nezpracovaných sloupců.

Odhadce musí mít seznam funkcí pro trénování modelu. Data sloupce je tedy nutné převést na tenzor.

Osvědčeným postupem je definovat dva seznamy prvků na základě jejich typu a poté je předat ve sloupcích feature_columns estimátoru.

Začnete převodem spojitých prvků a poté definujte segment s kategorickými daty.

Funkce datové sady mají dva formáty:

Celé číslo
Objekt

Každá funkce je uvedena v následujících dvou proměnných podle jejich typů.

## 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 je vybaven objektem numeric_column, který pomáhá při transformaci spojitých proměnných na tenzor. V níže uvedeném kódu převedete všechny proměnné z CONTI_FEATURES na tenzor s číselnou hodnotou. To je nutné pro konstrukci modelu. Všechny nezávislé proměnné je třeba převést na správný typ tenzoru.

Níže napíšeme kód, který vám umožní vidět, co se děje za feature_column.numeric_column. Vypíšeme převedenou hodnotu pro age. Slouží to pro ilustrační účely, proto není třeba rozumět Python kód. Pro pochopení kódů se můžete podívat do oficiální dokumentace.

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

Hodnoty jsou přesně stejné jako v df_train

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

Podle dokumentace TensorFlow existují různé způsoby, jak převádět kategorická data. Pokud je seznam slovní zásoby prvku znám a nemá dostatek hodnot, je možné vytvořit sloupec kategorie s categorical_column_with_vocabulary_list. Všem jedinečným seznamům slovníků přiřadí ID.

Pokud má například stav proměnné tři různé hodnoty:

Manžel
Manželka
Jediný

Poté budou přidělena tři ID. Například manžel bude mít ID 1, manželka ID 2 a tak dále.

Pro účely ilustrace můžete tento kód použít k převodu objektové proměnné na kategorický sloupec v TensorFlow.

Pohlaví rysu může mít pouze dvě hodnoty: mužský nebo ženský. Po převodu pohlaví rysu TensorFlow vytvoří 2 nové sloupce, jeden pro mužský a jeden pro ženský. Pokud je pohlaví rovno mužskému, pak bude nový sloupec pro mužský roven 1 a pro ženský 0. Tento příklad je zobrazen v tabulce níže:

Řádky	pohlaví	po transformaci	samec	žena
1	samec	=>	1	0
2	samec	=>	1	0
3	žena	=>	0	1

V tensorflow:

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

Níže jsme dodali Python kód pro tisk kódování. Opět nemusíte rozumět kódu, účelem je vidět transformaci

Rychlejší způsob transformace dat je však použití metody categorical_column_with_hash_bucket. Změna řetězcových proměnných v řídké matici bude užitečná. Řídká matice je matice s většinou nul. Metoda se postará o vše. Stačí zadat pouze počet košů a klíčový sloupec. Počet košů je maximální počet skupin, které TensorFlow může vytvořit. Klíčový sloupec je jednoduše název sloupce, který se má převést.

V níže uvedeném kódu vytvoříte smyčku přes všechny kategorické funkce.

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

Krok 3) Trénujte klasifikátor

TensorFlow v současné době poskytuje odhad pro lineární regresi a lineární klasifikaci.

Lineární regrese: LinearRegressor
Lineární klasifikace: LinearClassifier

Syntaxe lineárního klasifikátoru je stejná jako v tutoriálu na lineární regrese kromě jednoho argumentu, n_class. Musíte definovat sloupec prvku, adresář modelu a porovnat s lineárním regresorem; máte definovat číslo třídy. Pro logitovou regresi je počet tříd roven 2.

Model vypočítá váhy sloupců obsažených v continuous_features a categorical_features.

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

Výstup

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}

Nyní, když je klasifikátor definován, můžete vytvořit vstupní funkci. Metoda je stejná jako v tutoriálu pro lineární regresor. Zde použijete velikost dávky 128 a data zamícháte.

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)

Vytvoříte funkci s argumenty požadovanými lineárním odhadem, tj. počtem epoch, počtem dávek a zamícháte datovou sadu nebo poznámku. Vzhledem k tomu, že používáte Pandy k předání dat do modelu, musíte definovat proměnné X jako datový rámec pandy. Všimněte si, že smyčkou procházíte všechna data uložená v FUNKCÍCH.

Pojďme trénovat model s objektem model.train. Pomocí funkce, která byla dříve definována, naplníte model příslušnými hodnotami. Všimněte si, že nastavíte velikost dávky na 128 a počet epoch na Žádné. Model bude trénován přes tisíc kroků.

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>

Všimněte si, že ztráta se následně snížila během posledních 100 kroků, tj. z 901 na 1000.

Konečná ztráta po tisíci iteracích je 5444. Svůj model můžete odhadnout na testovací sadě a podívat se na výkon. Chcete-li vyhodnotit výkon vašeho modelu, musíte použít vyhodnocení objektu. Naplníte model testovací sadou a nastavíte počet epoch na 1, tj. data půjdou do modelu pouze jednou.

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 vrátí všechny metriky, které jste se naučili v teoretické části. Bez překvapení je přesnost velká díky nevyváženému označení. Ve skutečnosti model funguje o něco lépe než náhodný odhad. Představte si, že model předpovídá všechny domácnosti s příjmem nižším než 50 tisíc, pak má model přesnost 70 procent. Při bližší analýze můžete vidět, že předpověď a vyvolání jsou poměrně nízké.

Krok 4) Vylepšete model

Nyní, když máte model benchmarku, můžete jej zkusit vylepšit, tedy zvýšit přesnost. V předchozím tutoriálu jste se naučili, jak zlepšit schopnost předpovídání pomocí termínu interakce. V tomto tutoriálu se k této myšlence vrátíte přidáním polynomického členu k regresi.

Polynomiální regrese je užitečná, pokud je v datech nelinearita. Existují dva způsoby, jak zachytit nelinearitu v datech.

Přidejte polynomický člen
Segmentujte spojitou proměnnou na kategorickou proměnnou

Polynomiální člen

Z obrázku níže můžete vidět, co je to polynomiální regrese. Je to rovnice s X proměnnými s různou mocností. Polynomiální regrese druhého stupně má dvě proměnné, X a X na druhou. Třetí stupeň má tři proměnné, X, X²a X³

Polynomiální regresní rovnice druhého a třetího stupně — Co je polynomiální regrese

Výše uvedený graf znázorňuje křivku druhého stupně oproti její podkladové rovnici. Níže jsme vytvořili graf se dvěma proměnnými, X a Y. Je zřejmé, že vztah není lineární. Pokud přidáme lineární regresi, vidíme, že model není schopen zachytit daný vzorec (levý obrázek).

Nyní se podívejte na levý obrázek z obrázku níže, k regresi jsme přidali pětičleny (to je y=x+x²+x³+x⁴+x⁵. Model nyní mnohem lépe zachycuje vzor. To je síla polynomiální regrese.

Vraťme se k našemu příkladu. Věk není v lineárním vztahu s příjmem. Raný věk může mít rovný příjem blízký nule, protože děti nebo mladí lidé nepracují. Pak se zvyšuje v produktivním věku a klesá v důchodu. Je to typicky tvar obráceného U. Jedním ze způsobů, jak zachytit tento vzorec, je přidat k regresi mocninu dvě.

Uvidíme, jestli to zvýší přesnost.

Tuto novou funkci musíte přidat do datové sady a do seznamu spojitých funkcí.

Novou proměnnou přidáte do datové sady vlaku a testu, takže je pohodlnější napsat funkci.

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

Funkce má 3 argumenty:

df_t: definuje trénovací sadu
df_te: definuje testovací sadu
var_name = 'věk': Definujte proměnnou, kterou chcete transformovat

Ke čtverci proměnné stáří můžete použít objekt pow(2). Všimněte si, že nová proměnná se jmenuje 'new'

Nyní, když je funkce square_var napsána, můžete vytvořit nové datové sady.

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

Jak vidíte, nový datový soubor má ještě jednu funkci.

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

Čtvercová proměnná se v datové sadě nazývá new. Musíte jej přidat do seznamu spojitých funkcí.

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]

Hodnocení že jste změnili adresář grafu. Nemůžete trénovat různé modely ve stejném adresáři. To znamená, že musíte změnit cestu argumentu model_dir. Pokud tak neučiníte, TensorFlow vyvolá chybu.

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)

Nyní, když je klasifikátor navržen s novou datovou sadou, můžete model trénovat a vyhodnocovat.

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}

Druhá mocnina zlepšila přesnost z 0.76 na 0.79. Podívejme se, zda můžete udělat lépe tím, že zkombinujete pojem segmentace a interakce dohromady.

Bucketizace a interakce

Jak jste viděli dříve, lineární klasifikátor není schopen správně zachytit vzorec věku a příjmu. Je to proto, že se učí jednu váhu pro každý prvek. Chcete-li to klasifikátorovi usnadnit, jednu věc, kterou můžete udělat, je seskupit funkci. Segmentování transformuje číselný prvek na několik určitých na základě rozsahu, do kterého spadá, a každá z těchto nových funkcí udává, zda věk osoby spadá do tohoto rozsahu.

S těmito novými funkcemi může lineární model zachytit vztah tím, že se naučí různé hmotnosti pro každý kbelík.

V TensorFlow se to dělá pomocí bucketized_column. Je třeba přidat rozsah hodnot v hranicích.

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

Už víte, že věk je nelineární s příjmem. Dalším způsobem, jak zlepšit model, je interakce. Slovem TensorFlow je to překračování funkcí. Křížení prvků je způsob, jak vytvořit nové prvky, které jsou kombinacemi stávajících, což může být užitečné pro lineární klasifikátor, který nemůže modelovat interakce mezi prvky.

Věk můžete rozdělit pomocí další funkce, jako je vzdělání. To znamená, že některé skupiny budou mít pravděpodobně vysoký příjem a jiné nízké (Přemýšlejte o doktorandovi).

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

Chcete-li vytvořit sloupec křížového prvku, použijte crossed_column s proměnnými pro křížení v závorce. Hash_bucket_size označuje maximální možnosti křížení. Chcete-li vytvořit interakci mezi proměnnými (alespoň jedna proměnná musí být kategorická), můžete použít tf.feature_column.crossed_column. Chcete-li použít tento objekt, musíte do hranatých závorek přidat proměnnou pro interakci a druhý argument, velikost segmentu. Velikost segmentu je maximální možný počet skupin v rámci proměnné. Zde to nastavíte na 1000, protože neznáte přesný počet skupin

age_buckets je třeba před přidáním do sloupců funkce odmocnit. Také přidáte nové funkce do sloupců funkcí a připravíte odhad

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ýstup

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)

Jste připraveni odhadnout nový model a zjistit, zda zlepší přesnost.

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}

Nová úroveň přesnosti je 83.58 procenta. Je o čtyři procenta vyšší než u předchozího modelu.

Nakonec můžete přidat termín regularizace, abyste zabránili nadměrnému vybavení.

Krok 5) Hyperparametr:Lasso & Ridge

Váš model může trpět přepastování or podvybavení.

Overfitting: Model není schopen zobecnit předpověď na nová data
Underfitting: Model není schopen zachytit vzor dat. tj. lineární regrese, když jsou data nelineární

Když má model mnoho parametrů a relativně malé množství dat, vede to ke špatným předpovědím. Představte si, že jedna skupina má pouze tři pozorování; model vypočítá váhu pro tuto skupinu. Váha se používá k předpovědi; pokud jsou pozorování testovací sady pro tuto konkrétní skupinu zcela odlišná od trénovací sady, pak model provede špatnou předpověď. Během hodnocení pomocí trénovací sady je přesnost dobrá, ale není dobrá u testovací sady, protože vypočítané váhy neodpovídají skutečnému zobecnění vzoru. V tomto případě neprovádí rozumnou předpověď na neviditelná data.

Aby se zabránilo nadměrnému vybavení, regularizace vám dává možnost kontrolovat takovou složitost a učinit ji více zobecnitelnou. Existují dvě regularizační techniky:

L1: Laso
L2: Hřeben

V TensorFlow můžete tyto dva hyperparametry přidat v optimalizátoru. Například čím vyšší je hyperparametr L2, váha má tendenci být velmi nízká a blízká nule. Proložená čára bude velmi plochá, zatímco L2 blízko nule znamená, že váhy jsou blízké běžné lineární regresi.

Můžete si sami vyzkoušet různé hodnoty hyperparametrů a zjistit, zda můžete zvýšit úroveň přesnosti.

Hodnocení že pokud změníte hyperparametr, musíte smazat složku probíhající/vlak4, jinak se model spustí s dříve trénovaným modelem.

Podívejme se, jaká je přesnost s humbukem

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ýstup

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ýstup

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ýstup

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}

S tímto hyperparametrem mírně zvyšujete metriky přesnosti. Níže uvedená tabulka shromažďuje všechny metriky hlášené čtyřmi voláními metody evaluate v tomto tutoriálu.

Model	Sada funkcí	Přesnost	AUC	Přesnost	Odvolání
model	Základní kontinuální + kategorický	0.7615626	0.63300294	0.49401596	0.38637546
model_1	Výchozí hodnota plus druhá mocnina věku	0.7944229	0.6093755	0.6682401	0.2576703
model_imp	Věk rozdělený do skupin plus přeškrtnuté sloupce	0.8358209	0.88401634	0.68986726	0.55408216
model_regu	Zkřížené sloupy plus L1 a L2	0.83833915	0.8869794	0.69720596	0.5579823

Všimněte si, že základní přesnost modelu, který vždy predikuje většinovou třídu, je 0.76377374, takže pouze poslední dva modely překonaly triviální odhad s užitečnou rezervou.

V dalším tutoriálu se naučíte, jak vylepšit lineární klasifikátor pomocí metoda jádra.

Nejčastější dotazy

Logistická regrese je jeden druh lineárního klasifikátoru. Provede fitování lineárního skóre a poté ho promíchají přes sigmoid, aby vrátily kalibrované pravděpodobnosti. Jiné lineární klasifikátory, jako například lineární SVM nebo perceptron, sdílejí lineární hranici, ale optimalizují jinou ztrátu.

Lineární SVM optimalizuje ztrátu pantů a pouze okrajové body ovlivňují hranici, což pomáhá u malých, zašumených datových sad. Logistická regrese se rychleji trénuje na velmi velkých datech a vrací odhady pravděpodobnosti, které jsou důležité, když potřebujete laditelný rozhodovací práh.

Ne. Balíček tf-estimator byl v poslední verzi dodán spolu s TensorFlow 2.15 a od verze 2.16 a novější chybí. Spusťte tento tutoriál na TensorFlow 1.x nebo migrujte předpřipravený odhad do lineárního modelu Keras pomocí oficiálního průvodce migrací.

Automatizované vyhledávací knihovny považují L1, L2, rychlost učení a hranice segmentů za vyhledávací prostor a poté používají Bayesovskou optimalizaci nebo metody banditů k včasnému odstranění slabých pokusů. To nahrazuje ruční procházení, které tento tutoriál navrhuje, a obvykle najde lepší regularizační pár.

Copilot rychle vytváří opakující se standardizované verze feature_column, včetně seznamů s comprehenzí přes souvislé sloupce a bloky s kříženými sloupci. Výstup považujte za první návrh – ověřte každý název API oproti verzi, kterou spouštíte, protože Copilot kombinuje idiomy TensorFlow 1.x a 2.x.

Nastavuje počet segmentů, do kterých je kategorický sloupec hašován. Příliš malá hodnota způsobí kolizi nesouvisejících kategorií a sdílení váhy; příliš velká hodnota plýtvá pamětí. Nastavte ji pohodlně nad počet jedinečných hodnot, jak to tento tutoriál dělá s 1000.

Přidání druhé mocniny posouvá model směrem k jistější predikci většinové třídy. Přesnost stoupá na 0.6682, zatímco úplnost klesá na 0.2577, což je spíše obvyklý kompromis mezi přesností a úplností u nevyváženého popisku než chyba kódování.

Použijte jádro, pokud třídy neodděluje žádná lineární hranice, a to ani po rozdělení do bucketů a křížení rysů. Jádra implicitně mapují data do vícerozměrného prostoru, ale za cenu pomalejšího trénování a slabší interpretovatelnosti než zde uvedené lineární váhy.

Binární klasifikace TensorFlow: Příklad lineárního klasifikátoru

Co je lineární klasifikátor?

Jak funguje binární klasifikátor?

Lineární model

Logistická funkce

Jak měřit výkon lineárního klasifikátoru?

Přesnost

Matice zmatení

Přesnost a citlivost

Lineární klasifikátor s TensorFlow

Krok 1) Importujte data

Krok 2) Konverze dat

Krok 3) Trénujte klasifikátor

Krok 4) Vylepšete model

Polynomiální člen

Bucketizace a interakce

Krok 5) Hyperparametr:Lasso & Ridge

Nejčastější dotazy

Shrňte tento příspěvek takto:

Přihlaste se k odběru newsletteru