Gaußscher Kernel im maschinellen Lernen: Beispiele für Kernelmethoden

Der Zweck dieses Tutorials besteht darin, einen Datensatz linear trennbar zu machen. Das Tutorial ist in zwei Teile gegliedert:

1. Feature-Transformation
2. Trainieren Sie einen Kernel-Klassifikator mit Tensorflow

Im ersten Teil werden Sie die Idee hinter einer Kernel-Methode im maschinellen Lernen verstehen, während Sie im zweiten Teil sehen werden, wie Sie einen Kernel-Klassifikator mit Tensorflow trainieren. Sie verwenden den Datensatz für Erwachsene. Das Ziel dieses Datensatzes ist es, die Einnahmen unter und über 50.000 zu klassifizieren, wobei das Verhalten jedes Haushalts bekannt ist.

In diesem Tutorial lernen Sie:

• Warum benötigen Sie Kernel-Methoden?
• Was ist ein Kernel beim maschinellen Lernen?
• Arten von Kernel-Methoden
• Trainiere den Gaußschen Kernel-Klassifikator mit TensorFlow

Warum benötigen Sie Kernel-Methoden?

Das Ziel jedes Klassifikators ist es, die Klassen korrekt vorherzusagen. Dafür sollte der Datensatz trennbar sein. Schauen Sie sich die Handlung unten an. Es ist ziemlich einfach zu erkennen, dass alle Punkte über der schwarzen Linie zur ersten Klasse und die anderen Punkte zur zweiten Klasse gehören. Es ist jedoch äußerst selten, dass ein Datensatz so einfach ist. In den meisten Fällen sind die Daten nicht trennbar. Kernel-Methoden im maschinellen Lernen machen es naiven Klassifikatoren wie einer logistischen Regression schwer.

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 der folgenden Abbildung zeichnen wir einen Datensatz, der nicht linear trennbar ist. Wenn wir eine gerade Linie zeichnen, werden die meisten Punkte nicht in die richtige Klasse eingestuft.

Eine Möglichkeit, dieses Problem zu lösen, besteht darin, das Dataset zu übernehmen und die Daten in eine andere Feature-Map umzuwandeln. Dies bedeutet, dass Sie eine Funktion verwenden, um die Daten in einen anderen Plan zu transformieren, der linearisierbar sein sollte.

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

Die Daten aus der obigen Abbildung befinden sich in einem 2D-Gaußschen Kernel-Plan, der nicht trennbar ist. Sie können versuchen, diese Daten dreidimensional zu transformieren. Dies bedeutet, dass Sie eine Figur mit drei Achsen erstellen.

In unserem Gaußschen Kernel-Beispiel wenden wir eine Polynomabbildung an, um unsere Daten auf eine 3D-Dimension zu bringen. Die Formel zum Transformieren der Daten lautet wie folgt.

Sie definieren eine Funktion in Gaussian Kernel Python, um die neuen Feature-Maps zu erstellen

Sie können numpy verwenden, um die obige Formel zu codieren:

Formel	Äquivalenter 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

Das neue Mapping sollte 3 Dimensionen mit 16 Punkten haben

x_1 = mapping(x, y)x_1.shape 

(3, 16) 

Lassen Sie uns ein neues Diagramm mit 3 Achsen, x, y und z erstellen.

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

Wir sehen eine Verbesserung, aber wenn wir die Ausrichtung des Diagramms ändern, ist klar, dass der Datensatz jetzt trennbar ist

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

Um ein großes Dataset zu bearbeiten und möglicherweise mehr als zwei Dimensionen erstellen zu müssen, treten bei Verwendung der oben beschriebenen Methode große Probleme auf. Tatsächlich müssen Sie alle Datenpunkte transformieren, was eindeutig nicht nachhaltig ist. Es wird ewig dauern, und auf Ihrem Computer ist möglicherweise nicht mehr genügend Speicher vorhanden.

Der häufigste Weg, um dieses Problem zu beheben, ist die Verwendung eines Kernels .

Was ist ein Kernel beim maschinellen Lernen?

Die Idee ist, einen höher dimensionierten Merkmalsraum zu verwenden, um die Daten nahezu linear trennbar zu machen, wie in der obigen Abbildung gezeigt.

Es gibt viele höherdimensionale Räume, um die Datenpunkte trennbar zu machen. Zum Beispiel haben wir gezeigt, dass die Polynomabbildung ein guter Anfang ist.

Wir haben auch gezeigt, dass diese Transformation bei vielen Daten nicht effizient ist. Stattdessen können Sie eine Kernelfunktion im maschinellen Lernen verwenden, um die Daten zu ändern, ohne zu einem neuen Funktionsplan zu wechseln.

Die Magie des Kernels besteht darin, eine Funktion zu finden, die alle Probleme vermeidet, die durch die hochdimensionale Berechnung entstehen. Das Ergebnis eines Kernels ist ein Skalar, oder anders gesagt, wir kehren zum eindimensionalen Raum zurück

Nachdem Sie diese Funktion gefunden haben, können Sie sie an den Standard-Linearklassifikator anschließen.

Schauen wir uns ein Beispiel an, um das Konzept des maschinellen Lernens im Kernel zu verstehen. Sie haben zwei Vektoren, x1 und x2. Ziel ist es, mithilfe einer Polynomabbildung eine höhere Dimension zu erzeugen. Die Ausgabe entspricht dem Punktprodukt der neuen Feature-Map. Von der obigen Methode müssen Sie:

1. Transformiere x1 und x2 in eine neue Dimension
2. Berechnen Sie das Punktprodukt: allen Kerneln gemeinsam
3. Transformiere x1 und x2 in eine neue Dimension

Mit der oben erstellten Funktion können Sie die höhere Dimension berechnen.

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

Ausgabe

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

Berechnen Sie das Punktprodukt

Sie können den Objektpunkt von numpy verwenden, um das Punktprodukt zwischen dem ersten und dem zweiten in x_1 gespeicherten Vektor zu berechnen.

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

Die Ausgabe ist 8100. Sie sehen das Problem, Sie müssen eine neue Feature-Map im Speicher speichern, um das Punktprodukt zu berechnen. Wenn Sie einen Datensatz mit Millionen von Datensätzen haben, ist dieser rechnerisch ineffektiv.

Stattdessen können Sie den Polynomkern verwenden , um das Punktprodukt zu berechnen, ohne den Vektor zu transformieren. Diese Funktion berechnet das Punktprodukt von x1 und x2 so, als ob diese beiden Vektoren in die höhere Dimension transformiert worden wären. Anders gesagt, eine Kernelfunktion berechnet die Ergebnisse des Punktprodukts aus einem anderen Merkmalsraum.

Sie können die Polynomkernfunktion in Python wie folgt schreiben.

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

Es ist die Potenz des Punktprodukts zweier Vektoren. Unten geben Sie den zweiten Grad des Polynomkerns zurück. Die Ausgabe entspricht der anderen Methode. Dies ist die Magie des Kernels.

polynomial_kernel(x1, x2, p=2)8100 

Arten von Kernel-Methoden

Es stehen viele verschiedene Kernel-Techniken zur Verfügung. Der einfachste ist der lineare Kernel. Diese Funktion eignet sich sehr gut für die Textklassifizierung. Der andere Kernel ist:

• Polynomkern
• Gaußscher Kernel

Im Beispiel mit TensorFlow verwenden wir das Random Fourier. TensorFlow verfügt über einen integrierten Schätzer zur Berechnung des neuen Feature-Space. Die Gaußsche Filterfunktion ist eine Annäherung an die Gaußsche Kernelfunktion.

Die Gaußsche Filterfunktion berechnet die Ähnlichkeit zwischen den Datenpunkten in einem viel höherdimensionalen Raum.

Trainiere den Gaußschen Kernel-Klassifikator mit TensorFlow

Ziel des Algorithmus ist es, den Haushalt zu klassifizieren, der mehr oder weniger als 50.000 verdient.

Sie bewerten ein logistisches Kernel-Regressions-Maschinelles Lernen, um ein Benchmark-Modell zu erhalten. Danach trainieren Sie einen Kernel-Klassifikator, um zu sehen, ob Sie bessere Ergebnisse erzielen können.

Sie verwenden die folgenden Variablen aus dem Datensatz für Erwachsene:

• Alter
• Arbeiterklasse
• fnlwgt
• Bildung
• education_num
• ehelich
• Besetzung
• Beziehung
• Rennen
• Sex
• Wertzuwachs
• Kapitalverlust
• Stunden_Woche
• Heimatland
• Etikette

Sie werden wie folgt vorgehen, bevor Sie das Modell trainieren und bewerten:

• Schritt 1) ​​Importieren Sie die Bibliotheken
• Schritt 2) Importieren Sie die Daten
• Schritt 3) Bereiten Sie die Daten vor
• Schritt 4) Konstruieren Sie die input_fn
• Schritt 5) Erstellen Sie das Logistikmodell: Basismodell
• Schritt 6) Bewerten Sie das Modell
• Schritt 7) Konstruieren Sie den Kernel-Klassifikator
• Schritt 8) Bewerten Sie den Kernel-Klassifikator

Schritt 1) Importieren Sie die Bibliotheken

Um Kernelmodelle in künstliche Intelligenz zu importieren und zu trainieren, müssen Sie Tensorflow, Pandas und Numpy importieren

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

Schritt 2) Importieren Sie die Daten

Sie laden die Daten von der folgenden Website herunter und importieren sie als Panda-Datenrahmen.

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

Nachdem der Zug und der Testsatz definiert wurden, können Sie die Spaltenbezeichnung von Zeichenfolge in Ganzzahl ändern. Tensorflow akzeptiert keinen Zeichenfolgenwert für das Etikett.

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)

Schritt 3) Bereiten Sie die Daten vor

Der Datensatz enthält sowohl kontinuierliche als auch kategoriale Merkmale. Eine gute Praxis besteht darin, die Werte der kontinuierlichen Variablen zu standardisieren. Sie können die Funktion StandardScaler von sci-kit learn verwenden. Sie erstellen auch eine benutzerdefinierte Funktion, um die Konvertierung von Zug und Testsatz zu vereinfachen. Beachten Sie, dass Sie die kontinuierlichen und kategorialen Variablen zu einem gemeinsamen Dataset verketten und das Array vom Typ float32 sein sollte

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 

Die Transformatorfunktion ist bereit. Sie können den Datensatz konvertieren und die Funktion input_fn erstellen.

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

Im nächsten Schritt trainieren Sie eine logistische Regression. Sie erhalten eine Grundgenauigkeit. Ziel ist es, die Basislinie mit einem anderen Algorithmus zu übertreffen, nämlich einem Kernel-Klassifikator.

Schritt 4) Erstellen Sie das Logistikmodell: Basismodell

Sie erstellen die Feature-Spalte mit dem Objekt real_valued_column. Dadurch wird sichergestellt, dass alle Variablen dichte numerische Daten sind.

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

Der Schätzer wird mit TensorFlow Estimator definiert. Sie weisen die Feature-Spalten an und wo das Diagramm gespeichert werden soll.

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} 

Sie trainieren die logistische Regression mit Mini-Batches der Größe 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) 

Sie können das Modell mit 1.000 Iterationen trainieren

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.

Schritt 6) Bewerten Sie das Modell

Sie definieren den Numpy-Schätzer, um das Modell zu bewerten. Sie verwenden den gesamten Datensatz zur Auswertung

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

Sie haben eine Genauigkeit von 82 Prozent. Im nächsten Abschnitt werden Sie versuchen, den logistischen Klassifikator mit einem Kernel-Klassifikator zu schlagen

Schritt 7) Erstellen Sie den Kernel-Klassifikator

Der Kernel-Schätzer unterscheidet sich zumindest in Bezug auf die Konstruktion nicht so stark vom herkömmlichen linearen Klassifikator. Die Idee dahinter ist, die Kraft des expliziten Kernels mit dem linearen Klassifikator zu nutzen.

Sie benötigen zwei vordefinierte Schätzer, die in TensorFlow verfügbar sind, um den Kernel-Klassifikator zu trainieren:

• RandomFourierFeatureMapper
• KernelLinearClassifier

Im ersten Abschnitt haben Sie gelernt, dass Sie die niedrige Dimension mithilfe einer Kernelfunktion in eine hohe Dimension umwandeln müssen. Genauer gesagt verwenden Sie das Random Fourier, eine Annäherung an die Gaußsche Funktion. Glücklicherweise hat Tensorflow die Funktion in seiner Bibliothek: RandomFourierFeatureMapper. Das Modell kann mit dem Schätzer KernelLinearClassifier trainiert werden.

Um das Modell zu erstellen, gehen Sie folgendermaßen vor:

1. Stellen Sie die Kernel-Funktion mit hoher Dimension ein
2. Stellen Sie den L2-Hyperparameter ein
3. Erstellen Sie das Modell
4. Trainiere das Modell
5. Bewerten Sie das Modell

Schritt A) Stellen Sie die Kernel-Funktion mit hoher Dimension ein

Der aktuelle Datensatz enthält 14 Features, die Sie in eine neue hohe Dimension des 5.000-dimensionalen Vektors transformieren. Sie verwenden die zufälligen Fourier-Merkmale, um die Transformation zu erreichen. Wenn Sie sich an die Gaußsche Kernelformel erinnern, stellen Sie fest, dass der Standardabweichungsparameter definiert werden muss. Dieser Parameter steuert das Ähnlichkeitsmaß, das während der Klassifizierung verwendet wird.

Sie können alle Parameter in RandomFourierFeatureMapper optimieren mit:

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

Sie müssen den Kernel-Mapper mithilfe der zuvor erstellten Feature-Spalten erstellen: feat_column

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

Schritt B) Stellen Sie den L2-Hyperparameter ein

Um eine Überanpassung zu vermeiden, bestrafen Sie die Verlustfunktion mit dem L2-Regularizer. Sie setzen den L2-Hyperparameter auf 0,1 und die Lernrate auf 5

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

Schritt C) Erstellen Sie das Modell

Der nächste Schritt ähnelt der linearen Klassifizierung. Sie verwenden den integrierten Schätzer KernelLinearClassifier. Beachten Sie, dass Sie den zuvor definierten Kernel-Mapper hinzufügen und das Modellverzeichnis ändern.

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

Schritt D) Trainieren Sie das Modell

Nachdem der Kernel-Klassifikator erstellt wurde, können Sie ihn trainieren. Sie wählen die 2000-fache Iteration des Modells

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

Schritt E) Bewerten Sie das Modell

Zu guter Letzt bewerten Sie die Leistung Ihres Modells. Sie sollten in der Lage sein, die logistische Regression zu überwinden.

# 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

Die endgültige Genauigkeit beträgt 84%, was einer Verbesserung von 2% gegenüber der logistischen Regression entspricht. Es gibt einen Kompromiss zwischen Genauigkeitsverbesserung und Rechenaufwand. Sie müssen sich überlegen, ob eine Verbesserung um 2% die Zeit wert ist, die der verschiedene Klassifikator benötigt, und ob sich dies überzeugend auf Ihr Unternehmen auswirkt.

Zusammenfassung

Ein Kernel ist ein großartiges Werkzeug, um nichtlineare Daten in (fast) lineare umzuwandeln. Das Manko dieser Methode ist rechenintensiv und kostspielig.

Unten finden Sie den wichtigsten Code zum Trainieren eines Kernel-Klassifikators

Stellen Sie die Kernel-Funktion mit hoher Dimension ein

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

Stellen Sie den L2-Hyperparameter ein

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

Erstellen Sie das Modell

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

Trainiere das Modell

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

Bewerten Sie das Modell

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