Gaussisk kerne i maskinlæring: Python Kernel metoder

Formålet med denne tutorial er at gøre et datasæt lineært adskilleligt. Tutorialen er opdelt i to dele:

Funktionstransformation
Træn en Kernel-klassifikator med Tensorflow

I den første del vil du forstå ideen bag en Kernel-metode i Machine Learning, mens du i den anden del vil se, hvordan du træner en kerneklassifikator med Tensorflow. Du skal bruge voksendatasættet. Formålet med dette datasæt er at klassificere omsætningen under og over 50 ved at kende hver husstands adfærd.

Hvorfor har du brug for Kernel Methods?

Formålet med hver klassifikator er at forudsige klasserne korrekt. Til det skal datasættet være adskilleligt. Se plottet nedenfor; det er ret enkelt at se, at alle punkter over den sorte linje tilhører den første klasse og de andre punkter til den anden klasse. Det er dog yderst sjældent at have et datasæt så simpelt. I de fleste tilfælde er dataene ikke adskillelige. Kernelmetoder i Machine Learning giver naive klassifikatorer som en logistisk regression en hård tid.

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

I figuren nedenfor plotter vi et datasæt, som ikke er lineært adskilleligt. Hvis vi tegner en lige linje, vil de fleste af punkterne ikke blive klassificeret i den rigtige klasse.

En måde at løse dette problem på er at tage datasættet og transformere dataene til et andet funktionskort. Det betyder, at du vil bruge en funktion til at transformere dataene i en anden plan, som burde være lineærbar.

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

Dataene fra figuren ovenfor er i en 2D Gaussian Kernel-plan, som ikke kan adskilles. Du kan prøve at transformere disse data i en tredimensionel, det betyder, at du opretter en figur med 3 akser.

I vores Gaussian Kernel-eksempel vil vi anvende en polynomiel mapping for at bringe vores data til en 3D-dimension. Formlen til at transformere dataene er som følger.

Du definerer en funktion i Gaussian Kernel Python at oprette de nye feature maps

Du kan bruge bedøvet for at kode ovenstående formel:

Formula	Tilsvarende Numpy-kode
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

Den nye kortlægning skal være med 3 dimensioner med 16 punkter

x_1  = mapping(x, y)
x_1.shape

(3, 16)

Lad os lave et nyt plot med 3 akser, henholdsvis x, y og 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()

Vi ser en forbedring, men hvis vi ændrer retningen af plottet, er det klart, at datasættet nu kan adskilles

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

For at manipulere et stort datasæt, og du måske skal oprette mere end 2 dimensioner, vil du stå over for et stort problem ved at bruge ovenstående metode. Faktisk skal du transformere alle datapunkter, hvilket tydeligvis ikke er bæredygtigt. Det vil tage dig aldre, og din computer kan løbe tør for hukommelse.

Den mest almindelige måde at løse dette problem på er at bruge en kerne.

Hvad er en kerne i maskinlæring?

Ideen er at bruge et funktionsrum med højere dimension til at gøre dataene næsten lineært adskillelige som vist i figuren ovenfor.

Der er masser af højere dimensionelle rum for at gøre datapunkterne adskillelige. For eksempel har vi vist, at polynomiekortlægningen er en god start.

Vi har også vist, at med masser af data er disse transformationer ikke effektive. I stedet kan du bruge en kernefunktion i Machine Learning til at ændre dataene uden at skifte til en ny funktionsplan.

Det magiske ved kernen er at finde en funktion, der undgår alle de problemer, som den højdimensionelle beregning indebærer. Resultatet af en kerne er en skalar, eller sagt anderledes er vi tilbage til et-dimensionelt rum

Når du har fundet denne funktion, kan du tilslutte den til standard lineær klassificering.

Lad os se et eksempel for at forstå konceptet Kernel Machine Learning. Du har to vektorer, x1 og x2. Målet er at skabe en højere dimension ved at bruge en polynomiel mapping. Outputtet er lig med prikproduktet af det nye feature map. Fra metoden ovenfor skal du:

Transform x1 og x2 til en ny dimension
Beregn prikproduktet: fælles for alle kerner
Transform x1 og x2 til en ny dimension

Du kan bruge funktionen oprettet ovenfor til at beregne den højere dimension.

## Kernel
x1 = np.array([3,6])
x2 = np.array([10,10])			

x_1 = mapping(x1, x2)
print(x_1)

Produktion

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

Beregn prikproduktet

Du kan bruge objektprikken fra numpy til at beregne prikproduktet mellem den første og anden vektor gemt i x_1.

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

Outputtet er 8100. Du kan se problemet, du skal gemme et nyt funktionskort i hukommelsen for at beregne prikproduktet. Hvis du har et datasæt med millioner af poster, er det beregningsmæssigt ineffektivt.

I stedet kan du bruge polynomisk kerne at beregne prikproduktet uden at transformere vektoren. Denne funktion beregner prikproduktet af x1 og x2, som om disse to vektorer er blevet transformeret til den højere dimension. Sagt anderledes, en kernefunktion beregner resultaterne af prikproduktet fra et andet funktionsrum.

Du kan skrive polynomiets kernefunktion i Python som følger.

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

Det er styrken af prikproduktet af to vektorer. Nedenfor returnerer du anden grad af polynomiumkernen. Outputtet er lig med den anden metode. Dette er kernens magi.

polynomial_kernel(x1, x2, p=2)			
8100

Typer af kernemetoder

Der er masser af forskellige Kernel-teknikker til rådighed. Den enkleste er den lineære kerne. Denne funktion fungerer ret godt til tekstklassificering. Den anden kerne er:

Polynomisk kerne
Gaussisk kerne

I eksemplet med TensorFlow, vil vi bruge Random Fourier. TensorFlow har en indbygget estimator til at beregne den nye funktionsplads. Den Gaussiske filterfunktion er en tilnærmelse af den Gaussiske kernefunktion.

Den Gaussiske filtreringsfunktion beregner ligheden mellem datapunkterne i et meget højere dimensionelt rum.

Træn Gaussian Kernel-klassifikator med TensorFlow

Formålet med algoritmen er at klassificere husstanden, der tjener mere eller mindre end 50k.

Du vil evaluere en logistisk Kernel Regression Machine Learning for at have en benchmarkmodel. Derefter træner du en Kernel-klassifikator for at se, om du kan få bedre resultater.

Du bruger følgende variabler fra voksendatasættet:

alder
arbejdsklasse
fnlwgt
uddannelse
uddannelsesnummer
ægteskabelig
besættelse
forhold
løb
køn
kapitalgevinst
kapitaltab
timer_uge
oprindelses land
label

Du vil fortsætte som følger, før du træner og evaluerer modellen:

Trin 1) Importer bibliotekerne
Trin 2) Importer dataene
Trin 3) Forbered dataene
Trin 4) Konstruer input_fn
Trin 5) Konstruer den logistiske model: Basismodel
Trin 6) Evaluer modellen
Trin 7) Konstruer Kernel-klassifikatoren
Trin 8) Evaluer Kernel-klassifikatoren

Trin 1) Importer bibliotekerne

At importere og træne Kernel-modeller i Kunstig intelligens, skal du importere tensorflow, pandaer og nusset

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

Trin 2) Importer dataene

Du downloader dataene fra følgende hjemmeside og du importerer det som en panda-dataramme.

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

Nu hvor toget og testsættet er defineret, kan du ændre kolonneetiketten fra streng til heltal. tensorflow accepterer ikke strengværdi for etiketten.

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)

Trin 3) Forbered dataene

Datasættet indeholder både kontinuerlige og kategoriske træk. En god praksis er at standardisere værdierne af de kontinuerlige variable. Du kan bruge funktionen StandardScaler fra sci-kit learning. Du opretter også en brugerdefineret funktion for at gøre det nemmere at konvertere toget og testsættet. Bemærk, at du sammenkæder de kontinuerlige og kategoriske variable til et fælles datasæt, og arrayet skal være af typen: 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

Transformatorfunktionen er klar, du kan konvertere datasættet og oprette funktionen 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)

I næste trin træner du en logistisk regression. Det vil give dig en baseline nøjagtighed. Målet er at slå basislinjen med en anden algoritme, nemlig en Kernel-klassifikator.

Trin 4) Konstruer den logistiske model: Basismodel

Du konstruerer funktionskolonnen med objektet real_valued_column. Det vil sikre, at alle variabler er tætte numeriske data.

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

Estimatoren defineres ved hjælp af TensorFlow Estimator, du instruerer funktionskolonnerne og hvor grafen skal gemmes.

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}

Du træner den logistiske regression ved hjælp af mini-batches af størrelse 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)

Du kan træne modellen med 1.000 iterationer

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>

Trin 6) Vurder modellen

Du definerer numpy estimatoren for at evaluere modellen. Du bruger hele datasættet til evaluering

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

Du har en nøjagtighed på 82 procent. I næste afsnit vil du prøve at slå den logistiske klassificering med en Kernel-klassifikator

Trin 7) Konstruer Kernel-klassifikatoren

Kerneestimatoren er ikke så forskellig fra den traditionelle lineære klassifikator, i det mindste med hensyn til konstruktion. Ideen bag er at bruge kraften i eksplicit kerne med den lineære klassifikator.

Du skal bruge to foruddefinerede estimatorer tilgængelige i TensorFlow for at træne Kernel Classifier:

RandomFourierFeatureMapper
KernelLinearClassifier

Du lærte i det første afsnit, at du skal transformere den lave dimension til en høj dimension ved hjælp af en kernefunktion. Mere præcist vil du bruge Random Fourier, som er en tilnærmelse af den Gaussiske funktion. Heldigvis har Tensorflow funktionen i sit bibliotek: RandomFourierFeatureMapper. Modellen kan trænes ved hjælp af estimatoren KernelLinearClassifier.

For at bygge modellen skal du følge disse trin:

Indstil kernefunktionen med høj dimension
Indstil L2-hyperparameteren
Byg modellen
Træn modellen
Vurder modellen

Trin A) Indstil kernefunktionen med høj dimension

Det nuværende datasæt indeholder 14 funktioner, som du vil transformere til en ny høj dimension af den 5.000-dimensionelle vektor. Du bruger de tilfældige Fourier-træk til at opnå transformationen. Hvis du husker den Gaussiske Kernel-formel, bemærker du, at der er standardafvigelsesparameteren, der skal defineres. Denne parameter kontrollerer det lighedsmål, der anvendes under klassificeringen.

Du kan indstille alle parametrene i RandomFourierFeatureMapper med:

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

Du skal konstruere kernemapperen ved at bruge funktionskolonnerne oprettet før: feat_column

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

Trin B) Indstil L2-hyperparameteren

For at forhindre overfitting straffer du tabsfunktionen med L2-regularizeren. Du indstiller L2-hyperparameteren til 0.1 og indlæringshastigheden til 5

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

Trin C) Byg modellen

Det næste trin ligner den lineære klassifikation. Du bruger den indbyggede estimator KernelLinearClassifier. Bemærk, at du tilføjer den tidligere definerede kernemapper og ændrer modelbiblioteket.

### 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'}

Trin D) Træn modellen

Nu hvor Kernel-klassifikatoren er bygget, er du klar til at træne den. Du vælger at gentage 2000 gange modellen

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

Trin E) Vurder modellen

Sidst, men ikke mindst, evaluerer du din models ydeevne. Du burde være i stand til at slå den logistiske regression.

# 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

Den endelige nøjagtighed er 84%, det er en forbedring på 2% i forhold til den logistiske regression. Der er en afvejning mellem forbedring af nøjagtighed og beregningsomkostninger. Du skal tænke på, om en forbedring på 2 % er værd at bruge den tid, den forskellige klassifikator bruger, og om det har en overbevisende indvirkning på din virksomhed.

Resumé

En kerne er et fantastisk værktøj til at transformere ikke-lineære data til (næsten) lineære. Manglen ved denne metode er, at den er beregningsmæssigt tidskrævende og dyr.

Nedenfor kan du finde den vigtigste kode til at træne en kerneklassificerer

Indstil kernefunktionen med høj dimension

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

Indstil L2-hyperparameteren

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

Byg modellen

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

Træn modellen

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

Vurder modellen

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

Du kan lide:

Hvorfor har du brug for Kernel Methods?

RELATEREDE ARTIKLER

Hvad er en kerne i maskinlæring?

Typer af kernemetoder

Træn Gaussian Kernel-klassifikator med TensorFlow

Resumé