Noyau gaussien dans l'apprentissage automatique : Python Méthodes du noyau

Le but de ce tutoriel est de rendre un ensemble de données linéairement séparable. Le tutoriel 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 en Machine Learning tandis que dans la deuxième partie, vous verrez comment former 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 inférieurs et supérieurs à 50k, connaissant le comportement de chaque foyer.

Pourquoi avez-vous besoin des méthodes du 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 de disposer d’un ensemble de données aussi simple. Dans la plupart des cas, les données ne sont pas séparables. Les méthodes du noyau dans l’apprentissage automatique donnent du fil à retordre aux classificateurs naïfs comme une régression logistique.

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

Méthode du noyau

Dans la figure ci-dessous, nous traçons un ensemble de données qui n'est pas linéairement séparable. Si on trace 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 l'ensemble de données et à transformer les données dans une autre carte de caractéristiques. Cela signifie que vous utiliserez une fonction pour transformer les données dans un autre plan, qui doit être linéaire.

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

Méthode du noyau

Les données de la figure ci-dessus se trouvent 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 à 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.

Méthode du noyau

Vous définissez une fonction dans le noyau gaussien Python pour créer les nouvelles cartes de fonctionnalités

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

Laits en poudre Code Numpy équivalent
x x[:,0]**
y x[:,1]
x2 x[:,0]**2
Méthode du noyau 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			

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

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

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

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

Méthode du noyau

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

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

Méthode du noyau

Pour manipuler un grand ensemble de données et que 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.

La manière la plus courante de résoudre ce problème consiste à utiliser un kernel.

Qu’est-ce qu’un noyau en machine learning ?

L'idée est d'utiliser un espace de fonctionnalités de dimension supérieure pour rendre les données séparables presque linéairement, comme le montre la figure ci-dessus.

Il existe de nombreux espaces de dimensions supérieures 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 noyau 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 impliqués par le calcul de grande dimension. Le résultat d'un noyau est un scalaire, ou autrement dit nous revenons à un espace unidimensionnel

Après avoir trouvé cette fonction, vous pouvez la connecter au classificateur linéaire standard.

Voyons un exemple pour comprendre le concept de Kernel Machine Learning. Vous disposez de deux vecteurs, x1 et x2. L'objectif est de créer une dimension supérieure en utilisant une cartographie polynomiale. Le résultat est égal au produit scalaire de la nouvelle carte de fonctionnalités. À partir de la méthode ci-dessus, vous devez :

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

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

## Kernel
x1 = np.array([3,6])
x2 = np.array([10,10])			

x_1 = mapping(x1, x2)
print(x_1)

Sortie

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

Calculer le produit scalaire

Vous pouvez utiliser l'objet dot de numpy pour calculer le produit scalaire entre le premier et le deuxième vecteur stockés 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 fonctionnalités pour calculer le produit scalaire. Si vous disposez d’un ensemble de données contenant des millions d’enregistrements, son calcul est inefficace.

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 dans la dimension supérieure. Autrement dit, une fonction noyau calcule les résultats du produit scalaire à partir d’un autre espace de fonctionnalités.

Vous pouvez écrire la fonction du noyau polynomial dans 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 renvoyez le deuxième degré du noyau polynomial. Le résultat est égal à l’autre méthode. C'est la magie du noyau.

polynomial_kernel(x1, x2, p=2)			
8100

Types de méthodes du noyau

Il existe de nombreuses techniques de noyau différentes. 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 dispose d'un estimateur intégré pour calculer le nouvel espace de fonctionnalités. La fonction de filtre gaussien est une approximation de la fonction de noyau gaussien.

Types de méthodes du noyau

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

Entraîner le classificateur à noyau gaussien avec TensorFlow

L'objectif de l'algorithme est de classer les ménages gagnant plus ou moins de 50 $.

Vous évaluerez un apprentissage automatique de régression de noyau logistique pour disposer d'un modèle de référence. Après cela, vous formerez un classificateur Kernel pour voir si vous pouvez obtenir de meilleurs résultats.

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

  • âge
  • classe ouvrière
  • fnlwgt
  • l'éducation
  • num_education
  • matrimonial
  • occupation
  • relations
  • breed
  • sexe
  • gain_capital
  • perte_de_capital
  • heures_semaine
  • pays d'origine
  • étiquette

Vous procéderez comme suit avant d'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) Construire le classificateur du noyau
  • Étape 8) Évaluer le classificateur du noyau

Étape 1) Importer les bibliothèques

Pour importer et entraîner des modèles de noyau dans Intelligence Artificielle, vous devez importer Tensorflow, pandas et numpy

#import numpy as np
from sklearn.model_selection 
import train_test_split
import tensorflow as tf
import pandas as pd
import numpy as np

Étape 2) Importez les données

Vous téléchargez les données à partir de ce qui suit site de NDN Collective et vous l'importez en tant que dataframe panda.

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

Maintenant que l'ensemble d'entraînement et de test est défini, vous pouvez modifier l'étiquette de la colonne de chaîne en entier. tensorflow n'accepte pas de 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éparer les données

L'ensemble de données contient à la fois des fonctionnalités 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 de l'ensemble d'entraînement et de test. Notez que vous concaténez les variables continues et catégorielles à un ensemble de données commun et que 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 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

La fonction de transformation est prête, vous pouvez convertir l'ensemble 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)

À 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 fonctionnalités avec l'objet real_valued_column. Cela garantira 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 l'endroit 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': <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}

Vous entraînerez la régression logistique en utilisant des mini-lots de taille 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)

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 = 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>

Étape 6) Évaluer le modèle

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

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

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) Construire le classificateur du noyau

L'estimateur à 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 dimension basse en dimension haute à l'aide d'une fonction noyau. Plus précisément, vous utiliserez le Random Fourier, 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 suivrez 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éfinir la fonction Kernel de haute dimension

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

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

  • entrée_dim = 14
  • sortie_dim= 5000
  • stdev=4
### Prep Kernel
kernel_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 auparavant : feat_column

### Map Kernel
kernel_mappers = {feat_column: [kernel_mapper]}

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

Pour éviter le surajustement, vous pénalisez la fonction de perte avec le régularisateur L2. Vous définissez l'hyperparamètre L2 à 0.1 et le taux d'apprentissage à 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 modifiez le répertoire modèle.

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

É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

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

Étape E) Évaluer le modèle

Enfin et surtout, vous évaluez les performances de votre modèle. Vous devriez pouvoir vaincre la régression logistique.

# 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

La précision finale est de 84%, soit 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 est longue et coûteuse en termes de calcul.

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

Définir la fonction Kernel de haute dimension

  • entrée_dim = 14
  • sortie_dim= 5000
  • stdev=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)