Gaussisk kjerne i maskinlæring: Eksempler på kjernemetoder

Hensikten med denne opplæringen er å gjøre et datasett lineært å skille. 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 Kernel-metode i Machine Learning mens du i den andre delen vil se hvordan du kan trene en kjerneklassifiseringsenhet med Tensorflow. Du vil bruke datasettet for voksne. Målet med dette datasettet er å klassifisere inntektene under og over 50 000, med kunnskap om oppførselen til hver husstand.

I denne veiledningen vil du lære-

• Hvorfor trenger du kjernemetoder?
• Hva er en kjerne innen maskinlæring?
• Typer av kjernemetoder
• Tren Gaussian Kernel classifier med TensorFlow

Hvorfor trenger du kjernemetoder?

Målet med hver klassifikator er å forutsi klassene riktig. For det skal datasettet kunne skilles. Se på handlingen nedenfor; det er ganske enkelt å se at alle poeng over den svarte linjen tilhører første klasse og de andre peker til andre klasse. Det er imidlertid ekstremt sjelden å ha et datasett så enkelt. I de fleste tilfeller kan ikke data skilles fra hverandre. Kjernemetoder i maskinlæring gir naive klassifikatorer som en logistisk regresjon vanskelig.

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

I figuren nedenfor plotter vi et datasett som ikke kan skilles lineært. Hvis vi tegner 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 i et annet funksjonskart. Det betyr at du vil bruke en funksjon for å transformere dataene i en annen plan, som skal være lineær.

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-Gaussisk kjerneplan som ikke kan skilles. 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 polynomial kartlegging for å bringe dataene våre til en 3D-dimensjon. Formelen for å transformere dataene er som følger.

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

Du kan bruke numpy til å kode formelen ovenfor:

Formel	Tilsvarende Numpy Code
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

Den nye kartleggingen skal være i 3 dimensjoner med 16 poeng

x_1 = mapping(x, y)x_1.shape 

(3, 16) 

La oss lage et nytt plot med henholdsvis 3 akser, x, y og z.

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

Vi ser en forbedring, men hvis vi endrer orienteringen av plottet, er det klart at datasettet nå kan skilles

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

For å manipulere et stort datasett, og du må kanskje opprette mer enn to dimensjoner, vil du møte et stort problem ved hjelp av metoden ovenfor. Du må faktisk transformere alle datapunkter, noe som tydeligvis ikke er bærekraftig. Det vil ta deg aldre, og datamaskinen din kan gå tom for minne.

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

Hva er en kjerne innen maskinlæring?

Tanken er å bruke et funksjonsrom med høyere dimensjon for å gjøre dataene nesten atskillelige som vist i figuren ovenfor.

Det er mange rom med høyere dimensjon for å gjøre datapunktene adskillelige. For eksempel har vi vist at polynomkartleggingen er en flott start.

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

Kjernen i kjernen er å finne en funksjon som unngår alle problemer som den høydimensjonale beregningen innebærer. Resultatet av en kjerne er en skalar, eller sagt annerledes at vi er tilbake til et dimensjonalt rom

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

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

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

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

## Kernelx1 = 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 prikkproduktet

Du kan bruke objektpunktet fra numpy til å beregne punktproduktet mellom den første og andre vektoren som er 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 den polynomiske kjernen til å beregne prikkproduktet 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 beregner en kjernefunksjon resultatene av punktproduktet fra et annet funksjonsrom.

Du kan skrive polynom-kjernefunksjonen i Python som følger.

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

Det er kraften i prikkproduktet til to vektorer. Nedenfor returnerer du den andre graden av den polynomiske kjernen. Utgangen er lik den andre metoden. Dette er magien til kjernen.

polynomial_kernel(x1, x2, p=2)8100 

Typer av 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:

• Polynomkjerne
• Gaussisk kjerne

I eksemplet med TensorFlow vil vi bruke Random Fourier. TensorFlow har en innebygd estimator for å beregne det nye funksjonsområdet. Den Gaussiske filterfunksjonen er en tilnærming av den Gaussiske kjernefunksjonen.

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

Tren Gaussian Kernel classifier med TensorFlow

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

Du vil evaluere en logistisk Kernel Regression Machine Learning for å ha en referansemodell. Etter det vil du trene en Kernel classifier for å se om du kan få bedre resultater.

Du bruker følgende variabler fra voksendatasettet:

• alder
• arbeidsklasse
• fnlwgt
• utdanning
• utdanning_nummer
• ekteskapelig
• okkupasjon
• forhold
• løp
• kjønn
• kapital_gevinst
• kapital_tap
• times_uke
• hjemland
• merkelapp

Du fortsetter 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 den logistiske modellen: Baseline model
• Trinn 6) Evaluer modellen
• Trinn 7) Konstruer kjerneklassifisereren
• Trinn 8) Evaluer kjerneklassifisereren

Trinn 1) Importer bibliotekene

For å importere og trene kjernemodeller i kunstig intelligens, må du importere tensorflow, pandaer og numpy

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

Trinn 2) Importer dataene

Du laster ned dataene fra følgende nettside og importerer dem som en panda-dataramme.

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

Nå som toget og testsettet er definert, kan du endre kolonnetiketten 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 funksjoner. 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 lettere å konvertere toget og testsettet. Merk at du sammenføyer de kontinuerlige og kategoriske variablene til et vanlig datasett, og matrisen skal 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 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 

Transformatorfunksjonen er klar, du kan konvertere datasettet og opprette 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 vil du trene en logistisk regresjon. Det vil gi deg en nøyaktighet ved utgangspunktet. Målet er å slå basislinjen med en annen algoritme, nemlig en Kernel classifier.

Trinn 4) Konstruer den logistiske modellen: Baselinjemodell

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

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

Estimatoren defineres ved hjelp av TensorFlow Estimator, du instruerer funksjonskolonnene og hvor du skal lagre grafen.

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} 

Du vil trene logisitc-regresjonen ved hjelp av minibatcher i størrelse 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) 

Du kan trene modellen med 1.000 iterasjon

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.

Trinn 6) Evaluer modellen

Du definerer nummen estimator for å evaluere modellen. Du bruker hele datasettet for evaluering

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

Du har en nøyaktighet på 82 prosent. I neste avsnitt vil du prøve å slå den logistiske klassifisereren med en kjerneklassifiser

Trinn 7) Konstruer kjerneklassifisereren

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

Du trenger to forhåndsdefinerte estimatorer tilgjengelig i TensorFlow for å trene Kernel Classifier:

• RandomFourierFeatureMapper
• KernelLinearClassifier

Du lærte i den første delen at du trenger å 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 til den gaussiske funksjonen. Heldigvis har Tensorflow funksjonen i biblioteket: RandomFourierFeatureMapper. Modellen kan trenes ved hjelp av estimatoren KernelLinearClassifier.

For å bygge modellen følger du disse trinnene:

1. Angi kjernefunksjonen med høy dimensjon
2. Sett L2 hyperparameter
3. Bygg modellen
4. Tren modellen
5. Evaluer modellen

Trinn A) Still inn høydimensjons kjernefunksjon

Gjeldende datasett 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, bemerker du at det er standardavviksparameteren å definere. Denne parameteren styrer for likhetstiltaket som brukes under klassifiseringen.

Du kan stille inn alle parametrene i RandomFourierFeatureMapper med:

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

Du må konstruere kjernekartleggeren ved å bruke funksjonskolonnene opprettet før: feat_column

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

Trinn B) Sett L2 hyperparameter

For å forhindre overmontering, straffer du tapsfunksjonen med L2 regulator. Du setter L2 hyperparameter til 0,1 og læringsgraden til 5

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

Trinn C) Bygg modellen

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

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

Trinn D) Tren modellen

Nå som Kernel classifier er bygget, er du klar til å trene den. Du velger å gjenta 2000 ganger modellen

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

Trinn E) Evaluer modellen

Sist, men ikke minst, evaluerer du ytelsen til modellen din. Du burde 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 
 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

Den endelige nøyaktigheten er 84%, det er en forbedring på 2% sammenlignet med den logistiske regresjonen. Det er en kompromiss mellom nøyaktighetsforbedring og beregningskostnad. Du må tenke på om 2% forbedring er verdt den tid som den forskjellige klassifisereren bruker, og om det har en overbevisende innvirkning på virksomheten din.

Sammendrag

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

Nedenfor finner du den viktigste koden for å trene en kjerneklassifiser

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

Sett L2 hyperparameter

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)