Gaussisk kärna i maskininlärning: Python Kärnmetoder
Evelyn Clarke
Syftet med denna handledning är att göra en datauppsättning linjärt separerbar. Handledningen är uppdelad i två delar:
- Funktionsförvandling
- Träna en kärnklassificerare med Tensorflow
I den första delen kommer du att förstå tanken bakom en Kernel-metod i Machine Learning medan du i den andra delen kommer att se hur du tränar en kärnklassificerare med Tensorflow. Du kommer att använda vuxendatauppsättningen. Syftet med denna datauppsättning är att klassificera intäkterna under och över 50k, med kännedom om varje hushålls beteende.
Varför behöver du Kernel Methods?
Syftet med varje klassificerare är att förutsäga klasserna korrekt. För det bör datasetet vara separerbart. Titta på handlingen 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 datauppsättning så enkel. I de flesta fall är uppgifterna inte separerbara. Kärnmetoder i Machine Learning ger naiva klassificerare som en logistisk regression en svår tid.
import numpy as np import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D
x_lin = np.array([1,2,3,4,5,6,7,8,9,10]) y_lin = np.array([2,2,3,2,2,9,6,8,8,9]) label_lin = np.array([0,0,0,0,0,1,1,1,1,1]) fig = plt.figure() ax=fig.add_subplot(111) plt.scatter(x_lin, y_lin, c=label_lin, s=60) plt.plot([-2.5, 10], [12.5, -2.5], 'k-', lw=2) ax.set_xlim([-5,15]) ax.set_ylim([-5,15])plt.show()
I figuren nedan plottar vi en datauppsättning som inte är linjärt separerbar. Om vi drar en rak linje kommer de flesta av punkterna inte att klassas i rätt klass.
Ett sätt att ta itu med detta problem är att ta datamängden och omvandla data till en annan funktionskarta. Det betyder att du kommer att använda en funktion för att omvandla data till en annan plan, som bör 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()
Data från figuren ovan finns i en 2D Gaussian Kernel-plan som inte är separerbar. Du kan försöka transformera dessa data i en tredimensionell, det betyder att du skapar en figur med 3 axlar.
I vårt exempel på Gaussisk kärna kommer vi att tillämpa en polynommappning för att få våra data till en 3D-dimension. Formeln för att transformera data är följande.
Du definierar en funktion i Gaussian Kernel Python för att skapa de nya funktionskartorna
Du kan använda numpy för att koda formeln ovan:
| Formel | Motsvarande Numpy-kod |
|---|---|
| x | x[:,0]** |
| y | x[:,1] |
| x2 | x[:,0]**2 |
 |
np.sqrt(2)* |
| xy | x[:,0]*x[:,1] |
| y2 | x[:,1]**2 |
### illustration purpose
def mapping(x, y):
x = np.c_[(x, y)]
if len(x) > 2:
x_1 = x[:,0]**2
x_2 = np.sqrt(2)*x[:,0]*x[:,1]
x_3 = x[:,1]**2
else:
x_1 = x[0]**2
x_2 = np.sqrt(2)*x[0]*x[1]
x_3 = x[1]**2
trans_x = np.array([x_1, x_2, x_3])
return trans_x
Den nya kartläggningen ska vara med 3 dimensioner med 16 punkter
x_1 = mapping(x, y) x_1.shape
(3, 16)
Låt oss göra en ny plot med 3 axlar, x, y respektive z.
# plot
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(x_1[0], x_1[1], x_1[2], c=label, s=60)
ax.view_init(30, 185)ax.set_xlabel('X Label')
ax.set_ylabel('Y Label')
ax.set_zlabel('Z Label')
plt.show()
Vi ser en förbättring men om vi ändrar orienteringen av plotten är det tydligt att datamängden nu är separerbar
# plot
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(x_1[0], x_1[1], x_1[1], c=label, s=60)
ax.view_init(0, -180)ax.set_ylim([150,-50])
ax.set_zlim([-10000,10000])
ax.set_xlabel('X Label')
ax.set_ylabel('Y Label')
ax.set_zlabel('Z Label')plt.show()
För att manipulera en stor datamängd och du kanske måste skapa mer än 2 dimensioner, kommer du att möta ett stort problem med ovanstående metod. Faktum är att du måste omvandla alla datapunkter, vilket helt klart inte är hållbart. Det kommer att ta dig åldrar och din dator kan få slut på minne.
Det vanligaste sättet att övervinna detta problem är att använda en kernel.
Vad är en kärna i maskininlärning?
Tanken är att använda ett funktionsutrymme med högre dimensioner för att göra data nästan linjärt separerbara som visas i figuren ovan.
Det finns gott om utrymmen med högre dimensioner för att göra datapunkterna separerbara. Till exempel har vi visat att polynomavbildningen är en bra början.
Vi har också visat att med massor av data är denna transformation inte effektiv. Istället kan du använda en kärnfunktion i maskininlärning för att ändra data utan att byta till en ny funktionsplan.
Det magiska med kärnan ä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 endimensionell rymd
När du har hittat den här funktionen kan du ansluta den till den vanliga linjära klassificeraren.
Låt oss se ett exempel för att förstå konceptet med Kernel Machine Learning. Du har två vektorer, x1 och x2. Målet är att skapa en högre dimension genom att använda en polynomavbildning. Utdata är lika med punktprodukten för den nya funktionskartan. Från metoden ovan måste du:
- Förvandla x1 och x2 till en ny dimension
- Beräkna punktprodukten: gemensam för alla kärnor
- 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.
## Kernel x1 = 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 punktprodukten
Du kan använda objektpunkten från numpy för att beräkna punktprodukten mellan den första och andra vektorn lagrad 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 i minnet för att beräkna punktprodukten. Om du har en datauppsättning med miljontals poster är den beräkningsmässigt ineffektiv.
Istället kan du använda polynom kärna 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, en kärnfunktion beräknar resultaten av punktprodukten från ett annat funktionsutrymme.
Du kan skriva polynomets kärnfunktion i Python som följer.
def polynomial_kernel(x, y, p=2): return (np.dot(x, y)) ** p
Det är kraften hos punktprodukten av 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 massor av olika kärntekniker tillgängliga. Den 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-klassificerare med TensorFlow
Målet med algoritmen är att klassificera hushållet som tjänar mer eller mindre än 50k.
Du kommer att utvärdera en logistisk Kernel Regression Machine Learning för att ha en benchmarkmodell. Efter det kommer du att träna en Kernel-klassificerare för att se om du kan få bättre resultat.
Du använder följande variabler från datauppsättningen för vuxna:
- ålder
- arbetsklass
- fnlwgt
- utbildning
- utbildningsnummer
- äktenskaplig
- ockupation
- relation
- lopp
- kön
- kapitalvinsten
- kapitalförlust
- timmar_vecka
- hemland
- etikett
Du kommer att gå tillväga 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 logistikmodellen: Baslinjemodell
- Steg 6) Utvärdera modellen
- Steg 7) Konstruera Kernel-klassificeraren
- Steg 8) Utvärdera Kernel-klassificeraren
Steg 1) Importera biblioteken
För att importera och träna Kernel-modeller i Artificiell intelligens, du måste importera tensorflow, pandor och klumpigt
#import numpy as np from sklearn.model_selection import train_test_split import tensorflow as tf import pandas as pd import numpy as np
Steg 2) Importera data
Du laddar ner data från följande webbplats och du importerar den som en pandadataram.
## Define path data COLUMNS = ['age','workclass', 'fnlwgt', 'education', 'education_num', 'marital', 'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss', 'hours_week', 'native_country', 'label'] PATH = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data" PATH_test ="https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.test "## Import df_train = pd.read_csv(PATH, skipinitialspace=True, names = COLUMNS, index_col=False) df_test = pd.read_csv(PATH_test,skiprows = 1, skipinitialspace=True, names = COLUMNS, index_col=False)
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 learning. Du skapar också en användardefinierad funktion för att göra det enklare att konvertera tåget och testsetet. Observera att du sammanfogar de kontinuerliga och kategoriska variablerna till en gemensam datauppsättning och matrisen bör 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 StandardScaler
from sklearn import preprocessing
def prep_data_str(df):
scaler = StandardScaler()
le = preprocessing.LabelEncoder()
df_toscale = df[COLUMNS_INT]
df_scaled = scaler.fit_transform(df_toscale.astype(np.float64))
X_1 = df[CATE_FEATURES].apply(le.fit_transform)
y = df['label'].astype(np.int32)
X_conc = np.c_[df_scaled, X_1].astype(np.float32)
return X_conc, y
Transformatorfunktionen är klar, du kan konvertera datasetet och skapa funktionen input_fn.
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 tränar du en logistisk regression. Det kommer att ge dig en baslinjenoggrannhet. Målet är att slå baslinjen med en annan algoritm, nämligen en Kernel-klassificerare.
Steg 4) Konstruera logistikmodellen: 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)
Estimatorn definieras med 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': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1a2003f780>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
Du kommer att träna den logistiska regressionen med hjälp av minibatcher av storlek 200.
# Train the model
train_input_fn = tf.estimator.inputs.numpy_input_fn(
x={"features": X_train},
y=y_train,
batch_size=200,
num_epochs=None,
shuffle=True)
Du kan träna modellen med 1.000 XNUMX iterationer
estimator.train(input_fn=train_input_fn, steps=1000)
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Create CheckpointSaverHook. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Saving checkpoints for 1 into kernel_log/model.ckpt. INFO:tensorflow:loss = 138.62949, step = 1 INFO:tensorflow:global_step/sec: 324.16 INFO:tensorflow:loss = 87.16762, step = 101 (0.310 sec) INFO:tensorflow:global_step/sec: 267.092 INFO:tensorflow:loss = 71.53657, step = 201 (0.376 sec) INFO:tensorflow:global_step/sec: 292.679 INFO:tensorflow:loss = 69.56703, step = 301 (0.340 sec) INFO:tensorflow:global_step/sec: 225.582 INFO:tensorflow:loss = 74.615875, step = 401 (0.445 sec) INFO:tensorflow:global_step/sec: 209.975 INFO:tensorflow:loss = 76.49044, step = 501 (0.475 sec) INFO:tensorflow:global_step/sec: 241.648 INFO:tensorflow:loss = 66.38373, step = 601 (0.419 sec) INFO:tensorflow:global_step/sec: 305.193 INFO:tensorflow:loss = 87.93341, step = 701 (0.327 sec) INFO:tensorflow:global_step/sec: 396.295 INFO:tensorflow:loss = 76.61518, step = 801 (0.249 sec) INFO:tensorflow:global_step/sec: 359.857 INFO:tensorflow:loss = 78.54885, step = 901 (0.277 sec) INFO:tensorflow:Saving checkpoints for 1000 into kernel_log/model.ckpt. INFO:tensorflow:Loss for final step: 67.79706. <tensorflow.python.estimator.canned.linear.LinearClassifier at 0x1a1fa3cbe0>
Steg 6) Utvärdera modellen
Du definierar numpy estimatorn för att utvärdera modellen. Du använder hela datasetet för utvärdering
# Evaluation
test_input_fn = tf.estimator.inputs.numpy_input_fn(
x={"features": X_test},
y=y_test,
batch_size=16281,
num_epochs=1,
shuffle=False)
estimator.evaluate(input_fn=test_input_fn, steps=1)
INFO:tensorflow:Calling model_fn. WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead. WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Starting evaluation at 2018-07-12-15:58:22 INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from kernel_log/model.ckpt-1000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Evaluation [1/1] INFO:tensorflow:Finished evaluation at 2018-07-12-15:58:23 INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.82353663, accuracy_baseline = 0.76377374, auc = 0.84898686, auc_precision_recall = 0.67214864, average_loss = 0.3877216, global_step = 1000, label/mean = 0.23622628, loss = 6312.495, precision = 0.7362797, prediction/mean = 0.21208474, recall = 0.39417577
{'accuracy': 0.82353663,
'accuracy_baseline': 0.76377374,
'auc': 0.84898686,
'auc_precision_recall': 0.67214864,
'average_loss': 0.3877216,
'global_step': 1000,
'label/mean': 0.23622628,
'loss': 6312.495,
'precision': 0.7362797,
'prediction/mean': 0.21208474,
'recall': 0.39417577}
Du har en noggrannhet på 82 procent. I nästa avsnitt kommer du att försöka slå den logistiska klassificeraren med en Kernel-klassificerare
Steg 7) Konstruera Kernel-klassificeraren
Kärnestimatorn skiljer sig inte så mycket från den traditionella linjära klassificeraren, åtminstone vad gäller konstruktion. Tanken bakom är att använda kraften hos explicit kärna 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 omvandla den låga dimensionen till en hög dimension med hjälp av en kärnfunktion. Mer exakt kommer du att använda Random Fourier, som är en approximation av Gauss-funktionen. Som tur är har Tensorflow funktionen i sitt bibliotek: RandomFourierFeatureMapper. Modellen kan tränas med hjälp av estimatorn KernelLinearClassifier.
För att bygga modellen följer du dessa steg:
- Ställ in den höga kärnfunktionen
- Ställ in hyperparametern L2
- Bygg modellen
- Träna modellen
- Utvärdera modellen
Steg A) Ställ in den höga kärnfunktionen
Den nuvarande datamängden innehåller 14 funktioner som du kommer att omvandla till en ny hög dimension av den 5.000 XNUMX-dimensionella vektorn. Du använder de slumpmässiga Fourier-funktionerna för att uppnå transformationen. Om du kommer ihåg formeln Gaussian Kernel, 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 Kernel kernel_mapper = tf.contrib.kernel_methods.RandomFourierFeatureMapper(input_dim=14, output_dim=5000, stddev=4, name='rffm')
Du måste konstruera kärnmapparen genom att använda funktionskolumnerna som skapats innan: feat_column
### Map Kernel
kernel_mappers = {feat_column: [kernel_mapper]}
Steg B) Ställ in hyperparametern L2
För att förhindra övermontering straffar du förlustfunktionen med L2-regularizern. Du ställer in hyperparametern L2 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 estimatorn KernelLinearClassifier. Observera att du lägger till den tidigare definierade kärnmapparen och ändrar modellkatalogen.
### Prep estimator
estimator_kernel = tf.contrib.kernel_methods.KernelLinearClassifier(
n_classes=2,
optimizer=optimizer,
kernel_mappers=kernel_mappers,
model_dir="kernel_train")
WARNING:tensorflow:From /Users/Thomas/anaconda3/envs/hello-tf/lib/python3.6/site-packages/tensorflow/contrib/kernel_methods/python/kernel_estimators.py:305: multi_class_head (from tensorflow.contrib.learn.python.learn.estimators.head) is deprecated and will be removed in a future version.
Instructions for updating:
Please switch to tf.contrib.estimator.*_head.
WARNING:tensorflow:From /Users/Thomas/anaconda3/envs/hello-tf/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/estimators/estimator.py:1179: BaseEstimator.__init__ (from tensorflow.contrib.learn.python.learn.estimators.estimator) is deprecated and will be removed in a future version.
Instructions for updating:
Please replace uses of any Estimator from tf.contrib.learn with an Estimator from tf.estimator.*
WARNING:tensorflow:From /Users/Thomas/anaconda3/envs/hello-tf/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/estimators/estimator.py:427: RunConfig.__init__ (from tensorflow.contrib.learn.python.learn.estimators.run_config) is deprecated and will be removed in a future version.
Instructions for updating:
When switching to tf.estimator.Estimator, use tf.estimator.RunConfig instead.
INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_task_type': None, '_task_id': 0, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1a200ae550>, '_master': '', '_num_ps_replicas': 0, '_num_worker_replicas': 0, '_environment': 'local', '_is_chief': True, '_evaluation_master': '', '_train_distribute': None, '_tf_config': gpu_options {
per_process_gpu_memory_fraction: 1.0
}
, '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_secs': 600, '_log_step_count_steps': 100, '_session_config': None, '_save_checkpoints_steps': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_model_dir': 'kernel_train'}
Steg D) Träna modellen
Nu när Kernel-klassificeraren är byggd är du redo att träna den. Du väljer att iterera 2000 gånger modellen
### estimate estimator_kernel.fit(input_fn=train_input_fn, steps=2000)
WARNING:tensorflow:Casting <dtype: 'int32'> labels to bool.
WARNING:tensorflow:Casting <dtype: 'int32'> labels to bool.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
WARNING:tensorflow:From /Users/Thomas/anaconda3/envs/hello-tf/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/estimators/head.py:678: ModelFnOps.__new__ (from tensorflow.contrib.learn.python.learn.estimators.model_fn) is deprecated and will be removed in a future version.
Instructions for updating:
When switching to tf.estimator.Estimator, use tf.estimator.EstimatorSpec. You can use the `estimator_spec` method to create an equivalent one.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Saving checkpoints for 1 into kernel_train/model.ckpt.
INFO:tensorflow:loss = 0.6931474, step = 1
INFO:tensorflow:global_step/sec: 86.6365
INFO:tensorflow:loss = 0.39374447, step = 101 (1.155 sec)
INFO:tensorflow:global_step/sec: 80.1986
INFO:tensorflow:loss = 0.3797774, step = 201 (1.247 sec)
INFO:tensorflow:global_step/sec: 79.6376
INFO:tensorflow:loss = 0.3908726, step = 301 (1.256 sec)
INFO:tensorflow:global_step/sec: 95.8442
INFO:tensorflow:loss = 0.41890752, step = 401 (1.043 sec)
INFO:tensorflow:global_step/sec: 93.7799
INFO:tensorflow:loss = 0.35700393, step = 501 (1.066 sec)
INFO:tensorflow:global_step/sec: 94.7071
INFO:tensorflow:loss = 0.35535482, step = 601 (1.056 sec)
INFO:tensorflow:global_step/sec: 90.7402
INFO:tensorflow:loss = 0.3692882, step = 701 (1.102 sec)
INFO:tensorflow:global_step/sec: 94.4924
INFO:tensorflow:loss = 0.34746957, step = 801 (1.058 sec)
INFO:tensorflow:global_step/sec: 95.3472
INFO:tensorflow:loss = 0.33655524, step = 901 (1.049 sec)
INFO:tensorflow:global_step/sec: 97.2928
INFO:tensorflow:loss = 0.35966292, step = 1001 (1.028 sec)
INFO:tensorflow:global_step/sec: 85.6761
INFO:tensorflow:loss = 0.31254214, step = 1101 (1.167 sec)
INFO:tensorflow:global_step/sec: 91.4194
INFO:tensorflow:loss = 0.33247527, step = 1201 (1.094 sec)
INFO:tensorflow:global_step/sec: 82.5954
INFO:tensorflow:loss = 0.29305756, step = 1301 (1.211 sec)
INFO:tensorflow:global_step/sec: 89.8748
INFO:tensorflow:loss = 0.37943482, step = 1401 (1.113 sec)
INFO:tensorflow:global_step/sec: 76.9761
INFO:tensorflow:loss = 0.34204718, step = 1501 (1.300 sec)
INFO:tensorflow:global_step/sec: 73.7192
INFO:tensorflow:loss = 0.34614792, step = 1601 (1.356 sec)
INFO:tensorflow:global_step/sec: 83.0573
INFO:tensorflow:loss = 0.38911164, step = 1701 (1.204 sec)
INFO:tensorflow:global_step/sec: 71.7029
INFO:tensorflow:loss = 0.35255936, step = 1801 (1.394 sec)
INFO:tensorflow:global_step/sec: 73.2663
INFO:tensorflow:loss = 0.31130585, step = 1901 (1.365 sec)
INFO:tensorflow:Saving checkpoints for 2000 into kernel_train/model.ckpt.
INFO:tensorflow:Loss for final step: 0.37795097.
KernelLinearClassifier(params={'head': <tensorflow.contrib.learn.python.learn.estimators.head._BinaryLogisticHead object at 0x1a2054cd30>, 'feature_columns': {_RealValuedColumn(column_name='features_MAPPED', dimension=5000, default_value=None, dtype=tf.float32, normalizer=None)}, 'optimizer': <tensorflow.python.training.ftrl.FtrlOptimizer object at 0x1a200aec18>, 'kernel_mappers': {_RealValuedColumn(column_name='features', dimension=14, default_value=None, dtype=tf.float32, normalizer=None): [<tensorflow.contrib.kernel_methods.python.mappers.random_fourier_features.RandomFourierFeatureMapper object at 0x1a200ae400>]}})
Steg E) Utvärdera modellen
Sist men inte minst utvärderar du prestandan hos din modell. Du bör kunna slå den logistiska regressionen.
# Evaluate and report metrics. eval_metrics = estimator_kernel.evaluate(input_fn=test_input_fn, steps=1)
WARNING:tensorflow:Casting <dtype: 'int32'> labels to bool. WARNING:tensorflow:Casting <dtype: 'int32'> labels to bool. WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead. WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead. INFO:tensorflow:Starting evaluation at 2018-07-12-15:58:50 INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from kernel_train/model.ckpt-2000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Evaluation [1/1] INFO:tensorflow:Finished evaluation at 2018-07-12-15:58:51 INFO:tensorflow:Saving dict for global step 2000: accuracy = 0.83975184, accuracy/baseline_label_mean = 0.23622628, accuracy/threshold_0.500000_mean = 0.83975184, auc = 0.8904007, auc_precision_recall = 0.72722375, global_step = 2000, labels/actual_label_mean = 0.23622628, labels/prediction_mean = 0.23786618, loss = 0.34277728, precision/positive_threshold_0.500000_mean = 0.73001117, recall/positive_threshold_0.500000_mean = 0.5104004
Den slutliga noggrannheten är 84 %, det är en förbättring på 2 % jämfört med den logistiska regressionen. Det finns en kompromiss mellan förbättring av noggrannhet och beräkningskostnad. Du måste tänka på om 2% förbättring är värd den tid som går åt av den olika klassificeraren och om det har en övertygande inverkan på din verksamhet.
Sammanfattning
En kärna är ett utmärkt verktyg för att omvandla icke-linjär data till (nästan) linjär. Nackdelen med denna metod är att den är beräkningsmässigt tidskrävande och kostsam.
Nedan kan du hitta den viktigaste koden för att träna en kärnklassificerare
Ställ in den höga kärnfunktionen
- 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 hyperparametern L2
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)
