Gaussisk kjerne i maskinlæring: Python Kjernemetoder

Hensikten med denne opplæringen er å gjøre et datasett lineært separerbart. Opplæringen er delt inn i to deler:

  1. Funksjonstransformasjon
  2. Tren en kjerneklassifiser med Tensorflow

I den første delen vil du forstå ideen bak en kjernemetode i maskinlæring, mens du i den andre delen vil se hvordan du trener en kjerneklassifiser med Tensorflow. Du vil bruke voksendatasettet. Målet med dette datasettet er å klassifisere inntektene under og over 50k, vel vitende om oppførselen til hver husholdning.

Hvorfor trenger du kjernemetoder?

Målet med hver klassifiserer er å forutsi klassene riktig. For det bør datasettet være separerbart. Se på plottet nedenfor; det er ganske enkelt å se at alle punktene over den svarte linjen tilhører den første klassen og de andre punktene til den andre klassen. Det er imidlertid ekstremt sjeldent å ha et datasett så enkelt. I de fleste tilfeller er ikke dataene separerbare. Kjernemetoder i Machine Learning gir naive klassifiserere som en logistisk regresjon en vanskelig 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()

Kjernemetode

I figuren nedenfor plotter vi et datasett som ikke er lineært separerbart. Hvis vi trekker en rett linje, vil de fleste punktene ikke bli klassifisert i riktig klasse.

En måte å takle dette problemet på er å ta datasettet og transformere dataene til et annet funksjonskart. Det betyr at du vil bruke en funksjon til å transformere dataene i en annen plan, som bør 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()

Kjernemetode

Dataene fra figuren ovenfor er i en 2D Gaussisk kjerneplan som ikke kan separeres. Du kan prøve å transformere disse dataene i en tredimensjon, det betyr at du lager en figur med 3 akser.

I vårt Gaussian Kernel-eksempel vil vi bruke en polynomkartlegging for å bringe dataene våre til en 3D-dimensjon. Formelen for å transformere dataene er som følger.

Kjernemetode

Du definerer en funksjon i Gaussian Kernel Python for å lage de nye funksjonskartene

Du kan bruke følelsesløs for å kode formelen ovenfor:

Formel Tilsvarende Numpy-kode
x x[:,0]**
y x[:,1]
x2 x[:,0]**2
Kjernemetode np.sqrt(2)*
xy x[:,0]*x[:,1]
y2 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 kartleggingen skal være med 3 dimensjoner med 16 punkter

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

La oss lage et nytt plott med henholdsvis 3 akser, 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()

Kjernemetode

Vi ser en forbedring, men hvis vi endrer retningen på plottet, er det klart at datasettet nå kan separeres

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

Kjernemetode

For å manipulere et stort datasett, og du må kanskje lage mer enn 2 dimensjoner, vil du møte et stort problem ved å bruke metoden ovenfor. Faktisk må du transformere alle datapunkter, noe som tydeligvis ikke er bærekraftig. Det vil ta lang tid, og datamaskinen kan gå tom for minne.

Den vanligste måten å løse dette problemet på er å bruke en kjerne.

Hva er en kjerne i maskinlæring?

Ideen er å bruke et funksjonsrom med høyere dimensjon for å gjøre dataene nesten lineært separerbare som vist i figuren ovenfor.

Det er nok av høyere dimensjonale rom for å gjøre datapunktene separerbare. For eksempel har vi vist at polynomkartleggingen er en god start.

Vi har også vist at med mye data er ikke denne transformasjonen effektiv. I stedet kan du bruke en kjernefunksjon i maskinlæring for å endre dataene uten å endre til en ny funksjonsplan.

Magien med kjernen er å finne en funksjon som unngår alle problemene som følger av den høydimensjonale beregningen. Resultatet av en kjerne er en skalar, eller sagt annerledes er vi tilbake til endimensjonalt rom

Etter at du har funnet denne funksjonen, kan du koble den til standard lineær klassifiserer.

La oss se et eksempel for å forstå konseptet Kernel Machine Learning. Du har to vektorer, x1 og x2. Målet er å skape en høyere dimensjon ved å bruke en polynomkartlegging. Utgangen er lik prikkproduktet til det nye funksjonskartet. Fra metoden ovenfor må du:

  1. Forvandle x1 og x2 til en ny dimensjon
  2. Beregn punktproduktet: felles for alle kjerner
  3. Forvandle x1 og x2 til en ny dimensjon

Du kan bruke funksjonen opprettet ovenfor for å beregne den høyere dimensjonen.

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

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

Produksjon

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

Beregn punktproduktet

Du kan bruke objektprikken fra numpy til å beregne punktproduktet mellom den første og andre vektoren lagret i x_1.

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

Utgangen er 8100. Du ser problemet, du må lagre et nytt funksjonskart i minnet for å beregne punktproduktet. Hvis du har et datasett med millioner av poster, er det beregningsmessig ineffektivt.

I stedet kan du bruke polynom kjerne å beregne punktproduktet uten å transformere vektoren. Denne funksjonen beregner punktproduktet til x1 og x2 som om disse to vektorene har blitt transformert til den høyere dimensjonen. Sagt annerledes, en kjernefunksjon beregner resultatene av punktproduktet fra et annet funksjonsområde.

Du kan skrive polynomets kjernefunksjon i Python som følger.

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

Det er kraften til punktproduktet av to vektorer. Nedenfor returnerer du den andre graden av polynomkjernen. Utgangen er lik den andre metoden. Dette er magien med kjernen.

polynomial_kernel(x1, x2, p=2)			
8100

Typer kjernemetoder

Det er mange forskjellige kjerneteknikker tilgjengelig. Den enkleste er den lineære kjernen. Denne funksjonen fungerer ganske bra for tekstklassifisering. Den andre kjernen er:

  • Polynom kjerne
  • Gaussisk kjerne

I eksempelet med tensorflow, vil vi bruke Random Fourier. TensorFlow har en innebygd estimator for å beregne den nye funksjonsplassen. Den Gaussiske filterfunksjonen er en tilnærming av den Gaussiske kjernefunksjonen.

Typer kjernemetoder

Den Gaussiske filtreringsfunksjonen beregner likheten mellom datapunktene i et mye høyere dimensjonalt rom.

Tren Gaussian Kernel-klassifiserer med TensorFlow

Målet med algoritmen er å klassifisere husholdningen som tjener mer eller mindre enn 50k.

Du vil evaluere en logistisk kjerneregresjonsmaskinlæring for å ha en benchmarkmodell. Etter det vil du trene en kjerneklassifiser for å se om du kan få bedre resultater.

Du bruker følgende variabler fra voksendatasettet:

  • alder
  • arbeidsklasse
  • fnlwgt
  • utdanning
  • utdanning_nummer
  • ekteskapelig
  • okkupasjon
  • forholdet
  • rase
  • kjønn
  • kapitalgevinst
  • kapitaltap
  • timer_uke
  • native_country
  • etikett

Du vil gå frem som følger før du trener og evaluerer modellen:

  • Trinn 1) Importer bibliotekene
  • Trinn 2) Importer dataene
  • Trinn 3) Forbered dataene
  • Trinn 4) Konstruer input_fn
  • Trinn 5) Konstruer logistikkmodellen: Grunnmodell
  • Trinn 6) Vurder modellen
  • Trinn 7) Konstruer kjerneklassifikatoren
  • Trinn 8) Evaluer kjerneklassifikatoren

Trinn 1) Importer bibliotekene

For å importere og trene kjernemodeller i Kunstig intelligens, du må 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

Trinn 2) Importer dataene

Du laster ned dataene fra følgende nettsted og du importerer den 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)

Nå som toget og testsettet er definert, kan du endre kolonneetiketten fra streng til heltall. tensorflow godtar ikke strengverdi 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)			

Trinn 3) Forbered dataene

Datasettet inneholder både kontinuerlige og kategoriske trekk. En god praksis er å standardisere verdiene til de kontinuerlige variablene. Du kan bruke funksjonen StandardScaler fra sci-kit learning. Du oppretter også en brukerdefinert funksjon for å gjøre det enklere å konvertere toget og testsettet. Merk at du kobler sammen de kontinuerlige og kategoriske variablene til et felles datasett og matrisen bør være av 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

Transformatorfunksjonen er klar, du kan konvertere datasettet og lage input_fn-funksjonen.

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 neste trinn skal du trene en logistisk regresjon. Det vil gi deg en grunnlinjenøyaktighet. Målet er å slå grunnlinjen med en annen algoritme, nemlig en kjerneklassifikator.

Trinn 4) Konstruer logistikkmodellen: Grunnmodell

Du konstruerer funksjonskolonnen med objektet real_valued_column. Det vil sørge for at alle variabler er tette numeriske data.

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

Estimatoren er definert ved hjelp av TensorFlow Estimator, du instruerer funksjonskolonnene og hvor grafen skal lagres.

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 vil trene den logiske regresjonen ved å bruke minibatcher i 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 trene modellen med 1.000 iterasjoner

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>

Trinn 6) Evaluer modellen

Du definerer numpy estimatoren for å evaluere modellen. Du bruker hele datasettet for 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øyaktighet på 82 prosent. I neste avsnitt vil du prøve å slå den logistiske klassifisereren med en kjerneklassifiserer

Trinn 7) Konstruer kjerneklassifikatoren

Kjerneestimatoren er ikke så forskjellig fra den tradisjonelle lineære klassifikatoren, i det minste når det gjelder konstruksjon. Ideen bak er å bruke kraften til eksplisitt kjerne med den lineære klassifikatoren.

Du trenger to forhåndsdefinerte estimatorer som er tilgjengelige i TensorFlow for å trene opp Kernel Classifier:

  • RandomFourierFeatureMapper
  • KernelLinearClassifier

Du lærte i den første delen at du må transformere den lave dimensjonen til en høy dimensjon ved hjelp av en kjernefunksjon. Mer presist vil du bruke Random Fourier, som er en tilnærming av Gauss-funksjonen. Heldigvis har Tensorflow funksjonen i biblioteket: RandomFourierFeatureMapper. Modellen kan trenes ved å bruke estimatoren KernelLinearClassifier.

For å bygge modellen, følger du disse trinnene:

  1. Angi kjernefunksjonen med høy dimensjon
  2. Still inn L2-hyperparameteren
  3. Bygg modellen
  4. Tren modellen
  5. Evaluer modellen

Trinn A) Angi kjernefunksjonen med høy dimensjon

Det gjeldende datasettet inneholder 14 funksjoner som du vil transformere til en ny høy dimensjon av den 5.000-dimensjonale vektoren. Du bruker de tilfeldige Fourier-funksjonene for å oppnå transformasjonen. Hvis du husker den Gaussiske kjerneformelen, merker du at det er standardavviksparameteren som skal defineres. Denne parameteren kontrollerer for likhetsmålet som brukes under klassifiseringen.

Du kan justere alle parameterne 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 må konstruere kjernekartleggingen ved å bruke funksjonskolonnene opprettet før: feat_column

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

Trinn B) Still inn L2-hyperparameteren

For å forhindre overtilpasning straffer du tapsfunksjonen med L2-regularizeren. Du setter L2-hyperparameteren til 0.1 og læringshastigheten til 5

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

Trinn C) Bygg modellen

Det neste trinnet ligner den lineære klassifiseringen. Du bruker den innebygde estimatoren KernelLinearClassifier. Merk at du legger til kjernekartleggingen som er definert tidligere og endrer modellkatalogen.

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

Trinn D) Tren modellen

Nå som Kernel-klassifisereren er bygget, er du klar til å trene den. Du velger å iterere 2000 ganger 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>]}})

Trinn E) Evaluer modellen

Sist, men ikke minst, evaluerer du ytelsen til modellen din. Du bør være i stand til å slå den logistiske regresjonen.

# 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øyaktigheten er 84 %, det er en forbedring på 2 % sammenlignet med den logistiske regresjonen. Det er en avveining mellom forbedret nøyaktighet og beregningskostnad. Du må tenke på om 2 % forbedring er verdt tiden som brukes av den forskjellige klassifisereren, og om det har en overbevisende innvirkning på virksomheten din.

Oppsummering

En kjerne er et flott verktøy for å transformere ikke-lineære data til (nesten) lineære. Ulempen med denne metoden er at den er beregningsmessig tidkrevende og kostbar.

Nedenfor finner du den viktigste koden for å trene en kjerneklassifiserer

Angi kjernefunksjonen med høy dimensjon

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

Still inn L2-hyperparameteren

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

Bygg modellen

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

Tren modellen

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

Evaluer modellen

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