Gaussische kernel in machinaal leren: Python Kernel-methoden
Evelien Clarke
Het doel van deze zelfstudie is om een gegevensset lineair scheidbaar te maken. De tutorial is verdeeld in twee delen:
- Functietransformatie
- Train een kernelclassificator met Tensorflow
In het eerste deel zul je het idee achter een Kernel-methode in Machine Learning begrijpen, terwijl je in het tweede deel zult zien hoe je een kernel-classifier traint met Tensorflow. Je zult de dataset voor volwassenen gebruiken. Het doel van deze dataset is om de inkomsten onder en boven de 50k te classificeren, waarbij je het gedrag van elk huishouden kent.
Waarom heb je Kernel-methoden nodig?
Het doel van elke classificator is om de klassen correct te voorspellen. Daarvoor moet de dataset scheidbaar zijn. Kijk naar het onderstaande plot; het is vrij eenvoudig te zien dat alle punten boven de zwarte lijn tot de eerste klasse behoren en de overige punten tot de tweede klasse. Het is echter uiterst zeldzaam om zo'n eenvoudige dataset te hebben. In de meeste gevallen zijn de gegevens niet scheidbaar. Kernelmethoden in Machine Learning maken het lastig voor naïeve classificatoren als logistische regressie.
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()
In de onderstaande afbeelding plotten we een dataset die niet lineair scheidbaar is. Als we een rechte lijn trekken, worden de meeste punten niet in de juiste klasse ingedeeld.
Eén manier om dit probleem aan te pakken is door de dataset te nemen en de gegevens in een andere feature map te transformeren. Het betekent dat u een functie gaat gebruiken om de gegevens in een ander plan te transformeren, dat lineair moet 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 bevinden zich in een 2D Gaussiaans kernelplan dat niet scheidbaar is. Je kunt proberen deze gegevens driedimensionaal te transformeren, dit betekent dat je een figuur met 3 assen maakt.
In ons Gaussiaanse kernelvoorbeeld 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 de Gaussiaanse kernel Python om de nieuwe feature maps te maken
Je kunt gebruiken numpy om de bovenstaande formule te coderen:
| Formule | Equivalente Numpy-code |
|---|---|
| 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
De nieuwe mapping zou 3 dimensies met 16 punten moeten hebben
x_1 = mapping(x, y) x_1.shape
(3, 16)
Laten we een nieuwe plot maken met respectievelijk 3 assen, x, y en 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()
We zien een verbetering, maar als we de oriëntatie van de plot veranderen, is het duidelijk dat de dataset nu scheidbaar is
# 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()
Als u een grote dataset wilt manipuleren en mogelijk meer dan twee dimensies moet creëren, zult u met de bovenstaande methode een groot probleem tegenkomen. In feite moet je alle datapunten transformeren, wat duidelijk niet duurzaam is. Het zal een eeuwigheid duren, en het kan zijn dat uw computer onvoldoende geheugen heeft.
De meest gebruikelijke manier om dit probleem op te lossen is door gebruik te maken van een pit.
Wat is een kernel in machine learning?
Het idee is om een kenmerkruimte met een hogere dimensie te gebruiken om de gegevens bijna lineair scheidbaar te maken, zoals weergegeven in de bovenstaande afbeelding.
Er zijn tal van hoger-dimensionale ruimtes om de gegevenspunten 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 naar een nieuw functieplan te wijzigen.
De magie van de kernel is het vinden van een functie die alle problemen vermijdt die gepaard gaan met hoogdimensionale berekeningen. Het resultaat van een kernel is een scalair, of anders gezegd: we zijn terug in de eendimensionale ruimte
Nadat u deze functie hebt gevonden, kunt u deze aansluiten op de standaard lineaire classificator.
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 polynomiale mapping. De uitvoer is gelijk aan het puntproduct van de nieuwe feature map. Volgens de bovenstaande methode moet u:
- Transformeer x1 en x2 naar een nieuwe dimensie
- Bereken het puntproduct: gemeenschappelijk voor alle kernels
- Transformeer x1 en x2 naar een nieuwe dimensie
U kunt de hierboven gemaakte functie gebruiken om de hogere dimensie te berekenen.
## Kernel x1 = np.array([3,6]) x2 = np.array([10,10]) x_1 = mapping(x1, x2) print(x_1)
uitgang
[[ 9. 100. ]
[ 25.45584412 141.42135624]
[ 36. 100. ]]
Bereken het puntproduct
U kunt het objectpunt van numpy gebruiken om het puntproduct tussen de eerste en tweede vector opgeslagen in x_1 te berekenen.
print(np.dot(x_1[:,0], x_1[:,1])) 8100.0
De uitvoer is 8100. U ziet het probleem: u moet een nieuwe feature map in het geheugen opslaan om het puntproduct te berekenen. Als u een dataset met miljoenen records heeft, is deze rekenkundig ineffectief.
In plaats daarvan kunt u de polynoom kernel 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 polynomiale kernelfunctie schrijven in Python als volgt.
def polynomial_kernel(x, y, p=2): return (np.dot(x, y)) ** p
Het is de macht van het inproduct van twee vectoren. Hieronder geef je de tweede graad van de polynoomkern terug. De uitvoer is gelijk aan de andere methode. Dit is de magie van de kernel.
polynomial_kernel(x1, x2, p=2) 8100
Soorten kernelmethoden
Er zijn veel verschillende Kernel-technieken beschikbaar. De eenvoudigste is de lineaire kernel. 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 featureruimte te berekenen. De Gaussische filterfunctie is een benadering van de Gaussische kernelfunctie.
De Gaussiaanse filterfunctie berekent de gelijkenis tussen de datapunten in een veel hoger dimensionale ruimte.
Train de Gaussiaanse kernelclassificator met TensorFlow
Het doel van het algoritme is om het huishouden te classificeren dat meer of minder dan 50 verdient.
Je evalueert een logistieke Kernel Regressie Machine Learning om een benchmarkmodel te hebben. Daarna traint u een Kernel-classifier om te zien of u betere resultaten kunt behalen.
U gebruikt de volgende variabelen uit de dataset voor volwassenen:
- leeftijd
- werkklas
- fnlwgt
- onderwijs
- onderwijs_num
- huwelijks-
- bezetting
- verwantschap
- race
- geslacht
- kapitaal_winst
- kapitaal_verlies
- uren_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: Basislijnmodel
- Stap 6) Evalueer het model
- Stap 7) Construeer de Kernel-classificator
- Stap 8) Evalueer de Kernel-classificator
Stap 1) Importeer de bibliotheken
Kernel-modellen importeren en trainen Artificial Intelligence, je moet tensorflow importeren, panda's en numpig
#import numpy as np from sklearn.model_selection import train_test_split import tensorflow as tf import pandas as pd import numpy as np
Stap 2) Importeer de gegevens
U downloadt de gegevens van de volgende website en je importeert het als een panda-dataframe.
## 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 de trein en de testset zijn gedefinieerd, kunt u het kolomlabel wijzigen van string in geheel getal. 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 praktijk is het standaardiseren van de waarden van de continue variabelen. U kunt de functie StandardScaler van sci-kit learn gebruiken. U maakt ook een door de gebruiker gedefinieerde functie om het ombouwen van de trein en de testset eenvoudiger te maken. Houd er rekening mee 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 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
De transformatorfunctie is klaar, u kunt de dataset converteren en de input_fn-functie 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 u een basisnauwkeurigheid. Het doel is om de basislijn te verslaan met een ander algoritme, namelijk een Kernel-classifier.
Stap 4) Construeer het logistieke model: Basislijnmodel
U construeert de featurekolom 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 functiekolommen 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': <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}
Je traint de logistieke regressie met behulp van minibatches van grootte 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)
Je kunt het model trainen met 1.000 iteraties
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>
Stap 6) Evalueer het model
U definieert de numpy-schatter om het model te evalueren. U gebruikt de volledige dataset voor evaluatie
# 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}
Je hebt een nauwkeurigheid van 82 procent. In de volgende sectie probeer je de logistieke classificator te verslaan met een Kernel-classifier
Stap 7) Construeer de Kernel-classificator
De kernschatter verschilt niet zoveel van de traditionele lineaire classificator, althans qua constructie. Het idee hierachter is om de kracht van de 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 het eerste deel geleerd dat je de lage dimensie naar een hoge dimensie moet transformeren met behulp van een kernelfunctie. Nauwkeuriger gezegd, 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:
- Stel de Kernel-functie met hoge afmetingen in
- Stel de L2-hyperparameter in
- Bouw het model
- Train het model
- Evalueer het model
Stap A) Stel de Kernel-functie met hoge afmetingen in
De huidige dataset bevat 14 objecten die u gaat transformeren naar een nieuwe hoge dimensie van de 5.000-dimensionale vector. U gebruikt de willekeurige Fourier-functies om de transformatie te bewerkstelligen. Als u zich de Gaussiaanse Kernel-formule herinnert, merkt u dat er een standaarddeviatieparameter moet worden gedefinieerd. Deze parameter controleert de mate van gelijkenis die tijdens de classificatie wordt gebruikt.
U kunt alle parameters in RandomFourierFeatureMapper afstemmen met:
- invoer_dim = 14
- uitvoer_dim= 5000
- stddev=4
### Prep Kernel kernel_mapper = tf.contrib.kernel_methods.RandomFourierFeatureMapper(input_dim=14, output_dim=5000, stddev=4, name='rffm')
U moet de kernelmapper construeren met behulp van de eerder gemaakte featurekolommen: feat_column
### Map Kernel
kernel_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 leersnelheid 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 kerneltoewijzer toevoegt en de modelmap wijzigt.
### 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'}
Stap D) Train het model
Nu de Kernel-classificator is gebouwd, bent u klaar om deze te trainen. U kiest ervoor om 2000 keer het model te herhalen
### 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>]}})
Stap E) Evalueer het model
Last but not least evalueert u de prestaties van uw model. Je zou de logistische regressie moeten kunnen verslaan.
# 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
De uiteindelijke nauwkeurigheid is 84%, dit is een verbetering van 2% vergeleken met de logistische regressie. Er is een afweging tussen nauwkeurigheidsverbetering en rekenkosten. U moet bedenken of een verbetering van 2% de tijd waard is die door de verschillende classificaties wordt verbruikt en of dit een overtuigende impact heeft op uw bedrijf.
Samenvatting
Een kernel is een geweldig hulpmiddel om niet-lineaire gegevens naar (bijna) lineair te transformeren. De tekortkoming van deze methode is dat deze rekentijdrovend en kostbaar is.
Hieronder vindt u de belangrijkste code om een kernelclassifer te trainen
Stel de Kernel-functie met hoge afmetingen in
- invoer_dim = 14
- uitvoer_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)
