Gaussovské jádro ve strojovém učení: Python Metody jádra

Účelem tohoto tutoriálu je vytvořit datovou sadu lineárně oddělitelnou. Tutoriál je rozdělen do dvou částí:

Transformace rysů
Trénujte klasifikátor jádra pomocí Tensorflow

V první části pochopíte myšlenku metody Kernel v Machine Learning, 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 souboru dat je klasifikovat tržby pod a nad 50 XNUMX, se znalostí chování každé domácnosti.

Proč potřebujete metody jádra?

Cílem každého klasifikátoru je správně předpovědět třídy. K tomu by měla být datová sada oddělitelná. Podívejte se na spiknutí níže; je poměrně jednoduché 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 jednoduchý soubor dat. Ve většině případů nejsou data oddělitelná. Metody jádra ve strojovém učení dávají naivním klasifikátorům, jako je logistická regrese, těžké časy.

import numpy as np
  import matplotlib.pyplot as plt
  from 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 níže zobrazujeme datovou sadu, která není lineárně oddělitelná. Pokud nakreslíme přímku, většina bodů nebude zařazena do správné třídy.

Jedním ze způsobů, jak tento problém vyřešit, je vzít datovou sadu a transformovat data do jiné mapy prvků. To znamená, že použijete funkci k transformaci dat do jiného plánu, který by měl být lineární.

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 obrázku výše jsou ve 2D Gaussian Kernel plánu, který nelze oddělit. Můžete se pokusit tato data transformovat do trojrozměru, to znamená, že vytvoříte obrazec se 3 osami.

V našem příkladu Gaussian Kernel použijeme polynomiální mapování, abychom přivedli naše data do 3D dimenze. Vzorec pro transformaci dat je následující.

Funkci definujete v Gaussian Kernel Python vytvořit nové mapy objektů

Můžeš použít otupělý pro kódování výše uvedeného vzorce:

Vzorec	Ekvivalentní Numpy kód
x	x[:,0]**
y	x[:,1]
x²	x[:,0]**2
	np.sqrt(2)*
xy	x[:,0]*x[:,1]
y²	x[:,1]**2

### illustration purpose
def mapping(x, y):    
	x = np.c_[(x, y)]				
    if len(x) >	2:        
    	x_1 = x[:,0]**2        
        x_2 = np.sqrt(2)*x[:,0]*x[:,1]        
        x_3 = x[:,1]**2								
    else:            
    	x_1 = x[0]**2        
        x_2 = np.sqrt(2)*x[0]*x[1]        
        x_3 = x[1]**2			    
   trans_x = np.array([x_1, x_2, x_3])				
   return trans_x

Nové mapování by mělo mít 3 rozměry s 16 body

x_1  = mapping(x, y)
x_1.shape

(3, 16)

Udělejme nový graf se 3 osami, x, y a z.

# plot
fig = 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šení, ale pokud změníme orientaci grafu, je jasné, že soubor dat je nyní oddělitelný

# plot
fig = 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 velkým souborem dat a možná budete muset vytvořit více než 2 dimenze, budete čelit velkému problému při použití výše uvedené metody. Ve skutečnosti musíte transformovat všechny datové body, což zjevně není udržitelné. Bude vám to trvat věky a vašemu počítači může dojít paměť.

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

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

Záměrem je použít prostor prvků 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.

Také jsme ukázali, že s velkým množstvím dat není tato transformace efektivní. Místo toho můžete použít funkci jádra v Machine Learning k úpravě dat bez přechodu na nový plán funkcí.

Kouzlo jádra spočívá v nalezení funkce, která se vyhne všem problémům, které s sebou nese vysokorozměrný výpočet. Výsledkem jádra je skalár, 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 pro 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 součinu nové mapy prvků. Z výše uvedené metody musíte:

Transformujte x1 a x2 do nové dimenze
Vypočítejte bodový součin: společný pro všechna jádra
Transformujte x1 a x2 do nové dimenze

K výpočtu vyšší dimenze můžete použít funkci vytvořenou výše.

## Kernel
x1 = 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ý součin

Objekt tečka z numpy můžete použít k výpočtu tečkového součinu 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, potřebujete uložit do paměti novou mapu funkcí, abyste mohli vypočítat bodový součin. 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 pro výpočet bodového součinu bez transformace vektoru. Tato funkce počítá bodový součin x1 a x2, jako by tyto dva vektory byly transformovány do vyšší dimenze. Jinak řečeno, funkce jádra počítá výsledky bodového součinu z jiného prostoru funkcí.

Můžete zapsat funkci polynomického jádra Python jak následuje.

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

Je to mocnina tečkového součinu dvou vektorů. Níže vrátíte druhý stupeň polynomického jádra. Výstup je stejný jako u druhé metody. To je kouzlo jádra.

polynomial_kernel(x1, x2, p=2)			
8100

Typy metod jádra

K dispozici je mnoho různých technik jádra. Nejjednodušší je lineární jádro. Tato funkce funguje docela dobře pro klasifikaci textu. Další jádro je:

Polynomiální jádro
Gaussovo jádro

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

Funkce Gaussova filtrování počítá podobnost mezi datovými body v mnohem vyšším dimenzionálním prostoru.

Trénujte klasifikátor Gaussian Kernel pomocí TensorFlow

Cílem algoritmu je klasifikovat domácnost s příjmem vyšším nebo nižším než 50 tisíc.

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

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

stáří
pracovní třída
fnlwgt
vzdělání
vzdělání_číslo
manželský
povolání
vztah
závod
pohlaví
kapitálový zisk
kapitálová_ztráta
hodiny_týden
rodná země
štítek

Před trénováním 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) Vytvořte 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 Umělá inteligence, musíte importovat tensorflow, pandy a nudný

#import numpy as np
from sklearn.model_selection 
import train_test_split
import tensorflow as tf
import pandas as pd
import numpy as np

Krok 2) Importujte data

Data stáhnete z následujícího webových stránkách a importujete jej jako datový rámec panda.

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

Nyní, když jsou definovány vlaková a testovací sada, 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ý soubor obsahuje jak spojité, tak kategorické prvky. Osvědčeným postupem je standardizovat hodnoty spojitých proměnných. Můžete použít funkci StandardScaler ze sci-kit learn. Vytvoříte také uživatelsky definovanou funkci, která usnadní převod vlakové a testovací sady. Všimněte si, že spojité a kategorické proměnné zřetězíte 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 StandardScaler
from sklearn import preprocessing			

def 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 budete trénovat logistickou regresi. Poskytne vám základní přesnost. Cílem je překonat základní linii pomocí jiného algoritmu, jmenovitě klasifikátoru jádra.

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

Sloupec prvku vytvoříte pomocí objektu real_valued_column. Ujistí se, že všechny proměnné jsou hustá číselná data.

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

Odhad je definován pomocí TensorFlow Estimator, vy určujete sloupce prvků a kam se má 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': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1a2003f780>, '_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}

Logisitc regresi budete trénovat pomocí minidávek o velikosti 200.

# Train the model
train_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 XNUMX iteracemi

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 = 1
INFO:tensorflow:global_step/sec: 324.16
INFO:tensorflow:loss = 87.16762, step = 101 (0.310 sec)
INFO:tensorflow:global_step/sec: 267.092
INFO:tensorflow:loss = 71.53657, step = 201 (0.376 sec)
INFO:tensorflow:global_step/sec: 292.679
INFO:tensorflow:loss = 69.56703, step = 301 (0.340 sec)
INFO:tensorflow:global_step/sec: 225.582
INFO:tensorflow:loss = 74.615875, step = 401 (0.445 sec)
INFO:tensorflow:global_step/sec: 209.975
INFO:tensorflow:loss = 76.49044, step = 501 (0.475 sec)
INFO:tensorflow:global_step/sec: 241.648
INFO:tensorflow:loss = 66.38373, step = 601 (0.419 sec)
INFO:tensorflow:global_step/sec: 305.193
INFO:tensorflow:loss = 87.93341, step = 701 (0.327 sec)
INFO:tensorflow:global_step/sec: 396.295
INFO:tensorflow:loss = 76.61518, step = 801 (0.249 sec)
INFO:tensorflow:global_step/sec: 359.857
INFO: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.


<tensorflow.python.estimator.canned.linear.LinearClassifier at 0x1a1fa3cbe0>

Krok 6) Vyhodnoťte model

Definujete numpy estimator pro vyhodnocení modelu. K vyhodnocení použijete celou datovou sadu

# Evaluation
test_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:22
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from kernel_log/model.ckpt-1000
INFO: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:23
INFO: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 klasifikátorem jádra

Krok 7) Sestavte klasifikátor jádra

Kernel estimator se od tradičního lineárního klasifikátoru až tak neliší, alespoň co se konstrukce týče. Základní myšlenkou je využít sílu 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 pomocí funkce jádra potřebujete transformovat nízkou dimenzi na vysokou dimenzi. Přesněji, použijete náhodný Fourier, což je aproximace Gaussovy funkce. Naštěstí má Tensorflow funkci ve své knihovně: RandomFourierFeatureMapper. Model lze trénovat pomocí estimátoru KernelLinearClassifier.

Chcete-li sestavit model, postupujte takto:

Nastavte funkci jádra vysoké dimenze
Nastavte hyperparametr L2
Sestavte model
Trénujte model
Vyhodnoťte model

Krok A) Nastavte funkci jádra vysoké dimenze

Aktuální datová sada obsahuje 14 funkcí, které transformujete do nové vysoké dimenze 5.000-rozměrného vektoru. K dosažení transformace použijete náhodné Fourierovy prvky. Pokud si vzpomenete na vzorec Gaussova jádra, všimnete si, že je třeba definovat parametr standardní odchylky. Tento parametr řídí míru podobnosti používanou během klasifikace.

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

input_dim = 14
output_dim= 5000
stddev=4

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

Mapovač jádra musíte sestavit pomocí dříve vytvořených sloupců funkcí: feat_column

### Map Kernel
kernel_mappers = {feat_column: [kernel_mapper]}

Krok B) Nastavte hyperparametr L2

Abyste zabránili nadměrnému vybavení, penalizujete funkci ztráty pomocí regularizátoru 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 vestavěný estimátor KernelLinearClassifier. Všimněte si, že přidáte mapovač jádra definovaný dříve a změníte adresář modelu.

### Prep estimator
estimator_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': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1a200ae550>, '_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 klasifikátor jádra vytvořen, jste připraveni jej trénovat. Zvolíte iteraci 2000násobku modelu

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

WARNING:tensorflow:Casting <dtype: 'int32'> labels to bool.
WARNING:tensorflow:Casting <dtype: 'int32'> 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 = 1
INFO:tensorflow:global_step/sec: 86.6365
INFO:tensorflow:loss = 0.39374447, step = 101 (1.155 sec)
INFO:tensorflow:global_step/sec: 80.1986
INFO:tensorflow:loss = 0.3797774, step = 201 (1.247 sec)
INFO:tensorflow:global_step/sec: 79.6376
INFO:tensorflow:loss = 0.3908726, step = 301 (1.256 sec)
INFO:tensorflow:global_step/sec: 95.8442
INFO:tensorflow:loss = 0.41890752, step = 401 (1.043 sec)
INFO:tensorflow:global_step/sec: 93.7799
INFO:tensorflow:loss = 0.35700393, step = 501 (1.066 sec)
INFO:tensorflow:global_step/sec: 94.7071
INFO:tensorflow:loss = 0.35535482, step = 601 (1.056 sec)
INFO:tensorflow:global_step/sec: 90.7402
INFO:tensorflow:loss = 0.3692882, step = 701 (1.102 sec)
INFO:tensorflow:global_step/sec: 94.4924
INFO:tensorflow:loss = 0.34746957, step = 801 (1.058 sec)
INFO:tensorflow:global_step/sec: 95.3472
INFO:tensorflow:loss = 0.33655524, step = 901 (1.049 sec)
INFO:tensorflow:global_step/sec: 97.2928
INFO:tensorflow:loss = 0.35966292, step = 1001 (1.028 sec)
INFO:tensorflow:global_step/sec: 85.6761
INFO:tensorflow:loss = 0.31254214, step = 1101 (1.167 sec)
INFO:tensorflow:global_step/sec: 91.4194
INFO:tensorflow:loss = 0.33247527, step = 1201 (1.094 sec)
INFO:tensorflow:global_step/sec: 82.5954
INFO:tensorflow:loss = 0.29305756, step = 1301 (1.211 sec)
INFO:tensorflow:global_step/sec: 89.8748
INFO:tensorflow:loss = 0.37943482, step = 1401 (1.113 sec)
INFO:tensorflow:global_step/sec: 76.9761
INFO:tensorflow:loss = 0.34204718, step = 1501 (1.300 sec)
INFO:tensorflow:global_step/sec: 73.7192
INFO:tensorflow:loss = 0.34614792, step = 1601 (1.356 sec)
INFO:tensorflow:global_step/sec: 83.0573
INFO:tensorflow:loss = 0.38911164, step = 1701 (1.204 sec)
INFO:tensorflow:global_step/sec: 71.7029
INFO:tensorflow:loss = 0.35255936, step = 1801 (1.394 sec)
INFO:tensorflow:global_step/sec: 73.2663
INFO: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': <tensorflow.contrib.learn.python.learn.estimators.head._BinaryLogisticHead object at 0x1a2054cd30>, 'feature_columns': {_RealValuedColumn(column_name='features_MAPPED', dimension=5000, default_value=None, dtype=tf.float32, normalizer=None)}, 'optimizer': <tensorflow.python.training.ftrl.FtrlOptimizer object at 0x1a200aec18>, 'kernel_mappers': {_RealValuedColumn(column_name='features', dimension=14, default_value=None, dtype=tf.float32, normalizer=None): [<tensorflow.contrib.kernel_methods.python.mappers.random_fourier_features.RandomFourierFeatureMapper object at 0x1a200ae400>]}})

Krok E) Vyhodnoťte model

V neposlední řadě hodnotíte výkon svého modelu. Měli byste být schopni překonat logistickou regresi.

# Evaluate and report metrics.
eval_metrics = estimator_kernel.evaluate(input_fn=test_input_fn, steps=1)

WARNING:tensorflow:Casting <dtype: 'int32'> labels to bool.
WARNING:tensorflow:Casting <dtype: 'int32'> 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:50
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from kernel_train/model.ckpt-2000
INFO: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:51
INFO: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á přesnost je 84 %, což je 2% zlepšení oproti logistické regresi. Existuje kompromis mezi zlepšením přesnosti a výpočetními náklady. Musíte se zamyslet nad tím, zda 2% zlepšení stojí za čas strávený různým klasifikátorem a zda má přesvědčivý dopad na vaše podnikání.

Shrnutí

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

Níže naleznete nejdůležitější kód pro trénování klasifikátoru 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)

Proč potřebujete metody jádra?

SOUVISEJÍCÍ ČLÁNKY

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

Typy metod jádra

Trénujte klasifikátor Gaussian Kernel pomocí TensorFlow

Shrnutí

Přihlaste se k odběru newsletteru