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

Dva nejběžnější kontrolované výukové úkoly 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 kurz je zaměřen na lineární klasifikátor.

Co je Lineární klasifikátor?

Lineární Klasifikátor v strojového učení je metoda pro zjištění třídu objektu na základě jeho vlastností pro statistické klasifikace. 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í. Cílem klasifikace je předpovědět pravděpodobnost každé třídy dané sadou vstupů. Štítek (tj. Závislá proměnná) je diskrétní hodnota, která se nazývá třída.

1. Pokud má popisek pouze dvě třídy, je algoritmus učení Binární klasifikátor.
2. Klasifikátor více tříd řeší štítky s více než dvěma třídami.

Typickým problémem s binární klasifikací je například předpovědět pravděpodobnost, že zákazník provede druhý nákup. Predikce typu zvířete zobrazeného na obrázku je problém s klasifikací více tříd, protože existují více než dvě odrůdy zvířat.

Teoretická část tohoto tutoriálu se primárně zaměřuje na binární třídu. Další informace o výstupní funkci více tříd se dozvíte v budoucím výukovém programu.

V tomto výukovém programu se naučíte

• Co je Lineární klasifikátor?
• Jak funguje binární klasifikátor?
• Jak měřit výkonnost lineárního klasifikátoru?
• Přesnost
• Matice zmatku
• 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
• Krok 5) Hyperparametr: Lasso & Ridge

Jak funguje binární klasifikátor?

V předchozím kurzu jste se naučili, že funkce se skládá ze dvou druhů proměnných, závislé proměnné a sady funkcí (nezávislé proměnné). V lineární regrese 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.

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

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

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

Pravděpodobnost úspěchu se počítá pomocí logistické regrese . Algoritmus vypočítá pravděpodobnost na základě funkce X a předpovídá úspěch, pokud je tato pravděpodobnost vyšší než 50 procent. Více formálně 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, prvků ab zkreslení.

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

• Lineární model
• Logistická funkce

Lineární model

Způsob výpočtu vah již znáte. Váhy se počítají pomocí tečkového součinu: Y je lineární funkce všech prvků x _i . Pokud model nemá funkce, předpověď se rovná zkreslení, b.

Váhy označují směr korelace mezi prvky _xi a štítkem y. Pozitivní korelace zvyšuje pravděpodobnost pozitivní třídy, zatímco negativní korelace vede k pravděpodobnosti blíže k 0 (tj. Negativní třída).

Lineární model vrací pouze reálné číslo, které je v rozporu s mírou pravděpodobnosti rozsahu [0,1]. Logistická funkce je nutná pro převod 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.

Příklad logistické funkce

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

Klasifikátor může transformovat pravděpodobnost do třídy

• Hodnoty mezi 0 a 0,49 se stanou třídou 0
• Hodnoty mezi 0,5 a 1 se stávají třídou 1

Jak měřit výkonnost 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 dě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ů.

Změřte výkon lineárního klasifikátoru pomocí metriky Přesnost

S touto metrikou můžete zaznamenat nedostatek, zejména u třídy nevyváženosti. Datová sada nerovnováhy nastane, když počet pozorování na skupinu není stejný. Řekněme; pokusíte se klasifikovat vzácnou událost pomocí logistické funkce. Představte si, že se klasifikátor pokouší odhadnout smrt pacienta po nemoci. Podle údajů zemřelo 5 procent pacientů. Můžete trénovat klasifikátor tak, aby předpovídal počet úmrtí, a pomocí metriky přesnosti vyhodnotit výkony. Pokud klasifikátor předpovídá 0 úmrtí pro celou datovou sadu, bude to správné v 95 procentech případu.

Matice zmatku

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

Změřte výkon lineárního klasifikátoru pomocí matice Confusion

Matice zmatku vizualizuje přesnost klasifikátoru porovnáním skutečných a předpovězených tříd, jak je znázorněno ve výše uvedeném příkladu lineárního klasifikátoru. Matice binárního zmatku se skládá ze čtverců:

• TP: True Positive: Předpovězené hodnoty správně předpovídané jako skutečné kladné hodnoty
• FP: Předpokládané hodnoty nesprávně předpovídaly skutečné kladné hodnoty. tj. záporné hodnoty předpovídané jako pozitivní
• FN: False Negative: Kladné hodnoty předpovídané jako negativní
• TN: True Negative: Předpovězené hodnoty správně předpovězené jako skutečné záporné hodnoty

Z matice zmatků je snadné porovnat skutečnou třídu a předpovězenou třídu.

Přesnost a citlivost

Matice zmatku poskytuje dobrý pohled na skutečně pozitivní a falešně pozitivní. V některých případech je lepší mít stručnější metriku.

Přesnost

Přesná metrika ukazuje přesnost kladné třídy. Měří, jak pravděpodobná 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 Recall. Vyvolání se také nazývá citlivost nebo skutečná kladná rychlost.

Citlivost

Citlivost počítá poměr správně detekovaných pozitivních tříd. Tato metrika udává, jak dobrý je model pro rozpoznání pozitivní třídy.

Lineární klasifikátor s TensorFlow

V tomto kurzu použijeme datovou sadu sčítání lidu. Účelem je použít proměnné v datovém souboru sčítání k předpovědi úrovně příjmů. 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ý
• obsazení
• vztah
• závod
• sex
• rodná země

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

• stáří
• fnlwgt
• education_num
• kapitálový zisk
• capital_loss
• hours_week

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

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 tfimport pandas as pd 

Dále importujete data z archivu UCI a definujete názvy sloupců. Sloupce použijete k pojmenování sloupců v datovém rámci pandy.

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

## Define path dataCOLUMNS = ['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 zkušební 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 pozorování a zkušební souprava 16 281

print(df_train.shape, df_test.shape)print(df_train.dtypes)(32561, 15) (16281, 15)age int64workclass objectfnlwgt int64education objecteducation_num int64marital objectoccupation objectrelationship objectrace objectsex objectcapital_gain int64capital_loss int64hours_week int64native_country objectlabel objectdtype: object

Tensorflow vyžaduje pro trénování klasifikátoru logickou hodnotu. Musíte přetypovat hodnoty z řetězce na celé číslo. Štítek je uložen jako objekt, je však nutné jej převést na číselnou hodnotu. Níže uvedený kód vytvoří slovník s hodnotami, které se mají převést a vytvořit smyčku nad položkou sloupce. Všimněte si, že tuto operaci provedete dvakrát, jeden pro zkoušku vlaku, druhý 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 údajích o vlaku je 24 720 příjmů nižších než 50 000 a výše 7841. Poměr je u testovací sady téměř stejný. Další informace najdete v tomto výukovém programu Facety.

print(df_train["label"].value_counts())### The model will be correct in atleast 70% of the caseprint(df_test["label"].value_counts())## Unbalanced labelprint(df_train.dtypes)0 247201 7841Name: label, dtype: int640 124351 3846Name: label, dtype: int64age int64workclass objectfnlwgt int64education objecteducation_num int64marital objectoccupation objectrelationship objectrace objectsex objectcapital_gain int64capital_loss int64hours_week int64native_country objectlabel int64dtype: object

Krok 2) Konverze dat

Než trénujete lineární klasifikátor pomocí Tensorflow, je zapotřebí několik kroků. Musíte si připravit funkce, které chcete zahrnout do modelu. V referenční regresi použijete původní data bez použití jakékoli transformace.

Pro vycvičení modelu musí mít odhadce seznam funkcí. Data sloupce tedy musí být převedena na tenzor.

Dobrým postupem je definovat dva seznamy funkcí na základě jejich typu a poté je předat do feature_columns odhadce.

Začnete převodem spojitých funkcí a poté definujete segment s kategorickými daty.

Vlastnosti 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 listCONTI_FEATURES = ['age', 'fnlwgt','capital_gain', 'education_num', 'capital_loss', 'hours_week']### Define the categorical listCATE_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řevádíte všechny proměnné z CONTI_FEATURES na tenzor s číselnou hodnotou. To je povinné 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. Převedenou hodnotu pro věk vytiskneme. Je to pro účely vysvětlení, proto není nutné rozumět kódu pythonu. K pochopení kódů můžete nahlédnout do oficiální dokumentace.

def print_transformation(feature = "age", continuous = True, size = 2):#X = fc.numeric_column(feature)## Create feature namefeature_names = [feature]## Create dict with the datad = dict(zip(feature_names, [df_train[feature]]))## Convert ageif 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 valueinput_layer = tf.feature_column.input_layer(features=d,feature_columns=feature_columns)## Create lookup tablezero = tf.constant(0, dtype=tf.float32)where = tf.not_equal(input_layer, zero)## Return lookup tbleindices = tf.where(where)values = tf.gather_nd(input_layer, indices)## Initiate graphsess = tf.Session()## Print valueprint(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 převodu kategorických dat. Pokud je seznam slovíček funkce znám a nemá mnoho hodnot, je možné vytvořit kategorický sloupec s kategorickým_sloupcem_s_vocabulary_listem. Přiřadí každému jedinečnému seznamu slovníků ID.

Například pokud má stav proměnné tři odlišné hodnoty:

• Manžel
• Manželka
• Singl

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

Pro ilustraci můžete tento kód použít k převodu proměnné objektu na kategorický sloupec v TensorFlow.

Celovečerní sex může mít pouze dvě hodnoty: mužský nebo ženský. Když převedeme hraný sex, Tensorflow vytvoří 2 nové sloupce, jeden pro muže a jeden pro ženy. Pokud je pohlaví stejné jako muž, bude nový sloupec mužský rovno 1 a ženský 0. Tento příklad je zobrazen v následující tabulce:

řádky	sex	po transformaci	mužský	ženský
1	mužský	=>	1	0
2	mužský	=>	1	0
3	ženský	=>	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 přidali kód Pythonu pro tisk kódování. Opět nemusíte kódu rozumět, účelem je vidět transformaci

Rychlejší způsob, jak transformovat data, je však použít metodu categorical_column_with_hash_bucket. Bude užitečné měnit proměnné řetězce v řídké matici. Řídká matice je matice s většinou nulou. Metoda se postará o všechno. Musíte pouze určit počet segmentů a sloupec klíče. Počet segmentů je maximální počet skupin, které může Tensorflow vytvořit. Sloupec klíče 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 lineární regrese, kromě jednoho argumentu n_class. Musíte definovat sloupec prvků, adresář modelů a porovnat je 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':, '_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 definován klasifikátor, můžete vytvořit vstupní funkci. Metoda je stejná jako v kurzu lineárního regresoru. Zde použijete velikost dávky 128 a zamícháte data.

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 odhadcem, tj. Počet epoch, počet dávek a zamícháte datovou sadu nebo poznámku. Vzhledem k tomu, že k předání dat do modelu používáte metodu Pandas, musíte definovat proměnné X jako datový rámec pandas. Všimněte si, že procházíte všemi daty uloženými ve FUNKCÍCH.

Pojďme trénovat model s objektem model.train. Pomocí dříve definované funkce můžete model napájet příslušnými hodnotami. Všimněte si, že jste nastavili velikost dávky na 128 a počet epoch na Žádná. Model bude proškolen na 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 = 1INFO:tensorflow:global_step/sec: 65.8282INFO:tensorflow:loss = 52583.64, step = 101 (1.528 sec)INFO:tensorflow:global_step/sec: 118.386INFO:tensorflow:loss = 25203.816, step = 201 (0.837 sec)INFO:tensorflow:global_step/sec: 110.542INFO:tensorflow:loss = 54924.312, step = 301 (0.905 sec)INFO:tensorflow:global_step/sec: 199.03INFO:tensorflow:loss = 68509.31, step = 401 (0.502 sec)INFO:tensorflow:global_step/sec: 167.488INFO:tensorflow:loss = 9151.754, step = 501 (0.599 sec)INFO:tensorflow:global_step/sec: 220.155INFO:tensorflow:loss = 34576.06, step = 601 (0.453 sec)INFO:tensorflow:global_step/sec: 199.016INFO:tensorflow:loss = 36047.117, step = 701 (0.503 sec)INFO:tensorflow:global_step/sec: 197.531INFO:tensorflow:loss = 22608.148, step = 801 (0.505 sec)INFO:tensorflow:global_step/sec: 208.479INFO: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.

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 jedné iteraci je 5444. Svůj model můžete odhadnout na testovací sadě a zobrazit výkon. Chcete-li vyhodnotit výkon vašeho modelu, musíte použít vyhodnocení objektu. Nakrmíte model testovací sadou a nastavíte počet epoch na 1, tj. Data se do modelu dostanou 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:22INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from ongoing/train/model.ckpt-1000INFO: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:23INFO: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 si model vede 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., Pak má model přesnost 70 procent. Při bližší analýze můžete vidět, že predikce a vyvolání jsou poměrně nízké.

Krok 4) Vylepšete model

Nyní, když máte srovnávací model, můžete se ho pokusit vylepšit, to znamená zvýšit přesnost. V předchozím kurzu jste se naučili, jak zlepšit sílu predikce pomocí termínu interakce. V tomto kurzu se k této myšlence vrátíte přidáním polynomického výrazu k regresi.

Polynomiální regrese je instrumentální, když v datech není nelinearita. Existují dva způsoby, jak zachytit nelinearitu v datech.

• Přidejte polynomiální výraz
• Spojte spojitou proměnnou do kategorické proměnné

Polynomiální člen

Na následujícím obrázku můžete vidět, co je polynomiální regrese. Je to rovnice s X proměnnými s různým výkonem. 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 ³

Co je polynomiální regrese

Níže jsme sestrojili 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 vzor (levý obrázek).

Podívejme se nyní na levý obrázek z obrázku níže a do regrese jsme přidali pětičlenný termín (tj. Y = x + x ² + x ³ + x ⁴ + x ⁵⁾ . Model nyní lépe vystihuje vzor. 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 by mohl mít plochý příjem blízký nule, protože děti nebo mladí lidé nepracují. Poté se zvyšuje v produktivním věku a klesá během důchodu. Je to obvykle tvar obráceného U. Jedním ze způsobů, jak tento vzor zachytit, je přidání síly dva k regresi.

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

Tuto novou funkci musíte přidat do datové sady a do seznamu nepřetržité funkce.

Do vlaku přidáte novou proměnnou a otestujete datovou sadu, 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éninkovou sadu
• df_te: definujte testovací sadu
• var_name = 'age': Definujte proměnnou, kterou chcete transformovat

Pomocí objektu pow (2) můžete umocnit proměnný věk. Všimněte si, že nová proměnná má název „nová“

Nyní, když je napsána funkce square_var, 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á sada 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á nová. Musíte jej přidat do seznamu nepřetržitý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]

Všimněte si, že jste změnili adresář Graph. Nemůžete trénovat různé modely ve stejném adresáři. To znamená, že musíte změnit cestu argumentu model_dir. Pokud to neuděláte, TensorFlow způsobí 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':, '_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 trénovat a vyhodnotit model.

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 = 1INFO:tensorflow:global_step/sec: 81.487INFO:tensorflow:loss = 70077.66, step = 101 (1.228 sec)INFO:tensorflow:global_step/sec: 111.169INFO:tensorflow:loss = 49522.082, step = 201 (0.899 sec)INFO:tensorflow:global_step/sec: 128.91INFO:tensorflow:loss = 107120.57, step = 301 (0.776 sec)INFO:tensorflow:global_step/sec: 132.546INFO:tensorflow:loss = 12814.152, step = 401 (0.755 sec)INFO:tensorflow:global_step/sec: 162.194INFO:tensorflow:loss = 19573.898, step = 501 (0.617 sec)INFO:tensorflow:global_step/sec: 204.852INFO:tensorflow:loss = 26381.986, step = 601 (0.488 sec)INFO:tensorflow:global_step/sec: 188.923INFO:tensorflow:loss = 23417.719, step = 701 (0.529 sec)INFO:tensorflow:global_step/sec: 192.041INFO:tensorflow:loss = 23946.049, step = 801 (0.521 sec)INFO:tensorflow:global_step/sec: 197.025INFO: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.

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:37INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from ongoing/train1/model.ckpt-1000INFO: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:39INFO: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}

Čtvercová proměnná zlepšila přesnost z 0,76 na 0,79. Podívejme se, jestli můžete dosáhnout lepšího spojení kombinací pojmů bucketizace a interakce.

Bucketizace a interakce

Jak jste viděli dříve, lineární klasifikátor nedokáže správně zachytit vzor věku a příjmu. Je to proto, že se učí jednotlivou váhu pro každou funkci. Aby to bylo pro klasifikátor jednodušší, jednu věc, kterou můžete udělat, je vytvoření funkce. Bucketing transformuje numerický prvek na několik určitých na základě rozsahu, do kterého spadá, a každá z těchto nových funkcí naznačuje, zda věk člověka spadá do tohoto rozsahu.

S těmito novými funkcemi může lineární model zachytit vztah učením různých vah pro každý segment.

V TensorFlow se to provádí pomocí bucketized_column. Musíte přidat rozsah hodnot na hranici.

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 vylepšit model, je interakce. Ve slově TensorFlow jde o křížení funkcí. Křížení prvků je způsob, jak vytvořit nové prvky, které jsou kombinací 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í jiné 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 křížený_sloupec s proměnnými, které se mají křížit v závorce. Hodnota 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 kbelíku. Velikost segmentu je maximální možný počet skupin v rámci proměnné. Zde jej nastavíte na 1000, protože neznáte přesný počet skupin

age_buckets před přidáním do sloupců funkcí musí být na druhou. 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': , '_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šuje 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 = 1INFO:tensorflow:global_step/sec: 94.969INFO:tensorflow:loss = 50.334488, step = 101 (1.054 sec)INFO:tensorflow:global_step/sec: 242.342INFO:tensorflow:loss = 56.153225, step = 201 (0.414 sec)INFO:tensorflow:global_step/sec: 213.686INFO:tensorflow:loss = 45.792007, step = 301 (0.470 sec)INFO:tensorflow:global_step/sec: 174.084INFO:tensorflow:loss = 37.485672, step = 401 (0.572 sec)INFO:tensorflow:global_step/sec: 191.78INFO:tensorflow:loss = 56.48449, step = 501 (0.524 sec)INFO:tensorflow:global_step/sec: 163.436INFO:tensorflow:loss = 32.528934, step = 601 (0.612 sec)INFO:tensorflow:global_step/sec: 164.347INFO:tensorflow:loss = 37.438057, step = 701 (0.607 sec)INFO:tensorflow:global_step/sec: 154.274INFO:tensorflow:loss = 61.1075, step = 801 (0.647 sec)INFO:tensorflow:global_step/sec: 189.14INFO: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.

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:52INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from ongoing/train3/model.ckpt-1000INFO: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:54INFO: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 regularizační výraz, který zabrání přeplnění.

Krok 5) Hyperparametr: Lasso & Ridge

Váš model může trpět nadměrným nebo nedostatečným vybavením .

• 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í

Pokud má model spoustu parametrů a relativně nízké 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 se pozorování testovací sady pro tuto konkrétní skupinu zcela liší od tréninkové sady, pak model provede špatnou předpověď. Během vyhodnocení pomocí tréninkové sady je přesnost dobrá, ale u testovací sady není dobrá, protože vypočtené váhy nejsou správné pro zobecnění vzoru. V tomto případě neprovede rozumnou předpověď na neviditelných datech.

Aby se zabránilo nadměrnému vybavování, regularizace vám dává možnosti ovládat takovou složitost a zobecnit ji. Existují dvě techniky regularizace:

• L1: Laso
• L2: Ridge

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

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

Všimněte si, že pokud změníte hyperparametr, musíte odstranit složku probíhající / train4, jinak bude model začínat 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))

OUPUT

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': , '_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)

OUPUT

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 = 1INFO:tensorflow:global_step/sec: 77.4165INFO:tensorflow:loss = 50.38778, step = 101 (1.294 sec)INFO:tensorflow:global_step/sec: 187.889INFO:tensorflow:loss = 55.38014, step = 201 (0.535 sec)INFO:tensorflow:global_step/sec: 201.895INFO:tensorflow:loss = 46.806694, step = 301 (0.491 sec)INFO:tensorflow:global_step/sec: 217.992INFO:tensorflow:loss = 38.68271, step = 401 (0.460 sec)INFO:tensorflow:global_step/sec: 193.676INFO:tensorflow:loss = 56.99398, step = 501 (0.516 sec)INFO:tensorflow:global_step/sec: 202.195INFO:tensorflow:loss = 33.263622, step = 601 (0.497 sec)INFO:tensorflow:global_step/sec: 216.756INFO:tensorflow:loss = 37.7902, step = 701 (0.459 sec)INFO:tensorflow:global_step/sec: 240.215INFO:tensorflow:loss = 61.732605, step = 801 (0.416 sec)INFO:tensorflow:global_step/sec: 220.336INFO: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.

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:07INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from ongoing/train4/model.ckpt-1000INFO: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:09INFO: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ě zvýšíte metriky přesnosti. V dalším kurzu se naučíte, jak vylepšit lineární klasifikátor pomocí metody jádra.

souhrn

Chcete-li trénovat model, musíte:

• Definujte funkce: Nezávislé proměnné: X
• Definujte štítek: Závislá proměnná: y
• Postavte vlak / testovací soupravu
• Definujte počáteční hmotnost
• Definujte funkci ztráty: MSE
• Optimalizujte model: Sestupný sklon
• Definovat:
  • Míra učení
  • Počet epoch
  • Objem várky
  • Číslo třídy

V tomto kurzu jste se naučili, jak používat rozhraní API na vysoké úrovni pro klasifikátor lineární regrese. Musíte definovat:

1. Sloupce prvků. Pokud je průběžné: tf.feature_column.numeric_column (). Seznam můžete naplnit porozuměním seznamu pythonu
2. Odhad: tf.estimator.LinearClassifier (feature_columns, model_dir, n_classes = 2)
3. Funkce pro import dat, velikosti dávky a epochy: input_fn ()

Poté jste připraveni trénovat, hodnotit a předpovídat pomocí train (), evalu () a predikovat ()

Chcete-li zlepšit výkon modelu, můžete:

• Použijte polynomiální regrese
• Termín interakce: tf.feature_column.crossed_column
• Přidejte parametr regularizace