Gaussisk kerne i maskinindlæring: Eksempler på kernemetoder

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

1. Funktionstransformation
2. Træn en kerneklassifikator 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 man træner en kerneklassifikator med Tensorflow. Du vil bruge datasættet for voksne. Formålet med dette datasæt er at klassificere indtægterne under og over 50.000 under kendskab til hver husstands opførsel.

I denne vejledning lærer du-

• Hvorfor har du brug for kernemetoder?
• Hvad er en kerne inden for maskinindlæring?
• Typer af kernemetoder
• Træn Gaussian Kernel klassificering med TensorFlow

Hvorfor har du brug for kernemetoder?

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

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 datasæt, der ikke kan adskilles lineært. Hvis vi tegner en lige linje, klassificeres de fleste punkter ikke i den rigtige klasse.

En måde at tackle dette problem på er at tage datasættet og omdanne dataene til et andet funktionskort. Det betyder, at du vil bruge en funktion til at transformere dataene i en anden 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 kerneplan, som ikke kan adskilles. Du kan prøve at transformere disse data i en tredimension, det betyder, at du opretter en figur med 3 akser.

I vores Gaussiske kerneeksempel anvender vi en polynomial kortlægning for at bringe vores data til en 3D-dimension. Formlen til at transformere data er som følger.

Du definerer en funktion i Gaussian Kernel Python for at oprette de nye funktionskort

Du kan bruge numpy til at kode ovenstående formel:

Formel	Ækvivalent 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 kortlægning skal have 3 dimensioner med 16 point

x_1 = mapping(x, y)x_1.shape 

(3, 16) 

Lad os lave et nyt 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 ændrer orienteringen af ​​plottet, er det klart, at datasættet nu kan adskilles

# 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 at manipulere et stort datasæt, og du bliver muligvis nødt til at oprette mere end 2 dimensioner, står du over for et stort problem ved hjælp af ovenstående metode. Faktisk skal du transformere alle datapunkter, hvilket tydeligvis ikke er bæredygtigt. Det tager dig aldre, og din computer kan løbe tør for hukommelse.

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

Hvad er en kerne inden for maskinindlæring?

Ideen er at bruge et rum 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, der gør datapunkterne adskillelige. For eksempel har vi vist, at den polynomiske kortlægning er en god start.

Vi har også vist, at med mange data er denne transformation ikke effektiv. I stedet kan du bruge en kernefunktion i Machine Learning til at ændre dataene uden at skifte til en ny funktionsplan.

Kernens magi er at finde en funktion, der undgår alle de problemer, som den højdimensionale beregning indebærer. Resultatet af en kerne er en skalar eller sagt anderledes, vi er tilbage til et dimensionelt rum

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

Lad os se et eksempel for at forstå begrebet Kernel Machine Learning. Du har to vektorer, x1 og x2. Målet er at skabe en højere dimension ved hjælp af en polynomial kortlægning. Outputtet er lig med prikproduktet på det nye funktionskort. Fra ovenstående metode skal du:

1. Transformer x1 og x2 til en ny dimension
2. Beregn prikproduktet: fælles for alle kerner
3. Transformer x1 og x2 til en ny dimension

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

## Kernelx1 = 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 objektet prik 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 ser problemet, du skal gemme et nyt kort over funktioner for at beregne prikproduktet. Hvis du har et datasæt med millioner af poster, er det beregningsmæssigt ineffektivt.

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

Du kan skrive den polynomiale kernefunktion i Python som følger.

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

Det er kraften i prikproduktet fra to vektorer. Nedenfor returnerer du anden grad af den polynomiske kerne. Outputtet er lig med den anden metode. Dette er kernens magi.

polynomial_kernel(x1, x2, p=2)8100 

Typer af kernemetoder

Der er mange forskellige kerneteknikker til rådighed. Den enkleste er den lineære kerne. Denne funktion fungerer ret godt til tekstklassificering. Den anden kerne er:

• Polynom kerne
• Gaussisk kerne

I eksemplet med TensorFlow bruger vi Random Fourier. TensorFlow har en indbygget estimator til at beregne det nye funktionsrum. 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 klassificering 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 til at have en benchmark-model. Derefter træner du en Kernel classifier for at se, om du kan få bedre resultater.

Du bruger følgende variabler fra voksendatasættet:

• alder
• arbejdsklasse
• fnlwgt
• uddannelse
• uddannelsesnummer
• ægteskab
• beskæftigelse
• forhold
• race
• køn
• kapital_gevinst
• kapital-tab
• timer_uge
• oprindelses land
• etiket

Du fortsætter 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: Baseline model
• Trin 6) Evaluer modellen
• Trin 7) Konstruer kerneklassifikatoren
• Trin 8) Evaluer kerneklassifikatoren

Trin 1) Importer bibliotekerne

For at importere og træne kernemodeller i kunstig intelligens skal 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

Trin 2) Importer dataene

Du downloader dataene fra følgende websted, og du 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) 

Nu hvor toget og testsættet er defineret, kan du ændre kolonnemærket 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 funktioner. En god praksis er at standardisere værdierne for de kontinuerlige variabler. Du kan bruge funktionen StandardScaler fra sci-kit learning. Du opretter også en brugerdefineret funktion for at gøre det lettere at konvertere toget og testsættet. Bemærk, at du sammenkæder de kontinuerlige og kategoriske variabler 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 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 

Transformerfunktionen er klar, du kan konvertere datasættet og oprette input_fn-funktionen.

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 det næste trin træner du en logistisk regression. Det giver dig en grundlæggende nøjagtighed. Målet er at slå basislinjen med en anden algoritme, nemlig en kerneklassifikator.

Trin 4) Konstruer den logistiske model: Baseline model

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': , '_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 logisitc-regression ved hjælp af mini-batches 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 træne modellen med 1.000 iteration

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.

Trin 6) Evaluer modellen

Du definerer den bedøvede estimator for at evaluere modellen. Du bruger hele datasættet til 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øjagtighed på 82 procent. I det næste afsnit vil du prøve at slå den logistiske klassifikator med en kerneklassificering

Trin 7) Konstruer kerneklassifikatoren

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

Du har brug for to foruddefinerede estimatorer til rådighed i TensorFlow for at træne Kernel Classifier:

• RandomFourierFeatureMapper
• KernelinearClassifier

Du lærte i det første afsnit, at du har brug for at omdanne 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 opbygge modellen skal du følge disse trin:

1. Indstil den høje dimension Kernel-funktion
2. Indstil L2 hyperparameter
3. Byg modellen
4. Træn modellen
5. Evaluer modellen

Trin A) Indstil den høje dimension Kernel-funktion

Det aktuelle 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-funktioner til at opnå transformationen. Hvis du husker den Gaussiske kerneformel, bemærker du, at der er standardafvigelsesparameteren at definere. Denne parameter styrer den lighedsmåling, der anvendes under klassificeringen.

Du kan indstille alle parametre 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 skal konstruere kernekortlæggeren ved hjælp af funktionskolonnerne oprettet før: feat_column

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

Trin B) Indstil L2 hyperparameter

For at forhindre overmontering straffer du tabsfunktionen med L2-regulatoren. Du indstiller L2 hyperparameter til 0,1 og læringshastigheden til 5

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

Trin C) Byg modellen

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

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

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

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

Trin E) Evaluer modellen

Sidst men ikke mindst evaluerer du ydeevnen for din model. Du skal 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 
 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øjagtighed er 84%, det er en forbedring på 2% sammenlignet med den logistiske regression. Der er en kompromis mellem nøjagtighedsforbedring og beregningsomkostninger. Du er nødt til at tænke, om 2% forbedring er værd at bruge den tid, som 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 omdanne ikke-lineære data til (næsten) lineære. Manglen ved denne metode er beregningsmæssigt tidskrævende og dyr.

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

Indstil den høje dimension Kernel-funktion

• 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 hyperparameter

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) 

Evaluer modellen

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