Gaussische kernel in machinaal leren: voorbeelden van kernelmethoden

Het doel van deze tutorial is om een ​​dataset lineair scheidbaar te maken. De tutorial is opgedeeld in twee delen:

1. Feature transformatie
2. Train een kernelclassificatie met Tensorflow

In het eerste deel zul je het idee achter een kernelmethode in Machine Learning begrijpen, terwijl je in het tweede deel zult zien hoe je een kernelclassificator kunt trainen met Tensorflow. U gebruikt de dataset voor volwassenen. Het doel van deze dataset is om de inkomsten onder en boven de 50.000 te classificeren, waarbij we het gedrag van elk huishouden kennen.

In deze tutorial leer je-

• Waarom heb je kernelmethoden nodig?
• Wat is een kernel in machine learning?
• Soorten kernelmethoden
• Train de Gauss-kernelclassificatie met TensorFlow

Waarom heb je kernelmethoden nodig?

Het doel van elke classifier is om de klassen correct te voorspellen. Daarvoor moet de dataset scheidbaar zijn. Kijk naar de onderstaande plot; het is vrij eenvoudig om te zien dat alle punten boven de zwarte lijn tot de eerste klasse behoren en de andere punten tot de tweede klasse. Het is echter uiterst zeldzaam om een ​​dataset zo eenvoudig te hebben. In de meeste gevallen zijn de gegevens niet te scheiden. Kernelmethoden in Machine Learning maken naïeve classificaties zoals een logistieke regressie moeilijk.

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

In onderstaande figuur plotten we een dataset die niet lineair te scheiden is. Als we een rechte lijn trekken, worden de meeste punten niet in de juiste klasse ingedeeld.

Een manier om dit probleem aan te pakken, is door de gegevensset te nemen en de gegevens om te zetten in een andere functiekaart. Het betekent dat u een functie gebruikt om de gegevens om te zetten in een ander plan, dat lineair zou moeten zijn.

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

De gegevens uit de bovenstaande afbeelding zijn in een 2D Gaussian Kernel-plan dat niet kan worden gescheiden. U kunt proberen deze gegevens in een driedimensionale vorm te transformeren, dit betekent dat u een figuur met 3 assen maakt.

In ons Gaussian Kernel-voorbeeld zullen we een polynomiale mapping toepassen om onze gegevens naar een 3D-dimensie te brengen. De formule om de gegevens te transformeren is als volgt.

U definieert een functie in Gaussian Kernel Python om de nieuwe feature maps te maken

U kunt numpy gebruiken om de bovenstaande formule te coderen:

Formule	Gelijkwaardige 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

De nieuwe mapping zou met 3 dimensies met 16 punten moeten zijn

x_1 = mapping(x, y)x_1.shape 

(3, 16) 

Laten we een nieuwe plot maken met respectievelijk 3 assen, x, y en 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() 

We zien een verbetering, maar als we de oriëntatie van de plot veranderen, is het duidelijk dat de dataset nu scheidbaar is

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

Als u een grote dataset wilt manipuleren en u wellicht meer dan 2 dimensies moet maken, zult u met de bovenstaande methode voor een groot probleem komen te staan. In feite moet u alle datapunten transformeren, wat duidelijk niet duurzaam is. Het kost u heel veel tijd en het kan zijn dat uw computer onvoldoende geheugen heeft.

De meest gebruikelijke manier om dit probleem op te lossen, is door een kernel te gebruiken .

Wat is een kernel in machine learning?

Het idee is om een ​​feature-ruimte met een hogere dimensie te gebruiken om de gegevens bijna lineair te scheiden, zoals weergegeven in de bovenstaande afbeelding.

Er zijn veel hoger dimensionale ruimtes om de datapunten scheidbaar te maken. We hebben bijvoorbeeld aangetoond dat het in kaart brengen van polynomen een goed begin is.

We hebben ook aangetoond dat deze transformatie met veel data niet efficiënt is. In plaats daarvan kunt u een kernelfunctie in Machine Learning gebruiken om de gegevens te wijzigen zonder over te schakelen naar een nieuw functieplan.

De magie van de kernel is om een ​​functie te vinden die alle problemen vermijdt die worden geïmpliceerd door de hoog-dimensionale berekening. Het resultaat van een kernel is een scalair, of anders gezegd: we zijn terug in de eendimensionale ruimte

Nadat u deze functie heeft gevonden, kunt u deze aansluiten op de standaard lineaire classificatie.

Laten we een voorbeeld bekijken om het concept van Kernel Machine Learning te begrijpen. Je hebt twee vectoren, x1 en x2. Het doel is om een ​​hogere dimensie te creëren door gebruik te maken van een polynoomafbeelding. De output is gelijk aan het puntproduct van de nieuwe feature map. Van de bovenstaande methode moet u:

1. Transformeer x1 en x2 in een nieuwe dimensie
2. Bereken het puntproduct: gemeenschappelijk voor alle kernels
3. Transformeer x1 en x2 in een nieuwe dimensie

U kunt de hierboven gemaakte functie gebruiken om de hogere dimensie te berekenen.

## Kernelx1 = np.array([3,6])x2 = np.array([10,10])x_1 = mapping(x1, x2)print(x_1) 

Uitvoer

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

Bereken het puntproduct

U kunt de objectpunt uit numpy gebruiken om het puntproduct te berekenen tussen de eerste en tweede vector die is opgeslagen in x_1.

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

De uitvoer is 8100. U ziet het probleem, u moet in het geheugen een nieuwe functiekaart opslaan om het puntproduct te berekenen. Als u een dataset met miljoenen records heeft, is deze rekenkundig ineffectief.

In plaats daarvan kunt u de polynoomkernel gebruiken om het puntproduct te berekenen zonder de vector te transformeren. Deze functie berekent het puntproduct van x1 en x2 alsof deze twee vectoren naar de hogere dimensie zijn getransformeerd. Anders gezegd, een kernelfunctie berekent de resultaten van het puntproduct uit een andere kenmerkruimte.

U kunt de polynoom-kernelfunctie in Python als volgt schrijven.

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

Het is de kracht van het puntproduct van twee vectoren. Hieronder retourneert u de tweede graad van de polynoomkernel. De output is gelijk aan de andere methode. Dit is de magie van de pit.

polynomial_kernel(x1, x2, p=2)8100 

Soorten kernelmethoden

Er zijn veel verschillende Kernel-technieken beschikbaar. De eenvoudigste is de lineaire kern. Deze functie werkt redelijk goed voor tekstclassificatie. De andere kernel is:

• Polynoom kernel
• Gaussische kernel

In het voorbeeld met TensorFlow zullen we de Random Fourier gebruiken. TensorFlow heeft een ingebouwde schatter om de nieuwe feature ruimte te berekenen. De Gauss-filterfunctie is een benadering van de Gauss-kernelfunctie.

De Gauss-filterfunctie berekent de overeenkomst tussen de gegevenspunten in een veel hogere dimensionale ruimte.

Train de Gauss-kernelclassificatie met TensorFlow

Het doel van het algoritme is om het huishouden te classificeren dat meer of minder verdient dan 50.000.

Je evalueert een logistieke kernelregressie Machine Learning om een ​​benchmarkmodel te hebben. Daarna ga je een kernelclassificator trainen om te zien of je betere resultaten kunt krijgen.

U gebruikt de volgende variabelen uit de dataset voor volwassenen:

• leeftijd
• werkklas
• fnlwgt
• onderwijs
• onderwijs_getal
• echtelijk
• bezetting
• relatie
• ras
• seks
• capital_gain
• capital_loss
• uur_week
• geboorteland
• label

Voordat u het model gaat trainen en evalueren, gaat u als volgt te werk:

• Stap 1) Importeer de bibliotheken
• Stap 2) Importeer de gegevens
• Stap 3) Bereid de gegevens voor
• Stap 4) Construeer de input_fn
• Stap 5) Construeer het logistieke model: Baselinemodel
• Stap 6) Evalueer het model
• Stap 7) Construeer de Kernel-classificator
• Stap 8) Evalueer de kernelclassificatie

Stap 1) Importeer de bibliotheken

Om kernelmodellen in kunstmatige intelligentie te importeren en te trainen, moet u tensorflow, panda's en numpy importeren

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

Stap 2) Importeer de gegevens

U downloadt de gegevens van de volgende website en u importeert deze als een panda dataframe.

## 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 de trein en testset zijn gedefinieerd, kunt u het kolomlabel wijzigen van string in integer. tensorflow accepteert geen tekenreekswaarde voor het label.

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)

Stap 3) Bereid de gegevens voor

De dataset bevat zowel continue als categorische kenmerken. Een goede gewoonte is om de waarden van de continue variabelen te standaardiseren. U kunt de functie StandardScaler van sci-kit learn gebruiken. U creëert ook een door de gebruiker gedefinieerde functie om het ombouwen van de trein en testset te vergemakkelijken. Merk op dat u de continue en categorische variabelen samenvoegt tot een gemeenschappelijke gegevensset en dat de array van het type moet zijn: 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 

De transformatorfunctie is klaar, u kunt de dataset converteren en de functie input_fn maken.

X_train, y_train = prep_data_str(df_train)X_test, y_test = prep_data_str(df_test)print(X_train.shape)(32561, 14) 

In de volgende stap train je een logistieke regressie. Het geeft je een basisnauwkeurigheid. Het doel is om de basislijn te verslaan met een ander algoritme, namelijk een kernelclassificatie.

Stap 4) Construeer het logistieke model: Baselinemodel

U construeert de objectkolom met het object real_valued_column. Het zorgt ervoor dat alle variabelen compacte numerieke gegevens zijn.

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

De schatter wordt gedefinieerd met behulp van TensorFlow Estimator, u instrueert de objectkolommen en waar de grafiek moet worden opgeslagen.

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} 

Je traint de logische regressie met behulp van mini-batches van grootte 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) 

Je kunt het model trainen met 1.000 iteratie

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.

Stap 6) Evalueer het model

U definieert de numpy-schatter om het model te evalueren. U gebruikt de volledige dataset voor evaluatie

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

Je hebt een nauwkeurigheid van 82 procent. In de volgende sectie ga je proberen om de logistieke classifier te verslaan met een Kernel classifier

Stap 7) Construeer de Kernel-classificator

De kernelschatter verschilt niet zo veel van de traditionele lineaire classificator, althans qua constructie. Het idee erachter is om de kracht van een expliciete kernel te gebruiken met de lineaire classificator.

U hebt twee vooraf gedefinieerde schatters nodig die beschikbaar zijn in TensorFlow om de Kernel Classifier te trainen:

• RandomFourierFeatureMapper
• KernelLinearClassifier

Je hebt in de eerste sectie geleerd dat je de lage dimensie moet transformeren naar een hoge dimensie met behulp van een kernelfunctie. Om precies te zijn, u zult de Random Fourier gebruiken, wat een benadering is van de Gauss-functie. Gelukkig heeft Tensorflow de functie in zijn bibliotheek: RandomFourierFeatureMapper. Het model kan worden getraind met behulp van de schatter KernelLinearClassifier.

Om het model te bouwen, volgt u deze stappen:

1. Stel de Kernel-functie met hoge dimensie in
2. Stel de L2-hyperparameter in
3. Bouw het model
4. Train het model
5. Evalueer het model

Stap A) Stel de Kernel-functie met hoge dimensie in

De huidige dataset bevat 14 features die je gaat transformeren naar een nieuwe hoge dimensie van de 5.000-dimensionale vector. U gebruikt de willekeurige Fourier-functies om de transformatie te bereiken. Als u zich de Gaussiaanse kernelformule herinnert, merkt u op dat er de standaarddeviatieparameter moet worden gedefinieerd. Deze parameter bepaalt voor de maatstaf voor gelijkenis die tijdens de classificatie wordt gebruikt.

U kunt alle parameters in RandomFourierFeatureMapper afstemmen met:

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

U moet de kernel-mapper construeren met behulp van de feature-kolommen die eerder zijn gemaakt: feat_column

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

Stap B) Stel de L2-hyperparameter in

Om overfitting te voorkomen, bestraf je de verliesfunctie met de L2 regularizer. U stelt de L2-hyperparameter in op 0,1 en de leertempo op 5

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

Stap C) Bouw het model

De volgende stap is vergelijkbaar met de lineaire classificatie. U gebruikt de ingebouwde schatter KernelLinearClassifier. Merk op dat u de eerder gedefinieerde kernel-mapper toevoegt en de modeldirectory wijzigt.

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

Stap D) Train het model

Nu de kernelclassificatie is gebouwd, bent u klaar om deze te trainen. U kiest ervoor om 2000 keer het model te herhalen

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

Stap E) Evalueer het model

Ten slotte evalueert u de prestaties van uw model. Je zou de logistieke regressie moeten kunnen verslaan.

# 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

De uiteindelijke nauwkeurigheid is 84%, het is een verbetering van 2% ten opzichte van de logistische regressie. Er is een afweging tussen nauwkeurigheidsverbetering en computerkosten. U moet nadenken of 2% verbetering de tijd waard is die door de andere classificator wordt verbruikt en of dit een overtuigende impact heeft op uw bedrijf.

Overzicht

Een kernel is een geweldig hulpmiddel om niet-lineaire gegevens om te zetten naar (bijna) lineair. De tekortkoming van deze methode is dat ze rekenkundig tijdrovend en kostbaar is.

Hieronder vind je de belangrijkste code om een ​​kernel classifer te trainen

Stel de Kernel-functie met hoge dimensie in

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

Stel de L2-hyperparameter in

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

Bouw het model

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

Train het model

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

Evalueer het model

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