Noyau gaussien dans l'apprentissage automatique: exemples de méthodes de noyau

Table des matières:

Anonim

Le but de ce didacticiel est de rendre un jeu de données séparable linéairement. Le didacticiel est divisé en deux parties:

  1. Transformation des fonctionnalités
  2. Former un classificateur de noyau avec Tensorflow

Dans la première partie, vous comprendrez l'idée derrière une méthode Kernel dans Machine Learning tandis que dans la deuxième partie, vous verrez comment entraîner un classificateur de noyau avec Tensorflow. Vous utiliserez l'ensemble de données pour adultes. L'objectif de cet ensemble de données est de classer les revenus en dessous et au-dessus de 50k, en connaissant le comportement de chaque ménage.

Dans ce tutoriel, vous apprendrez-

  • Pourquoi avez-vous besoin de méthodes de noyau?
  • Qu'est-ce qu'un noyau dans l'apprentissage automatique?
  • Types de méthodes de noyau
  • Former le classificateur de noyau gaussien avec TensorFlow

Pourquoi avez-vous besoin de méthodes de noyau?

Le but de chaque classificateur est de prédire correctement les classes. Pour cela, l'ensemble de données doit être séparable. Regardez l'intrigue ci-dessous; il est assez simple de voir que tous les points au-dessus de la ligne noire appartiennent à la première classe et les autres points à la seconde classe. Cependant, il est extrêmement rare d'avoir un ensemble de données aussi simple. Dans la plupart des cas, les données ne sont pas séparables. Les méthodes de noyau dans le Machine Learning donnent du fil à retordre aux classificateurs naïfs comme une régression logistique.

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

Dans la figure ci-dessous, nous traçons un ensemble de données qui n'est pas linéairement séparable. Si nous dessinons une ligne droite, la plupart des points ne seront pas classés dans la bonne classe.

Une façon de résoudre ce problème consiste à prendre le jeu de données et à transformer les données dans une autre carte d'entités. Cela signifie que vous utiliserez une fonction pour transformer les données dans un autre plan, qui devrait être linéarisé.

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

Les données de la figure ci-dessus sont dans un plan de noyau gaussien 2D qui n'est pas séparable. Vous pouvez essayer de transformer ces données en trois dimensions, c'est-à-dire que vous créez une figure avec 3 axes.

Dans notre exemple de noyau gaussien, nous appliquerons un mappage polynomial pour amener nos données à une dimension 3D. La formule pour transformer les données est la suivante.

Vous définissez une fonction dans Gaussian Kernel Python pour créer les nouvelles cartes d'entités

Vous pouvez utiliser numpy pour coder la formule ci-dessus:

Formule Code Numpy équivalent
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

La nouvelle cartographie doit être en 3 dimensions avec 16 points

x_1 = mapping(x, y)x_1.shape 
(3, 16)

Faisons un nouveau tracé avec 3 axes, x, y et z respectivement.

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

On voit une amélioration mais si on change l'orientation du tracé, il est clair que le jeu de données est désormais séparable

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

Pour manipuler un grand ensemble de données et vous devrez peut-être créer plus de 2 dimensions, vous serez confronté à un gros problème en utilisant la méthode ci-dessus. En fait, vous devez transformer tous les points de données, ce qui n'est clairement pas durable. Cela vous prendra du temps et votre ordinateur risque de manquer de mémoire.

Le moyen le plus courant de résoudre ce problème est d'utiliser un noyau .

Qu'est-ce qu'un noyau dans l'apprentissage automatique?

L'idée est d'utiliser un espace d'entités de dimension supérieure pour rendre les données séparables de manière presque linéaire, comme illustré dans la figure ci-dessus.

Il existe de nombreux espaces de dimensions plus élevées pour rendre les points de données séparables. Par exemple, nous avons montré que la cartographie polynomiale est un bon début.

Nous avons également démontré qu'avec beaucoup de données, ces transformations ne sont pas efficaces. Au lieu de cela, vous pouvez utiliser une fonction Kernel dans Machine Learning pour modifier les données sans passer à un nouveau plan de fonctionnalités.

La magie du noyau est de trouver une fonction qui évite tous les problèmes qu'implique le calcul en haute dimension. Le résultat d'un noyau est un scalaire, ou dit autrement, nous sommes de retour à l'espace unidimensionnel

Une fois que vous avez trouvé cette fonction, vous pouvez la brancher sur le classificateur linéaire standard.

Voyons un exemple pour comprendre le concept de Kernel Machine Learning. Vous avez deux vecteurs, x1 et x2. L'objectif est de créer une dimension supérieure en utilisant un mappage polynomial. La sortie est égale au produit scalaire de la nouvelle carte d'entités. À partir de la méthode ci-dessus, vous devez:

  1. Transformez x1 et x2 en une nouvelle dimension
  2. Calculer le produit scalaire: commun à tous les noyaux
  3. Transformez x1 et x2 en une nouvelle dimension

Vous pouvez utiliser la fonction créée ci-dessus pour calculer la dimension supérieure.

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

Production

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

Calculer le produit scalaire

Vous pouvez utiliser l'objet point de numpy pour calculer le produit scalaire entre le premier et le deuxième vecteur stocké dans x_1.

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

La sortie est 8100. Vous voyez le problème, vous devez stocker en mémoire une nouvelle carte de caractéristiques pour calculer le produit scalaire. Si vous avez un ensemble de données avec des millions d'enregistrements, il est inefficace en termes de calcul.

Au lieu de cela, vous pouvez utiliser le noyau polynomial pour calculer le produit scalaire sans transformer le vecteur. Cette fonction calcule le produit scalaire de x1 et x2 comme si ces deux vecteurs avaient été transformés en dimension supérieure. Dit différemment, une fonction de noyau calcule les résultats du produit scalaire à partir d'un autre espace de fonctionnalités.

Vous pouvez écrire la fonction noyau polynomiale en Python comme suit.

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

C'est la puissance du produit scalaire de deux vecteurs. Ci-dessous, vous retournez le deuxième degré du noyau polynomial. La sortie est égale à l'autre méthode. C'est la magie du noyau.

polynomial_kernel(x1, x2, p=2)8100

Types de méthodes de noyau

Il existe de nombreuses techniques de noyau différentes disponibles. Le plus simple est le noyau linéaire. Cette fonction fonctionne plutôt bien pour la classification de texte. L'autre noyau est:

  • Noyau polynomial
  • Noyau gaussien

Dans l'exemple avec TensorFlow, nous utiliserons le Fourier aléatoire. TensorFlow a un estimateur intégré pour calculer le nouvel espace de fonctionnalités. La fonction de filtre gaussien est une approximation de la fonction noyau gaussienne.

La fonction de filtrage gaussien calcule la similitude entre les points de données dans un espace dimensionnel beaucoup plus élevé.

Former le classificateur de noyau gaussien avec TensorFlow

L'objectif de l'algorithme est de classer le ménage gagnant plus ou moins de 50k.

Vous évaluerez un apprentissage automatique de régression de noyau logistique pour avoir un modèle de référence. Après cela, vous entraînerez un classificateur de noyau pour voir si vous pouvez obtenir de meilleurs résultats.

Vous utilisez les variables suivantes de l'ensemble de données adulte:

  • âge
  • classe de travail
  • fnlwgt
  • éducation
  • education_num
  • matrimonial
  • Occupation
  • relation
  • course
  • sexe
  • capital_gain
  • capital_loss
  • heures_semaine
  • pays d'origine
  • étiqueter

Vous procéderez comme suit avant de vous entraîner et d'évaluer le modèle:

  • Étape 1) Importez les bibliothèques
  • Étape 2) Importez les données
  • Étape 3) Préparez les données
  • Étape 4) Construisez le input_fn
  • Étape 5) Construire le modèle logistique: modèle de base
  • Étape 6) Évaluer le modèle
  • Étape 7) Construisez le classificateur du noyau
  • Étape 8) Évaluer le classificateur du noyau

Étape 1) Importez les bibliothèques

Pour importer et entraîner des modèles de noyau en intelligence artificielle, vous devez importer tensorflow, pandas et numpy

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

Étape 2) Importez les données

Vous téléchargez les données à partir du site Web suivant et vous les importez en tant que dataframe panda.

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

Maintenant que le train et l'ensemble de test sont définis, vous pouvez changer l'étiquette de colonne de chaîne en entier. tensorflow n'accepte pas la valeur de chaîne pour l'étiquette.

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)

Étape 3) Préparez les données

L'ensemble de données contient à la fois des caractéristiques continues et catégorielles. Une bonne pratique consiste à standardiser les valeurs des variables continues. Vous pouvez utiliser la fonction StandardScaler de sci-kit learn. Vous créez également une fonction définie par l'utilisateur pour faciliter la conversion du train et de l'ensemble de test. Notez que vous concaténez les variables continues et catégorielles dans un ensemble de données commun et le tableau doit être du type: 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

La fonction de transformation est prête, vous pouvez convertir le jeu de données et créer la fonction 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)

Dans l'étape suivante, vous entraînerez une régression logistique. Cela vous donnera une précision de base. L'objectif est de battre la ligne de base avec un algorithme différent, à savoir un classificateur Kernel.

Étape 4) Construire le modèle logistique: modèle de base

Vous construisez la colonne de caractéristiques avec l'objet real_valued_column. Il s'assurera que toutes les variables sont des données numériques denses.

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

L'estimateur est défini à l'aide de TensorFlow Estimator, vous indiquez les colonnes de caractéristiques et où enregistrer le graphique.

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}

Vous apprendrez la régression logisitque à l'aide de mini-lots de taille 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)

Vous pouvez entraîner le modèle avec 1 000 itérations

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.

Étape 6) Évaluer le modèle

Vous définissez l'estimateur numpy pour évaluer le modèle. Vous utilisez l'ensemble de données pour l'évaluation

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

Vous avez une précision de 82 pour cent. Dans la section suivante, vous essaierez de battre le classificateur logistique avec un classificateur Kernel

Étape 7) Construisez le classificateur du noyau

L'estimateur par noyau n'est pas si différent du classificateur linéaire traditionnel, du moins en terme de construction. L'idée derrière est d'utiliser la puissance du noyau explicite avec le classificateur linéaire.

Vous avez besoin de deux estimateurs prédéfinis disponibles dans TensorFlow pour entraîner le classificateur de noyau:

  • RandomFourierFeatureMapper
  • KernelLinearClassifier

Vous avez appris dans la première section que vous devez transformer la petite dimension en une dimension élevée à l'aide d'une fonction noyau. Plus précisément, vous utiliserez le Fourier aléatoire, qui est une approximation de la fonction gaussienne. Heureusement, Tensorflow a la fonction dans sa bibliothèque: RandomFourierFeatureMapper. Le modèle peut être entraîné à l'aide de l'estimateur KernelLinearClassifier.

Pour créer le modèle, vous allez suivre ces étapes:

  1. Définir la fonction Kernel de haute dimension
  2. Définir l'hyperparamètre L2
  3. Construisez le modèle
  4. Former le modèle
  5. Évaluer le modèle

Étape A) Définissez la fonction Kernel de haute dimension

Le jeu de données actuel contient 14 entités que vous transformerez en une nouvelle dimension élevée du vecteur de 5 000 dimensions. Vous utilisez les fonctionnalités aléatoires de Fourier pour réaliser la transformation. Si vous rappelez la formule du noyau gaussien, vous notez qu'il y a le paramètre d'écart type à définir. Ce paramètre contrôle la mesure de similarité utilisée pendant la classification.

Vous pouvez régler tous les paramètres de RandomFourierFeatureMapper avec:

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

Vous devez construire le mappeur de noyau en utilisant les colonnes de fonctionnalités créées avant: feat_column

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

Étape B) Définissez l'hyperparamètre L2

Pour éviter le surajustement, vous pénalisez la fonction de perte avec le régulariseur L2. Vous définissez l'hyperparamètre L2 sur 0,1 et le taux d'apprentissage sur 5

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

Étape C) Construisez le modèle

L'étape suivante est similaire à la classification linéaire. Vous utilisez l'estimateur intégré KernelLinearClassifier. Notez que vous ajoutez le mappeur de noyau défini précédemment et que vous modifiez le répertoire du modèle.

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

Étape D) Former le modèle

Maintenant que le classificateur Kernel est construit, vous êtes prêt à l'entraîner. Vous choisissez d'itérer 2000 fois le modèle

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

Étape E) Évaluer le modèle

Enfin, vous évaluez les performances de votre modèle. Vous devriez être capable de battre la régression logistique.

# 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

La précision finale est de 84%, c'est une amélioration de 2% par rapport à la régression logistique. Il existe un compromis entre l'amélioration de la précision et le coût de calcul. Vous devez vous demander si une amélioration de 2% vaut le temps consommé par les différents classificateurs et si elle a un impact convaincant sur votre entreprise.

Résumé

Un noyau est un excellent outil pour transformer des données non linéaires en (presque) linéaires. L'inconvénient de cette méthode est qu'elle prend du temps et est coûteuse en termes de calcul.

Ci-dessous, vous pouvez trouver le code le plus important pour entraîner un classificateur du noyau

Définir la fonction Kernel de haute 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')

Définir l'hyperparamètre L2

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

Construisez le modèle

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

Former le modèle

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

Évaluer le modèle

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