Gaussovské jadro v strojovom učení: Príklady metód jadra

Obsah:

Anonim

Účelom tohto tutoriálu je vytvoriť lineárne oddeliteľnú množinu údajov. Výukový program je rozdelený do dvoch častí:

  1. Transformácia funkcií
  2. Vycvičte si klasifikátor jadra pomocou Tensorflow

V prvej časti pochopíte myšlienku jadrovej metódy v strojovom učení, zatiaľ čo v druhej časti uvidíte, ako trénovať klasifikátor jadra pomocou Tensorflow. Použijete dataset pre dospelých. Cieľom tohto súboru údajov je klasifikovať príjmy do 50 000, s vedomím správania sa každej domácnosti.

V tomto návode sa naučíte

  • Prečo potrebujete metódy jadra?
  • Čo je to jadro v strojovom učení?
  • Typy jadrových metód
  • Trénujte klasifikátor gaussovského jadra pomocou TensorFlow

Prečo potrebujete metódy jadra?

Cieľom každého klasifikátora je správne predpovedať triedy. Preto by mal byť súbor údajov oddeliteľný. Pozri sa na dej nižšie; je celkom jednoduché vidieť, že všetky body nad čiernou čiarou patria do prvej triedy a ostatné body do druhej triedy. Je však mimoriadne zriedkavé mať taký jednoduchý súbor údajov. Vo väčšine prípadov sa údaje nedajú oddeliť. Metódy jadra v strojovom učení dávajú naivným klasifikátorom ako logistická regresia ťažkosti.

import numpy as npimport matplotlib.pyplot as pltfrom mpl_toolkits.mplot3d import Axes3D 
x_lin = np.array([1,2,3,4,5,6,7,8,9,10])y_lin = np.array([2,2,3,2,2,9,6,8,8,9])label_lin = np.array([0,0,0,0,0,1,1,1,1,1])fig = plt.figure()ax=fig.add_subplot(111)plt.scatter(x_lin, y_lin, c=label_lin, s=60)plt.plot([-2.5, 10], [12.5, -2.5], 'k-', lw=2)ax.set_xlim([-5,15])ax.set_ylim([-5,15])plt.show()

Na obrázku nižšie vykresľujeme množinu údajov, ktorá nie je lineárne oddeliteľná. Ak nakreslíme priamku, väčšina bodov nebude klasifikovaná v správnej triede.

Jedným zo spôsobov riešenia tohto problému je zobrať množinu údajov a transformovať údaje na inú mapu funkcií. To znamená, že použijete funkciu na transformáciu údajov do iného plánu, ktorý by mal byť lineárny.

x = np.array([1,1,2,3,3,6,6,6,9,9,10,11,12,13,16,18])y = np.array([18,13,9,6,15,11,6,3,5,2,10,5,6,1,3,1])label = np.array([1,1,1,1,0,0,0,1,0,1,0,0,0,1,0,1]) 
fig = plt.figure()plt.scatter(x, y, c=label, s=60)plt.show()

Údaje z vyššie uvedeného obrázku sú v 2D gaussovskom jadre, ktoré nie je možné oddeliť. Môžete sa pokúsiť tieto údaje transformovať v trojrozmernom tvare, to znamená, že vytvoríte figúru s 3 osami.

V našom príklade s Gaussovským jadrom použijeme polynomické mapovanie, aby sme naše údaje dostali do 3D dimenzie. Vzorec na transformáciu údajov je nasledovný.

V Gaussian Kernel Python definujete funkciu na vytvorenie nových máp funkcií

Môžete použiť numpy na kódovanie vyššie uvedeného vzorca:

Vzorec Ekvivalentný číselný kód
X x [:, 0] **
r x [:, 1]
x 2 x [:, 0] ** 2
np.sqrt (2) *
xy x [:, 0] * x [:, 1]
y 2 x [:, 1] ** 2 
### illustration purposedef mapping(x, y):x = np.c_[(x, y)]if len(x) > 2:x_1 = x[:,0]**2x_2 = np.sqrt(2)*x[:,0]*x[:,1]x_3 = x[:,1]**2else:x_1 = x[0]**2x_2 = np.sqrt(2)*x[0]*x[1]x_3 = x[1]**2trans_x = np.array([x_1, x_2, x_3])return trans_x

Nové mapovanie by malo mať 3 rozmery a 16 bodov

x_1 = mapping(x, y)x_1.shape 
(3, 16)

Vytvorme nový graf s 3 osami, x, yaz.

# plotfig = plt.figure()ax = fig.add_subplot(111, projection='3d')ax.scatter(x_1[0], x_1[1], x_1[2], c=label, s=60)ax.view_init(30, 185)ax.set_xlabel('X Label')ax.set_ylabel('Y Label')ax.set_zlabel('Z Label')plt.show()

Vidíme zlepšenie, ale ak zmeníme orientáciu grafu, je zrejmé, že množinu údajov je teraz možné oddeliť

# plotfig = plt.figure()ax = fig.add_subplot(111, projection='3d')ax.scatter(x_1[0], x_1[1], x_1[1], c=label, s=60)ax.view_init(0, -180)ax.set_ylim([150,-50])ax.set_zlim([-10000,10000])ax.set_xlabel('X Label')ax.set_ylabel('Y Label')ax.set_zlabel('Z Label')plt.show()

Ak chcete manipulovať s veľkým súborom údajov a možno budete musieť vytvoriť viac ako 2 dimenzie, pomocou vyššie uvedenej metódy budete čeliť veľkým problémom. V skutočnosti musíte transformovať všetky údajové body, čo zjavne nie je udržateľné. Bude to trvať veky a váš počítač môže vyčerpať pamäť.

Najbežnejším spôsobom, ako prekonať tento problém, je použitie jadra .

Čo je to jadro v strojovom učení?

Cieľom je využiť priestor funkcií s vyššou dimenziou, aby boli údaje takmer lineárne oddeliteľné, ako je to znázornené na obrázku vyššie.

Existuje veľa priestorov vyšších dimenzií, aby boli dátové body oddeliteľné. Napríklad sme ukázali, že polynomické mapovanie je skvelým začiatkom.

Tiež sme preukázali, že pri mnohých údajoch nie je táto transformácia efektívna. Namiesto toho môžete použiť funkciu jadra v strojovom učení na úpravu údajov bez zmeny na nový plán funkcií.

Kúzlom jadra je nájsť funkciu, ktorá zabráni všetkým problémom spojeným s vysokodimenzionálnym výpočtom. Výsledkom jadra je skalár, alebo inak povedané, sme späť v jednorozmernom priestore

Keď nájdete túto funkciu, môžete ju pripojiť k štandardnému lineárnemu klasifikátoru.

Pozrime sa na príklad na pochopenie konceptu strojového učenia jadra. Máte dva vektory, x1 a x2. Cieľom je vytvoriť vyššiu dimenziu pomocou polynomiálneho mapovania. Výstup sa rovná bodovému súčinu novej mapy funkcií. Z vyššie uvedenej metódy musíte:

  1. Transformujte x1 a x2 do novej dimenzie
  2. Vypočítajte bodový produkt: spoločný pre všetky jadrá
  3. Transformujte x1 a x2 do novej dimenzie

Pomocou funkcie vytvorenej vyššie môžete vypočítať vyššiu dimenziu.

## Kernelx1 = np.array([3,6])x2 = np.array([10,10])x_1 = mapping(x1, x2)print(x_1)

Výkon

[[ 9. 100. ][ 25.45584412 141.42135624][ 36. 100. ]]

Vypočítajte bodový súčin

Objektovú bodku od numpy môžete použiť na výpočet bodového súčinu medzi prvým a druhým vektorom uloženým v x_1.

print(np.dot(x_1[:,0], x_1[:,1]))8100.0

Výstup je 8100. Vidíte problém, musíte vypočítať bodový produkt a uložiť tak do pamäte novú mapu funkcií. Ak máte súbor údajov s miliónmi záznamov, je to výpočtovo neefektívne.

Namiesto toho môžete pomocou polynomického jadra vypočítať bodový produkt bez transformácie vektora. Táto funkcia počíta bodový súčin x1 a x2, akoby sa tieto dva vektory transformovali do vyššej dimenzie. Povedané inak, funkcia jadra počíta výsledky bodového produktu z iného priestoru funkcií.

Funkciu polynomiálneho jadra môžete v Pythone napísať nasledovne.

def polynomial_kernel(x, y, p=2):return (np.dot(x, y)) ** p

Je to sila bodového súčinu dvoch vektorov. Nižšie vrátite druhý stupeň polynomiálneho jadra. Výstup sa rovná inej metóde. To je kúzlo jadra.

polynomial_kernel(x1, x2, p=2)8100

Typy jadrových metód

Existuje veľa rôznych techník jadra. Najjednoduchšie je lineárne jadro. Táto funkcia funguje pri klasifikácii textu veľmi dobre. Druhé jadro je:

  • Polynomické jadro
  • Gaussovo jadro

V príklade s TensorFlow použijeme Random Fourier. TensorFlow má zabudovaný odhadovač na výpočet priestoru nových funkcií. Funkcia Gaussovho filtra je aproximáciou funkcie Gaussovho jadra.

Funkcia Gaussovej filtrácie počíta podobnosť medzi údajovými bodmi v oveľa vyššom dimenzionálnom priestore.

Trénujte klasifikátor gaussovského jadra pomocou TensorFlow

Cieľom algoritmu je klasifikovať domácnosti zarábajúce viac alebo menej ako 50 tis.

Logistické jadro regresné strojové učenie vyhodnotíte, aby ste mali referenčný model. Potom nacvičíte klasifikátor jadra, aby ste zistili, či môžete dosiahnuť lepšie výsledky.

Používate nasledujúce premenné z množiny údajov pre dospelých:

  • Vek
  • pracovná trieda
  • fnlwgt
  • vzdelanie
  • vzdelanie_počet
  • manželský
  • okupácia
  • vzťah
  • rasa
  • pohlavie
  • kapitálový zisk
  • capital_loss
  • hours_week
  • rodná krajina
  • štítok

Pred trénovaním a vyhodnotením modelu budete postupovať nasledovne:

  • Krok 1) Importujte knižnice
  • Krok 2) Importujte údaje
  • Krok 3) Pripravte údaje
  • Krok 4) Vytvorte input_fn
  • Krok 5) Vytvorte logistický model: základný model
  • Krok 6) Vyhodnoťte model
  • Krok 7) Vytvorte klasifikátor jadra
  • Krok 8) Vyhodnoťte klasifikátor jadra

Krok 1) Importujte knižnice

Ak chcete importovať a trénovať modely jadra v umelej inteligencii, musíte importovať tensorflow, pandy a numpy

#import numpy as npfrom sklearn.model_selectionimport train_test_splitimport tensorflow as tfimport pandas as pdimport numpy as np

Krok 2) Importujte údaje

Stiahnete údaje z nasledujúcej webovej stránky a naimportujete ich ako dátový rámec panda.

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

Teraz, keď sú vlak a testovacia sada definované, môžete zmeniť štítok stĺpca z reťazca na celé číslo. tensorflow neprijíma hodnotu reťazca pre štítok.

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]df_train.shape(32561, 15)

Krok 3) Pripravte údaje

Dataset obsahuje nepretržité aj kategorické funkcie. Osvedčeným postupom je štandardizácia hodnôt spojitých premenných. Môžete použiť funkciu StandardScaler zo sci-kit learn. Vytvoríte tiež užívateľom definovanú funkciu, aby ste uľahčili prevod vlaku a testovacej súpravy. Upozorňujeme, že spojíte spojité a kategorické premenné do spoločného súboru údajov a pole by malo byť typu: float32

COLUMNS_INT = ['age','fnlwgt','education_num','capital_gain', 'capital_loss', 'hours_week']CATE_FEATURES = ['workclass', 'education', 'marital', 'occupation', 'relationship', 'race', 'sex', 'native_country']from sklearn.preprocessing import StandardScalerfrom sklearn import preprocessingdef prep_data_str(df):scaler = StandardScaler()le = preprocessing.LabelEncoder()df_toscale = df[COLUMNS_INT]df_scaled = scaler.fit_transform(df_toscale.astype(np.float64))X_1 = df[CATE_FEATURES].apply(le.fit_transform)y = df['label'].astype(np.int32)X_conc = np.c_[df_scaled, X_1].astype(np.float32)return X_conc, y

Funkcia transformátora je pripravená, môžete previesť množinu údajov a vytvoriť funkciu input_fn.

X_train, y_train = prep_data_str(df_train)X_test, y_test = prep_data_str(df_test)print(X_train.shape)(32561, 14)

V ďalšom kroku si nacvičíte logistickú regresiu. Poskytne vám základnú presnosť. Cieľom je prekonať základnú čiaru iným algoritmom, konkrétne klasifikátorom jadra.

Krok 4) Vytvorte logistický model: základný model

Stĺpec prvku skonštruujete z objektu real_valued_column. Zabezpečí, aby všetky premenné obsahovali husté číselné údaje.

feat_column = tf.contrib.layers.real_valued_column('features', dimension=14)

Odhad je definovaný pomocou nástroja TensorFlow Estimator, dávate pokyny stĺpcom funkcií a kam graf uložiť.

estimator = tf.estimator.LinearClassifier(feature_columns=[feat_column],n_classes=2,model_dir = "kernel_log")
INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'kernel_log', '_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}

Regresiu logisitcu budete trénovať pomocou minidávok veľkosti 200.

# Train the modeltrain_input_fn = tf.estimator.inputs.numpy_input_fn(x={"features": X_train},y=y_train,batch_size=200,num_epochs=None,shuffle=True)

Môžete trénovať model s 1 000 iteráciami

estimator.train(input_fn=train_input_fn, 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 kernel_log/model.ckpt.INFO:tensorflow:loss = 138.62949, step = 1INFO:tensorflow:global_step/sec: 324.16INFO:tensorflow:loss = 87.16762, step = 101 (0.310 sec)INFO:tensorflow:global_step/sec: 267.092INFO:tensorflow:loss = 71.53657, step = 201 (0.376 sec)INFO:tensorflow:global_step/sec: 292.679INFO:tensorflow:loss = 69.56703, step = 301 (0.340 sec)INFO:tensorflow:global_step/sec: 225.582INFO:tensorflow:loss = 74.615875, step = 401 (0.445 sec)INFO:tensorflow:global_step/sec: 209.975INFO:tensorflow:loss = 76.49044, step = 501 (0.475 sec)INFO:tensorflow:global_step/sec: 241.648INFO:tensorflow:loss = 66.38373, step = 601 (0.419 sec)INFO:tensorflow:global_step/sec: 305.193INFO:tensorflow:loss = 87.93341, step = 701 (0.327 sec)INFO:tensorflow:global_step/sec: 396.295INFO:tensorflow:loss = 76.61518, step = 801 (0.249 sec)INFO:tensorflow:global_step/sec: 359.857INFO:tensorflow:loss = 78.54885, step = 901 (0.277 sec)INFO:tensorflow:Saving checkpoints for 1000 into kernel_log/model.ckpt.INFO:tensorflow:Loss for final step: 67.79706.

Krok 6) Vyhodnoťte model

Na vyhodnotenie modelu definujete počítadlo odhadov. Na vyhodnotenie použijete celý súbor údajov

# Evaluationtest_input_fn = tf.estimator.inputs.numpy_input_fn(x={"features": X_test},y=y_test,batch_size=16281,num_epochs=1,shuffle=False)estimator.evaluate(input_fn=test_input_fn, steps=1)
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-07-12-15:58:22INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from kernel_log/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Evaluation [1/1]INFO:tensorflow:Finished evaluation at 2018-07-12-15:58:23INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.82353663, accuracy_baseline = 0.76377374, auc = 0.84898686, auc_precision_recall = 0.67214864, average_loss = 0.3877216, global_step = 1000, label/mean = 0.23622628, loss = 6312.495, precision = 0.7362797, prediction/mean = 0.21208474, recall = 0.39417577
{'accuracy': 0.82353663,'accuracy_baseline': 0.76377374,'auc': 0.84898686,'auc_precision_recall': 0.67214864,'average_loss': 0.3877216,'global_step': 1000,'label/mean': 0.23622628,'loss': 6312.495,'precision': 0.7362797,'prediction/mean': 0.21208474,'recall': 0.39417577}

Máte presnosť 82 percent. V nasledujúcej časti sa pokúsite poraziť logistický klasifikátor klasifikátorom jadra

Krok 7) Vytvorte klasifikátor jadra

Odhad jadra sa minimálne od konštrukcie nelíši od tradičného lineárneho klasifikátora. Myšlienkou je použitie sily explicitného jadra s lineárnym klasifikátorom.

Na školenie klasifikátora jadra potrebujete v TensorFlow dva preddefinované odhady:

  • RandomFourierFeatureMapper
  • KernelLinearClassifier

V prvej časti ste sa naučili, že musíte transformovať nízku dimenziu do vysokej dimenzie pomocou funkcie jadra. Presnejšie použijete Random Fourier, čo je aproximácia Gaussovej funkcie. Našťastie má Tensorflow vo svojej knižnici funkciu: RandomFourierFeatureMapper. Model je možné trénovať pomocou odhadcu KernelLinearClassifier.

Pri zostavovaní modelu budete postupovať podľa týchto krokov:

  1. Nastavte funkciu jadra s vysokou dimenziou
  2. Nastavte hyperparameter L2
  3. Postavte model
  4. Trénujte model
  5. Vyhodnoťte model

Krok A) Nastavte funkciu jadra s vysokou dimenziou

Aktuálny súbor údajov obsahuje 14 funkcií, ktoré transformujete na novú vysokú dimenziu 5 000-rozmerného vektora. Na dosiahnutie transformácie použijete náhodné Fourierove funkcie. Ak si spomeniete na vzorec Gaussovho jadra, všimnite si, že je potrebné definovať parameter štandardnej odchýlky. Tento parameter riadi mieru podobnosti použitú počas klasifikácie.

Všetky parametre v RandomFourierFeatureMapper môžete naladiť pomocou:

  • input_dim = 14
  • output_dim = 5 000
  • stddev = 4
### Prep Kernelkernel_mapper = tf.contrib.kernel_methods.RandomFourierFeatureMapper(input_dim=14, output_dim=5000, stddev=4, name='rffm')

Mapovač jadra musíte skonštruovať pomocou stĺpcov funkcií vytvorených predtým: feat_column

### Map Kernelkernel_mappers = {feat_column: [kernel_mapper]}

Krok B) Nastavte hyperparameter L2

Aby ste zabránili preťaženiu, potrestajte funkciu straty regulátorom L2. Nastavili ste hyperparameter L2 na 0,1 a rýchlosť učenia na 5

optimizer = tf.train.FtrlOptimizer(learning_rate=5, l2_regularization_strength=0.1)

Krok C) Zostavte model

Ďalší krok je podobný lineárnej klasifikácii. Používate odhadovač zabudovania KernelLinearClassifier. Upozorňujeme, že pridáte predtým definovaný mapovač jadra a zmeníte adresár modelu.

### Prep estimatorestimator_kernel = tf.contrib.kernel_methods.KernelLinearClassifier(n_classes=2,optimizer=optimizer,kernel_mappers=kernel_mappers,model_dir="kernel_train")
WARNING:tensorflow:From /Users/Thomas/anaconda3/envs/hello-tf/lib/python3.6/site-packages/tensorflow/contrib/kernel_methods/python/kernel_estimators.py:305: multi_class_head (from tensorflow.contrib.learn.python.learn.estimators.head) is deprecated and will be removed in a future version.Instructions for updating:Please switch to tf.contrib.estimator.*_head.WARNING:tensorflow:From /Users/Thomas/anaconda3/envs/hello-tf/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/estimators/estimator.py:1179: BaseEstimator.__init__ (from tensorflow.contrib.learn.python.learn.estimators.estimator) is deprecated and will be removed in a future version.Instructions for updating:Please replace uses of any Estimator from tf.contrib.learn with an Estimator from tf.estimator.*WARNING:tensorflow:From /Users/Thomas/anaconda3/envs/hello-tf/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/estimators/estimator.py:427: RunConfig.__init__ (from tensorflow.contrib.learn.python.learn.estimators.run_config) is deprecated and will be removed in a future version.Instructions for updating:When switching to tf.estimator.Estimator, use tf.estimator.RunConfig instead.INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_task_type': None, '_task_id': 0, '_cluster_spec': , '_master': '', '_num_ps_replicas': 0, '_num_worker_replicas': 0, '_environment': 'local', '_is_chief': True, '_evaluation_master': '', '_train_distribute': None, '_tf_config': gpu_options {per_process_gpu_memory_fraction: 1.0}, '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_secs': 600, '_log_step_count_steps': 100, '_session_config': None, '_save_checkpoints_steps': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_model_dir': 'kernel_train'}

Krok D) Trénujte model

Teraz, keď je klasifikátor jadra zostavený, ste pripravení ho trénovať. Zvolíte iteráciu 2 000-násobku modelu

### estimateestimator_kernel.fit(input_fn=train_input_fn, steps=2000)
WARNING:tensorflow:Casting 
 labels to bool.WARNING:tensorflow:Casting 
 labels to bool.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.WARNING:tensorflow:From /Users/Thomas/anaconda3/envs/hello-tf/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/estimators/head.py:678: ModelFnOps.__new__ (from tensorflow.contrib.learn.python.learn.estimators.model_fn) is deprecated and will be removed in a future version.Instructions for updating:When switching to tf.estimator.Estimator, use tf.estimator.EstimatorSpec. You can use the `estimator_spec` method to create an equivalent one.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 kernel_train/model.ckpt.INFO:tensorflow:loss = 0.6931474, step = 1INFO:tensorflow:global_step/sec: 86.6365INFO:tensorflow:loss = 0.39374447, step = 101 (1.155 sec)INFO:tensorflow:global_step/sec: 80.1986INFO:tensorflow:loss = 0.3797774, step = 201 (1.247 sec)INFO:tensorflow:global_step/sec: 79.6376INFO:tensorflow:loss = 0.3908726, step = 301 (1.256 sec)INFO:tensorflow:global_step/sec: 95.8442INFO:tensorflow:loss = 0.41890752, step = 401 (1.043 sec)INFO:tensorflow:global_step/sec: 93.7799INFO:tensorflow:loss = 0.35700393, step = 501 (1.066 sec)INFO:tensorflow:global_step/sec: 94.7071INFO:tensorflow:loss = 0.35535482, step = 601 (1.056 sec)INFO:tensorflow:global_step/sec: 90.7402INFO:tensorflow:loss = 0.3692882, step = 701 (1.102 sec)INFO:tensorflow:global_step/sec: 94.4924INFO:tensorflow:loss = 0.34746957, step = 801 (1.058 sec)INFO:tensorflow:global_step/sec: 95.3472INFO:tensorflow:loss = 0.33655524, step = 901 (1.049 sec)INFO:tensorflow:global_step/sec: 97.2928INFO:tensorflow:loss = 0.35966292, step = 1001 (1.028 sec)INFO:tensorflow:global_step/sec: 85.6761INFO:tensorflow:loss = 0.31254214, step = 1101 (1.167 sec)INFO:tensorflow:global_step/sec: 91.4194INFO:tensorflow:loss = 0.33247527, step = 1201 (1.094 sec)INFO:tensorflow:global_step/sec: 82.5954INFO:tensorflow:loss = 0.29305756, step = 1301 (1.211 sec)INFO:tensorflow:global_step/sec: 89.8748INFO:tensorflow:loss = 0.37943482, step = 1401 (1.113 sec)INFO:tensorflow:global_step/sec: 76.9761INFO:tensorflow:loss = 0.34204718, step = 1501 (1.300 sec)INFO:tensorflow:global_step/sec: 73.7192INFO:tensorflow:loss = 0.34614792, step = 1601 (1.356 sec)INFO:tensorflow:global_step/sec: 83.0573INFO:tensorflow:loss = 0.38911164, step = 1701 (1.204 sec)INFO:tensorflow:global_step/sec: 71.7029INFO:tensorflow:loss = 0.35255936, step = 1801 (1.394 sec)INFO:tensorflow:global_step/sec: 73.2663INFO:tensorflow:loss = 0.31130585, step = 1901 (1.365 sec)INFO:tensorflow:Saving checkpoints for 2000 into kernel_train/model.ckpt.INFO:tensorflow:Loss for final step: 0.37795097.KernelLinearClassifier(params={'head': , 'feature_columns': {_RealValuedColumn(column_name='features_MAPPED', dimension=5000, default_value=None, dtype=tf.float32, normalizer=None)}, 'optimizer': , 'kernel_mappers': {_RealValuedColumn(column_name='features', dimension=14, default_value=None, dtype=tf.float32, normalizer=None): []}})

Krok E) Vyhodnoťte model

V neposlednom rade hodnotíte výkonnosť svojho modelu. Mali by ste byť schopní prekonať logistickú regresiu.

# Evaluate and report metrics.eval_metrics = estimator_kernel.evaluate(input_fn=test_input_fn, steps=1)
WARNING:tensorflow:Casting 
 labels to bool.WARNING:tensorflow:Casting 
 labels to bool.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:Starting evaluation at 2018-07-12-15:58:50INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from kernel_train/model.ckpt-2000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Evaluation [1/1]INFO:tensorflow:Finished evaluation at 2018-07-12-15:58:51INFO:tensorflow:Saving dict for global step 2000: accuracy = 0.83975184, accuracy/baseline_label_mean = 0.23622628, accuracy/threshold_0.500000_mean = 0.83975184, auc = 0.8904007, auc_precision_recall = 0.72722375, global_step = 2000, labels/actual_label_mean = 0.23622628, labels/prediction_mean = 0.23786618, loss = 0.34277728, precision/positive_threshold_0.500000_mean = 0.73001117, recall/positive_threshold_0.500000_mean = 0.5104004

Výsledná presnosť je 84%, ide o 2% zlepšenie v porovnaní s logistickou regresiou. Medzi zlepšením presnosti a výpočtovými nákladmi existuje kompromis. Musíte si rozmyslieť, či 2% zlepšenie stojí za čas strávený iným klasifikátorom a či má presvedčivý dopad na vaše podnikanie.

Zhrnutie

Jadro je vynikajúci nástroj na transformáciu nelineárnych údajov na (takmer) lineárne. Nedostatkom tejto metódy je, že je výpočtovo náročná na čas a náklady.

Ďalej nájdete najdôležitejší kód na vycvičenie klasifikátora jadra

Nastavte funkciu jadra s vysokou dimenziou

  • input_dim = 14
  • output_dim = 5 000
  • stddev = 4
### Prep Kernelkernel_mapper = tf.contrib.kernel_methods.RandomFourierFeatureMapper(input_dim=14, output_dim=5000, stddev=4, name='rffm')

Nastavte hyperparameter L2

optimizer = tf.train.FtrlOptimizer(learning_rate=5, l2_regularization_strength=0.1)

Postavte model

estimator_kernel = tf.contrib.kernel_methods.KernelLinearClassifier( n_classes=2,optimizer=optimizer,kernel_mappers=kernel_mappers,model_dir="kernel_train")

Trénujte model

estimator_kernel.fit(input_fn=train_input_fn, steps=2000)

Vyhodnoťte model

eval_metrics = estimator_kernel.evaluate(input_fn=test_input_fn, steps=1)