Gaussovo jádro ve strojovém učení: Příklady metod jádra

Účelem tohoto kurzu je vytvořit lineárně oddělitelnou datovou sadu. Výukový program je rozdělen do dvou částí:

1. Transformace funkcí
2. Trénujte klasifikátor jádra pomocí Tensorflow

V první části pochopíte myšlenku, která stojí za metodou jádra ve strojovém učení, zatímco ve druhé části uvidíte, jak trénovat klasifikátor jádra pomocí Tensorflow. Budete používat datovou sadu pro dospělé. Cílem tohoto datového souboru je klasifikovat výnosy pod a nad 50 tis., S vědomím chování každé domácnosti.

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

• Proč potřebujete metody jádra?
• Co je to jádro ve strojovém učení?
• Typy jádrových metod
• Trénujte klasifikátor gaussovského jádra pomocí TensorFlow

Proč potřebujete metody jádra?

Cílem každého klasifikátoru je správně předpovědět třídy. Za tímto účelem by datová sada měla být oddělitelná. Podívejte se na obrázek níže; je docela snadné vidět, že všechny body nad černou čarou patří do první třídy a ostatní body do druhé třídy. Je však extrémně vzácné mít tak jednoduchou datovou sadu. Ve většině případů nejsou data oddělitelná. Metody jádra ve strojovém učení poskytují naivním klasifikátorům, jako je logistická regrese, těžké časy.

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 následujícím obrázku vykreslíme datovou sadu, která není lineárně oddělitelná. Pokud nakreslíme přímku, většina bodů nebude klasifikována ve správné třídě.

Jedním ze způsobů řešení tohoto problému je převzetí datové sady a transformace dat do jiné mapy funkcí. To znamená, že použijete funkci k transformaci dat do jiného plánu, který by měl být linearable.

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

Data z výše uvedeného obrázku jsou v plánu 2D Gaussova jádra, který není oddělitelný. Můžete se pokusit transformovat tato data v trojrozměrném, to znamená, že vytvoříte figuru se 3 osami.

V našem příkladu gaussovského jádra použijeme polynomiální mapování, abychom přenesli naše data do 3D dimenze. Vzorec pro transformaci dat je následující.

Definujete funkci v Gaussian Kernel Python, abyste vytvořili nové mapy funkcí

K kódování výše uvedeného vzorce můžete použít numpy:

Vzorec	Ekvivalentní číselný kód
X	x [:, 0] **
y	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é mapování by mělo mít 3 rozměry a 16 bodů

x_1 = mapping(x, y)x_1.shape 

(3, 16) 

Vytvořme nový graf se 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 vylepšení, ale pokud změníme orientaci grafu, je jasné, že datová sada je nyní oddělitelná

# 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() 

Chcete-li manipulovat s velkou datovou sadou a možná budete muset vytvořit více než 2 dimenze, budete pomocí výše uvedené metody čelit velkým problémům. Ve skutečnosti musíte transformovat všechny datové body, což zjevně není udržitelné. Bude to trvat věky a váš počítač může mít nedostatek paměti.

Nejběžnějším způsobem, jak tento problém překonat, je použití jádra .

Co je to jádro ve strojovém učení?

Myšlenkou je použít prostor funkcí vyšší dimenze, aby byla data téměř lineárně oddělitelná, jak je znázorněno na obrázku výše.

Existuje spousta prostorů vyšších dimenzí, aby byly datové body oddělitelné. Například jsme ukázali, že polynomiální mapování je skvělý začátek.

Rovněž jsme prokázali, že se spoustou dat není tato transformace efektivní. Místo toho můžete použít funkci jádra v Machine Learning k úpravě dat bez změny na nový plán funkcí.

Kouzlem jádra je najít funkci, která se vyhne všem problémům vyplývajícím z vysokodimenzionálního výpočtu. Výsledek jádra je skalární, nebo jinak řečeno, jsme zpět v jednorozměrném prostoru

Jakmile najdete tuto funkci, můžete ji připojit ke standardnímu lineárnímu klasifikátoru.

Podívejme se na příklad k pochopení konceptu strojového učení jádra. Máte dva vektory, x1 a x2. Cílem je vytvořit vyšší dimenzi pomocí polynomiálního mapování. Výstup se rovná bodovému produktu nové mapy funkcí. Z výše uvedené metody musíte:

1. Transformujte x1 a x2 do nové dimenze
2. Vypočítejte bodový produkt: společný pro všechna jádra
3. Transformujte x1 a x2 do nové dimenze

Pomocí výše vytvořené funkce můžete vypočítat vyšší dimenzi.

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

Výstup

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

Vypočítejte bodový produkt

Objektovou tečku z numpy můžete použít k výpočtu tečkového produktu mezi prvním a druhým vektorem 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, je třeba uložit do paměti novou mapu funkcí, abyste mohli vypočítat bodový produkt. Pokud máte datovou sadu s miliony záznamů, je výpočetně neefektivní.

Místo toho můžete použít polynomiální jádro k výpočtu bodového produktu bez transformace vektoru. Tato funkce počítá součin bodů x1 a x2, jako by tyto dva vektory byly transformovány do vyšší dimenze. Jinak řečeno, funkce jádra počítá výsledky tečkového produktu z jiného prostoru funkcí.

Funkci jádra polynomu můžete v Pythonu napsat následovně.

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

Je to síla bodového součinu dvou vektorů. Níže vrátíte druhý stupeň polynomiálního jádra. Výstup se rovná druhé metodě. To je kouzlo jádra.

polynomial_kernel(x1, x2, p=2)8100 

Typy jádrových metod

Existuje spousta různých technik jádra. Nejjednodušší je lineární jádro. Tato funkce funguje docela dobře pro klasifikaci textu. Druhé jádro je:

• Polynomiální jádro
• Gaussovo jádro

V příkladu s TensorFlow použijeme Random Fourier. TensorFlow má vestavěný odhadovač pro výpočet prostoru nových funkcí. Funkce Gaussova filtru je aproximací funkce Gaussova jádra.

Gaussova filtrační funkce počítá podobnost mezi datovými body v mnohem dimenzionálním prostoru.

Trénujte klasifikátor gaussovského jádra pomocí TensorFlow

Cílem algoritmu je klasifikace domácnosti vydělávající více než 50 tis.

Vyhodnotíte logistické jádrové regresní strojové učení, abyste měli srovnávací model. Poté procvičíte klasifikátor jádra, abyste zjistili, zda můžete dosáhnout lepších výsledků.

Z datové sady pro dospělé používáte následující proměnné:

• stáří
• pracovní třída
• fnlwgt
• vzdělání
• education_num
• manželský
• obsazení
• vztah
• závod
• sex
• kapitálový zisk
• capital_loss
• hours_week
• rodná země
• označení

Před tréninkem a hodnocením modelu budete postupovat následovně:

• Krok 1) Importujte knihovny
• Krok 2) Importujte data
• Krok 3) Připravte data
• Krok 4) Vytvořte input_fn
• Krok 5) Sestavte logistický model: Základní model
• Krok 6) Vyhodnoťte model
• Krok 7) Vytvořte klasifikátor jádra
• Krok 8) Vyhodnoťte klasifikátor jádra

Krok 1) Importujte knihovny

Chcete-li importovat a trénovat modely jádra v Artificial Intelligence, musíte importovat 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 data

Stahujete data z následujícího webu a importujete je jako datový 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) 

Nyní, když je definována sada vlaků a testů, můžete změnit popisek sloupce z řetězce na celé číslo. tensorflow nepřijímá hodnotu řetězce pro štítek.

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) Připravte data

Datová sada obsahuje kontinuální i kategorické funkce. Dobrým postupem je standardizovat hodnoty spojitých proměnných. Můžete použít funkci StandardScaler ze sci-kit learn. Vytvoříte také uživatelem definovanou funkci, abyste usnadnili převod vlaku a testovací sady. Všimněte si, že spojujete spojité a kategorické proměnné do společné datové sady a pole by mělo být 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 

Funkce transformátoru je připravena, můžete převést datovou sadu a vytvořit funkci 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 dalším kroku procvičíte logistickou regresi. Získáte základní přesnost. Cílem je porazit základní linii jiným algoritmem, konkrétně klasifikátorem jádra.

Krok 4) Sestavte logistický model: Základní model

Sloupec prvků vytvoříte pomocí objektu real_valued_column. Zajistí, aby všechny proměnné obsahovaly hustá numerická data.

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

Odhad je definován pomocí nástroje TensorFlow Estimator, dáváte pokyny sloupcům prvků a kam graf uložit.

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} 

Logickou regresi budete trénovat pomocí minidávek velikosti 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) 

Model můžete trénovat s 1 000 iterací

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

Pro vyhodnocení modelu definujete numpy estimator. Pro vyhodnocení používáte celou datovou sadu

# 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 přesnost 82 procent. V další části se pokusíte porazit logistický klasifikátor pomocí klasifikátoru jádra

Krok 7) Vytvořte klasifikátor jádra

Odhad jádra se neliší od tradičního lineárního klasifikátoru, alespoň pokud jde o konstrukci. Myšlenkou je použití síly explicitního jádra s lineárním klasifikátorem.

K trénování klasifikátoru jádra potřebujete dva předdefinované odhady dostupné v TensorFlow:

• RandomFourierFeatureMapper
• KernelLinearClassifier

V první části jste se dozvěděli, že musíte pomocí funkce jádra transformovat nízkou dimenzi na vysokou dimenzi. Přesněji použijete Random Fourier, což je aproximace Gaussovy funkce. Naštěstí má Tensorflow ve své knihovně funkci: RandomFourierFeatureMapper. Model lze trénovat pomocí odhadu KernelLinearClassifier.

K sestavení modelu budete postupovat podle těchto kroků:

1. Nastavte funkci jádra vysoké dimenze
2. Nastavte hyperparametr L2
3. Sestavte model
4. Trénujte model
5. Vyhodnoťte model

Krok A) Nastavte funkci jádra vysoké dimenze

Aktuální datová sada obsahuje 14 funkcí, které transformujete na novou vysokou dimenzi 5 000-dimenzionálního vektoru. K dosažení transformace použijete náhodné Fourierovy funkce. Pokud si vzpomenete na vzorec Gaussova jádra, všimnete si, že je třeba definovat parametr standardní odchylky. Tento parametr řídí míry podobnosti, které se používají během klasifikace.

Všechny parametry v RandomFourierFeatureMapper můžete naladit pomocí:

• input_dim = 14
• output_dim = 5000
• stddev = 4

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

Musíte vytvořit mapovač jádra pomocí sloupců funkcí vytvořených před: feat_column

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

Krok B) Nastavte hyperparametr L2

Abyste zabránili nadměrnému vybavení, penalizujete funkci ztráty regulátorem L2. Nastavíte hyperparametr L2 na 0,1 a rychlost učení na 5

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

Krok C) Sestavte model

Další krok je podobný lineární klasifikaci. Používáte odhadovač zabudování KernelLinearClassifier. Všimněte si, že přidáte dříve definovaný mapovač jádra a změníte adresář 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

Nyní, když je vytvořen klasifikátor jádra, jste připraveni ho trénovat. Rozhodnete se iterovat 2 000krát model

### 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 neposlední řadě hodnotíte výkon svého modelu. Měli byste být schopni porazit logistickou regresi.

# 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

Konečná přesnost je 84%, jde o 2% zlepšení ve srovnání s logistickou regresí. Mezi zlepšením přesnosti a výpočetními náklady je kompromis. Musíte si myslet, zda 2% zlepšení stojí za čas spotřebovaný jiným klasifikátorem a jestli má přesvědčivý dopad na vaše podnikání.

souhrn

Jádro je skvělý nástroj pro transformaci nelineárních dat na (téměř) lineární. Nedostatkem této metody je výpočetně časově náročná a nákladná.

Níže najdete nejdůležitější kód pro trénování třídiče jádra

Nastavte funkci jádra vysoké dimenze

• input_dim = 14
• output_dim = 5000
• stddev = 4

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

Nastavte hyperparametr L2

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

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