Gaussisk kärna i maskininlärning: exempel på kärnmetoder

Syftet med denna handledning är att göra en dataset linjärt åtskiljbar. Självstudien är uppdelad i två delar:

1. Funktionstransformation
2. Träna en Kernel classifier med Tensorflow

I den första delen kommer du att förstå idén bakom en Kernel-metod i Machine Learning medan du i den andra delen kommer att se hur man tränar en kärnklassificering med Tensorflow. Du kommer att använda den vuxna datamängden. Målet med denna dataset är att klassificera intäkterna under och över 50 000, med kännedom om varje hushålls beteende.

I denna handledning lär du dig-

• Varför behöver du kärnmetoder?
• Vad är en kärna inom maskininlärning?
• Typer av kärnmetoder
• Träna Gaussian Kernel classifier med TensorFlow

Varför behöver du kärnmetoder?

Syftet med varje klassificerare är att förutsäga klasserna korrekt. För det bör datasetet kunna separeras. Titta på tomten nedan; det är ganska enkelt att se att alla punkter ovanför den svarta linjen tillhör den första klassen och de andra punkterna till den andra klassen. Det är dock extremt sällsynt att ha en så enkel dataset. I de flesta fall är uppgifterna inte separerbara. Kärnmetoderna i maskininlärning ger naiva klassificatorer som en logistisk regression svårt.

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 nedan plottar vi en datauppsättning som inte kan separeras linjärt. Om vi ​​drar en rak linje kommer de flesta punkterna inte att klassificeras i rätt klass.

Ett sätt att ta itu med detta problem är att ta datauppsättningen och omvandla data till en annan funktionskarta. Det betyder att du kommer att använda en funktion för att transformera data i en annan plan, som ska vara linjä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() 

Uppgifterna från figuren ovan finns i en 2D-Gaussisk kärnplan som inte kan separeras. Du kan försöka transformera dessa data i en tredimension, det betyder att du skapar en figur med 3 axlar.

I vårt Gaussian Kernel-exempel kommer vi att tillämpa en polynomkartläggning för att få våra data till en 3D-dimension. Formeln för att transformera data är som följer.

Du definierar en funktion i Gaussian Kernel Python för att skapa de nya funktionskartorna

Du kan använda numpy för att koda ovanstående formel:

Formel	Motsvarande 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 nya kartläggningen ska ha tre dimensioner med 16 poäng

x_1 = mapping(x, y)x_1.shape 

(3, 16) 

Låt oss skapa ett nytt diagram med 3 axlar, x, y respektive 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 förbättring, men om vi ändrar orienteringen av plottet är det tydligt att dataset nu kan separeras

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

För att manipulera en stor dataset och du kan behöva skapa mer än två dimensioner, kommer du att möta ett stort problem med ovanstående metod. I själva verket måste du omvandla alla datapunkter, vilket helt klart inte är hållbart. Det kommer att ta dig åldrar och din dator kan ta slut på minne.

Det vanligaste sättet att lösa problemet är att använda en kärna .

Vad är en kärna inom maskininlärning?

Tanken är att använda ett högre-dimensionerat funktionsutrymme för att göra data nästan linjärt åtskiljbara som visas i figuren ovan.

Det finns gott om högre dimensionella utrymmen för att göra datapunkterna separerbara. Vi har till exempel visat att polynomkartläggningen är en bra start.

Vi har också visat att omvandlingen inte är effektiv med mycket data. Istället kan du använda en Kernel-funktion i Machine Learning för att ändra data utan att ändra till en ny funktionsplan.

Kärnans magi är att hitta en funktion som undviker alla problem som den högdimensionella beräkningen innebär. Resultatet av en kärna är en skalär, eller sagt annorlunda, vi är tillbaka till ett dimensionellt utrymme

När du har hittat den här funktionen kan du ansluta den till standard linjär klassificerare.

Låt oss se ett exempel för att förstå begreppet Kernel Machine Learning. Du har två vektorer, x1 och x2. Målet är att skapa en högre dimension genom att använda en polynomkartläggning. Utgången är lika med punktprodukten på den nya funktionskartan. Från metoden ovan måste du:

1. Förvandla x1 och x2 till en ny dimension
2. Beräkna punktprodukten: gemensam för alla kärnor
3. Förvandla x1 och x2 till en ny dimension

Du kan använda funktionen som skapats ovan för att beräkna den högre dimensionen.

## 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. ]] 

Beräkna prickprodukten

Du kan använda objektet dot från numpy för att beräkna dot-produkten mellan den första och andra vektorn som lagras i x_1.

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

Utgången är 8100. Du ser problemet, du måste lagra en ny funktionskarta för att beräkna punktprodukten i minnet. Om du har en datauppsättning med miljontals poster är den beräkningsmässigt ineffektiv.

Istället kan du använda polynomkärnan för att beräkna punktprodukten utan att transformera vektorn. Denna funktion beräknar punktprodukten av x1 och x2 som om dessa två vektorer har transformerats till den högre dimensionen. Sagt annorlunda beräknar en kärnfunktion resultatet av punktprodukten från ett annat funktionsutrymme.

Du kan skriva polynomfunktionen i Python enligt följande.

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

Det är kraften i punktprodukten i två vektorer. Nedan returnerar du den andra graden av polynomkärnan. Utgången är lika med den andra metoden. Detta är kärnans magi.

polynomial_kernel(x1, x2, p=2)8100 

Typer av kärnmetoder

Det finns många olika kärntekniker tillgängliga. Det enklaste är den linjära kärnan. Denna funktion fungerar ganska bra för textklassificering. Den andra kärnan är:

• Polynomkärna
• Gaussisk kärna

I exemplet med TensorFlow kommer vi att använda Random Fourier. TensorFlow har en inbyggd estimator för att beräkna det nya funktionsutrymmet. Den Gaussiska filterfunktionen är en approximation av den Gaussiska kärnfunktionen.

Den Gaussiska filtreringsfunktionen beräknar likheten mellan datapunkterna i ett mycket högre dimensionellt utrymme.

Träna Gaussian Kernel classifier med TensorFlow

Målet med algoritmen är att klassificera hushållet som tjänar mer eller mindre än 50 000.

Du kommer att utvärdera en logistisk Kernel Regression Machine Learning för att ha en standardmodell. Därefter tränar du en Kernel-klassificering för att se om du kan få bättre resultat.

Du använder följande variabler från den vuxna datamängden:

• ålder
• arbetsklass
• fnlwgt
• utbildning
• utbildning_num
• äktenskaplig
• ockupation
• relation
• lopp
• sex
• kapitalvinsten
• kapitalförlust
• timmar_vecka
• hemland
• märka

Du fortsätter enligt följande innan du tränar och utvärderar modellen:

• Steg 1) Importera biblioteken
• Steg 2) Importera data
• Steg 3) Förbered data
• Steg 4) Konstruera input_fn
• Steg 5) Konstruera den logistiska modellen: Baslinjemodell
• Steg 6) Utvärdera modellen
• Steg 7) Konstruera Kernel classifier
• Steg 8) Utvärdera Kernel classifier

Steg 1) Importera biblioteken

För att importera och träna Kernel-modeller i artificiell intelligens måste du importera tensorflow, pandor och numpy

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

Steg 2) Importera data

Du laddar ner data från följande webbplats och importerar den som en panda-dataram.

## 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 när tåget och testuppsättningen är definierade kan du ändra kolumnetiketten från sträng till heltal. tensorflow accepterar inte strängvärde för 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)

Steg 3) Förbered data

Datauppsättningen innehåller både kontinuerliga och kategoriska funktioner. En god praxis är att standardisera värdena för de kontinuerliga variablerna. Du kan använda funktionen StandardScaler från sci-kit lär. Du skapar också en användardefinierad funktion för att göra det lättare att konvertera tåget och testuppsättningen. Observera att du sammanfogar de kontinuerliga och kategoriska variablerna till en gemensam dataset och matrisen ska vara 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 

Transformatorfunktionen är klar, du kan konvertera datasetet och skapa 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 nästa steg kommer du att träna en logistisk regression. Det ger dig en grundnivå. Målet är att slå baslinjen med en annan algoritm, nämligen en Kernel classifier.

Steg 4) Konstruera den logistiska modellen: baslinjemodell

Du konstruerar funktionskolumnen med objektet real_valued_column. Det kommer att se till att alla variabler är täta numeriska data.

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

Uppskattaren definieras med hjälp av TensorFlow Estimator, du instruerar funktionskolumnerna och var grafen ska sparas.

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änar logisitc-regressionen med hjälp av minibatcher i storlek 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äna 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.

Steg 6) Utvärdera modellen

Du definierar numpy estimator för att utvärdera modellen. Du använder hela datasetet för utvärdering

# 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 noggrannhet på 82 procent. I nästa avsnitt försöker du slå den logistiska klassificeraren med en Kernel-klassificerare

Steg 7) Konstruera Kernel classifier

Kärnuppskattaren skiljer sig inte så mycket från den traditionella linjära klassificeraren, åtminstone när det gäller konstruktion. Tanken bakom är att använda kraften i den explicita kärnan med den linjära klassificeraren.

Du behöver två fördefinierade estimatorer tillgängliga i TensorFlow för att träna Kernel Classifier:

• RandomFourierFeatureMapper
• KernelLinearClassifier

Du lärde dig i det första avsnittet att du måste förvandla den låga dimensionen till en hög dimension med en kärnfunktion. Mer exakt kommer du att använda Random Fourier, vilket är en approximation av den Gaussiska funktionen. Lyckligtvis har Tensorflow funktionen i sitt bibliotek: RandomFourierFeatureMapper. Modellen kan tränas med hjälp av beräknaren KernelLinearClassifier.

För att bygga modellen följer du dessa steg:

1. Ställ in kärnfunktionen med hög dimension
2. Ställ in L2 hyperparameter
3. Bygg modellen
4. Träna modellen
5. Utvärdera modellen

Steg A) Ställ in kärnfunktionen med hög dimension

Den aktuella datasetet innehåller 14 funktioner som du kommer att omvandla till en ny hög dimension av den 5.000-dimensionella vektorn. Du använder de slumpmässiga Fourier-funktionerna för att uppnå transformationen. Om du kommer ihåg Gaussisk kärnformel, noterar du att det finns standardavvikelseparametern att definiera. Denna parameter styr för likhetsmåttet som används under klassificeringen.

Du kan ställa in alla parametrar 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åste konstruera kärnmapparen med hjälp av funktionskolumnerna som skapats tidigare: feat_column

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

Steg B) Ställ in L2-hyperparametern

För att förhindra övermontering straffar du förlustfunktionen med L2-regulatorn. Du ställer in L2 hyperparameter till 0,1 och inlärningshastigheten till 5

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

Steg C) Bygg modellen

Nästa steg liknar den linjära klassificeringen. Du använder den inbyggda beräknaren KernelLinearClassifier. Observera att du lägger till den tidigare definierade kärnmapparen och ändrar 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'}

Steg D) Träna modellen

Nu när Kernel-klassificeraren är byggd är du redo att träna den. Du väljer att itera 2000 gånger 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): []}}) 

Steg E) Utvärdera modellen

Sist men inte minst utvärderar du prestanda för din modell. Du borde kunna slå den logistiska regressionen.

# 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 slutliga noggrannheten är 84%, det är en 2% förbättring jämfört med logistisk regression. Det finns en kompromiss mellan noggrannhetsförbättring och beräkningskostnad. Du måste tänka om 2% förbättring värt den tid som den olika klassificeringen tar och om det har en tvingande inverkan på ditt företag.

Sammanfattning

En kärna är ett utmärkt verktyg för att omvandla icke-linjär data till (nästan) linjär. Bristen på denna metod är att den är tidsberäknande och kostsamt.

Nedan hittar du den viktigaste koden för att träna en kärnklassificering

Ställ in kärnfunktionen med hög dimension

• input_dim = 14
• output_dim = 5000
• stddev = 4

### Prep Kernelkernel_mapper = tf.contrib.kernel_methods.RandomFourierFeatureMapper(input_dim=14, output_dim=5000, stddev=4, name='rffm') 

Ställ in 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") 

Träna modellen

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

Utvärdera modellen

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