Comment les méthodes à noyau se comparent-elles aux réseaux de neurones ?

Une méthode à noyau corrige la carte des caractéristiquesping Un réseau de neurones apprend à l'avance uniquement les poids linéaires, ce qui lui permet de s'entraîner rapidement même avec des données modestes. Un réseau neuronal, quant à lui, apprend sa propre représentation, qui s'adapte mieux aux très grands ensembles de données non structurés, comme les images.

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

⚡ Résumé intelligent

Les méthodes à noyau gaussien rendent linéairement séparables des données non séparables sans nécessiter la construction d'une carte de caractéristiques de haute dimension. Cette présentation illustre la carte polynomiale.ping à la main, puis entraîne un classificateur à noyau de Fourier aléatoire dans TensorFlow.

(I.e. Problème de séparabilité : Les classificateurs linéaires échouent lorsqu'aucune ligne droite ne divise les classes dans l'espace des caractéristiques d'origine.
☑️ Carte polynomialeping: La transformation en x au carré, racine-deux xy et y au carré élève deux dimensions en trois et sépare les données de l'échantillon.
✅ Astuce du noyau : Un noyau renvoie directement le produit scalaire des vecteurs mappés, de sorte qu'aucune carte de caractéristiques étendue n'est jamais stockée.
🧪 Trois noyaux : Le modèle linéaire convient à la classification de texte, le modèle polynomial capture les interactions entre les caractéristiques et le modèle RBF gaussien mesure la similarité basée sur la distance.
️ Compilation de TensorFlow : RandomFourierFeatureMapper projette 14 caractéristiques en 5 000 dimensions avant que KernelLinearClassifier ne soit entraîné avec un optimiseur Ftrl.
📈 Résultat mesuré : Le classificateur à noyau atteint une précision de 0.83975184 contre 0.82353663 pour la ligne de base logistique.

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

Transformation des fonctionnalités
Entraînez un classificateur à noyau avec TensorFlow

Dans la première partie, vous comprendrez le principe des méthodes à noyau en apprentissage automatique, tandis que dans la seconde partie, vous verrez comment entraîner un classificateur à noyau. TensorFlowVous utiliserez l'ensemble de données concernant les adultes. L'objectif de cet ensemble de données est de classer les revenus en fonction de leur niveau (inférieur ou supérieur à 50 000 €), en connaissant le comportement de chaque ménage.

Pourquoi avez-vous besoin des méthodes du noyau ?

L'objectif de tout classificateur est de prédire correctement les classes. Pour cela, l'ensemble de données doit être séparable. Observez le graphique ci-dessous : il est assez simple de constater que tous les points situés au-dessus de la ligne noire appartiennent à la première classe et les autres à la seconde. 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, et ces données non séparables compliquent considérablement la tâche des classificateurs simples comme la 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], &#x27;k-', lw=2)
  ax.set_xlim([-5,15])
  ax.set_ylim([-5,15])plt.show()

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

Une solution à ce problème consiste à transformer les données du jeu de données en une autre carte de caractéristiques. Cela implique d'utiliser une fonction pour déplacer les données sur un autre plan, linéairement séparable.

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 se situent dans un plan bidimensionnel et ne sont pas séparables. Vous pouvez essayer de les transformer en trois dimensions, c'est-à-dire créer une figure à trois axes.

Dans notre exemple de noyau gaussien, nous appliquerons une application polynomialeping pour donner une troisième dimension à nos données. La formule de transformation des données est la suivante.

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. Chaque ligne ci-dessous associe un terme de la carteping avec l'expression matricielle qui la produit, et la petite image marque la racine carrée de deux facteurs.

Laits en poudre	Code NumPy équivalent
x	x[:,0]
y	x[:,1]
x²	x[:,0]**2
	np.sqrt(2)*
xy	x[:,0]*x[:,1]
y²	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 carteping Elle possède 3 dimensions et 16 points.

x_1  = mapping(x, y)
x_1.shape

(3, 16)

Créez maintenant un nouveau graphique avec 3 axes, x, y et z respectivement.

# plot
fig = plt.figure()
ax = fig.add_subplot(111, projection=&#x27;3d')
ax.scatter(x_1[0], x_1[1], x_1[2], c=label, s=60)
ax.view_init(30, 185)ax.set_xlabel(&#x27;X Label')
ax.set_ylabel(&#x27;Y Label')
ax.set_zlabel(&#x27;Z Label')
plt.show()

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

# plot
fig = plt.figure()
ax = fig.add_subplot(111, projection=&#x27;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(&#x27;X Label')
ax.set_ylabel(&#x27;Y Label')
ax.set_zlabel(&#x27;Z Label')plt.show()

Si vous devez manipuler un grand ensemble de données et créer plus de deux dimensions, la méthode décrite ci-dessus vous posera un problème majeur. En effet, il vous faudra transformer tous les points de données, ce qui est clairement impossible à réaliser en pratique. Cela vous prendra un temps considérable et votre ordinateur risque de manquer de mémoire.

La méthode la plus courante pour résoudre ce problème consiste à utiliser un noyau.

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

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

Il existe de nombreux espaces de dimension supérieure qui rendent les points de données séparables. Par exemple, nous avons montré que l'application polynomialeping est un bon début.

Nous avons également démontré qu'avec de grandes quantités de données, ces transformations sont inefficaces. Il est préférable d'utiliser une fonction noyau en apprentissage automatique pour modifier les données sans passer à un nouveau plan de caractéristiques.

Le principe du noyau est de trouver une fonction qui évite tous les problèmes liés aux calculs en grande dimension. Le résultat d'un noyau est un scalaire, autrement dit, on revient à un espace unidimensionnel.

Une fois cette fonction trouvée, vous pouvez l'intégrer au classificateur linéaire standard.

Voici un exemple concret pour illustrer le concept d'apprentissage automatique à noyau. Vous avez deux vecteurs, x1 et x2. L'objectif est de créer une dimension supérieure à l'aide d'une application polynomiale.pingLe résultat est égal au produit scalaire de la nouvelle carte de caractéristiques. D'après la méthode ci-dessus, vous devez :

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

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 le point objet à partir de NumPy 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

Le résultat est 8100. Vous voyez le problème : il faut stocker une nouvelle carte des caractéristiques en mémoire pour calculer le produit scalaire. Si votre jeu de données contient des millions d’enregistrements, cette opération est inefficace.

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 l'espace de dimension supérieure. Autrement dit, une fonction noyau calcule le résultat du produit scalaire à partir d'un autre espace de caractéristiques.

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. La plus simple est le noyau linéaire. Cette fonction est particulièrement performante pour la classification de texte. Les autres noyaux sont :

Noyau polynomial
Noyau gaussien

Le tableau ci-dessous résume le rôle de chacun et les situations dans lesquelles les praticiens y ont recours.

Noyau	Ce qu'il calcule	Utilisation typique
luminaires Néon Del	Le produit scalaire simple dans l'espace des caractéristiques d'origine	Données déjà séparables et fonctionnalités textuelles de haute dimension
Polynôme	Le produit scalaire élevé à un degré p, capturant les interactions entre les fonctionnalités	Frontières courbes lorsque les interactions sont connues pour avoir une importance
Gaussienne (RBF)	Une similarité basée sur la distance qui tend vers zéro à mesure que les points s'éloignent les uns des autres.	Le premier choix habituel lorsque la forme de la frontière est inconnue

Dans l'exemple avec TensorFlow, nous utiliserons des caractéristiques de Fourier aléatoires. TensorFlow possède un estimateur intégré pour calculer le nouvel espace de caractéristiques. Le mappeur de caractéristiques de Fourier aléatoires est une approximation de la fonction noyau gaussienne illustrée ci-dessous.

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

La théorie étant établie, la suite de ce tutoriel met en application un noyau gaussien sur un jeu de données réel.

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 commencerez par évaluer une régression logistique afin d'obtenir un modèle de référence. Ensuite, vous entraînerez un classificateur à noyau 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 :

Importer les bibliothèques
Importez les données
Préparer les données
Construire le modèle logistique : modèle de base
Évaluer le modèle
Construire et évaluer le classificateur à noyau

Note de version : Chaque extrait de code ci-dessous cible TensorFlow 1.x. L'espace de noms `tf.contrib`, qui fournit `real_valued_column`, `RandomFourierFeatureMapper` et `KernelLinearClassifier`, a été supprimé dans TensorFlow 2.0, et `tf.estimator` lui-même a été supprimé dans TensorFlow 2.16. Sur une version actuelle, construisez le même pipeline avec la couche `tf.keras.layers.experimental.RandomFourierFeatures` suivie d'une couche de sortie Dense, ou avec la paire `RBFSampler` et `SGDClassifier` de scikit-learn.

Étape 1) Importez 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 depuis le page de données pour adultes de l'UCI et importez-le en tant que DataFrame pandas.

## Define path data
COLUMNS = [&#x27;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)

Une fois les ensembles d'entraînement et de test définis, vous pouvez modifier l'étiquette de la colonne : au lieu d'une chaîne de caractères, elle doit être un entier. TensorFlow n'accepte pas les chaînes de caractères pour cette étiquette.

label = {&#x27;<=50K': 0,'>50K': 1}
df_train.label = [label[item] for item in df_train.label]
label_t = {&#x27;<=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 des variables continues et catégorielles. Il est recommandé de standardiser les valeurs des variables continues. Vous pouvez utiliser la fonction StandardScaler de scikit-apprendreVous créez également une fonction personnalisée pour faciliter la conversion des ensembles d'entraînement et de test. Notez que vous concaténez les variables continues et catégorielles dans un ensemble de données commun, et que le tableau doit être de type float32.

COLUMNS_INT = [&#x27;age','fnlwgt','education_num','capital_gain', 'capital_loss', 'hours_week']
CATE_FEATURES = [&#x27;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[&#x27;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 donc 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(&#x27;features', dimension=14)

L'estimateur est défini à l'aide de l'API TensorFlow Estimator ; vous fournissez les colonnes de caractéristiques et l'emplacement où enregistrer le graphe.

estimator = tf.estimator.LinearClassifier(feature_columns=[feat_column],
                                          n_classes=2,
                                          model_dir = "kernel_log"
                                         )

INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {&#x27;_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 5) Évaluer le modèle

Vous définissez la fonction d'entrée NumPy pour évaluer le modèle. Vous utilisez l'ensemble de test complet 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

{&#x27;accuracy': 0.82353663,
 &#x27;accuracy_baseline': 0.76377374,
 &#x27;auc': 0.84898686,
 &#x27;auc_precision_recall': 0.67214864,
 &#x27;average_loss': 0.3877216,
 &#x27;global_step': 1000,
 &#x27;label/mean': 0.23622628,
 &#x27;loss': 6312.495,
 &#x27;precision': 0.7362797,
 &#x27;prediction/mean': 0.21208474,
 &#x27;recall': 0.39417577}

Vous obtenez une précision de 82 %. Dans la section suivante, vous tenterez de surpasser le classificateur logistique à l'aide d'un classificateur à noyau.

Étape 6) Construire le classificateur du noyau

L'estimateur à noyau n'est pas si différent du classificateur linéaire traditionnel, du moins en termes de construction. L'idée sous-jacente est de combiner la puissance d'une fonction noyau explicite.ping 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 qu'il est nécessaire de transformer la faible dimension en une dimension supérieure à l'aide d'une fonction noyau. Plus précisément, vous utiliserez des caractéristiques de Fourier aléatoires, qui approximent la fonction gaussienne. TensorFlow 1.x fournit cette fonction.ping comme RandomFourierFeatureMapper, et le modèle peut être entraîné à l'aide de l'estimateur KernelLinearClassifier.

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

Définir la fonction Kernel de haute dimension
Définir l'hyperparamètre L2
Construisez le modèle
Former le modèle
Évaluer le modèle

Étape A) Définir la fonction noyau de grande dimension

L'ensemble de données actuel contient 14 caractéristiques que vous allez transformer en un nouveau vecteur de dimension 5 000. Cette transformation s'effectue à l'aide de caractéristiques de Fourier aléatoires. Si vous vous souvenez de la formule du noyau gaussien, vous remarquerez la présence d'un paramètre d'écart type à définir. Ce paramètre contrôle la mesure de similarité utilisée lors de la classification : un écart type faible fait que le noyau ne considère comme similaires que les points très proches, tandis qu'un écart type élevé lisse la frontière de décision.

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

entrée_dim = 14
output_dim = 5000
écart type = 4

### Prep Kernel
kernel_mapper = tf.contrib.kernel_methods.RandomFourierFeatureMapper(input_dim=14, output_dim=5000, stddev=4, name=&#x27;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 surapprentissage, vous pénalisez la fonction de perte avec la régularisation L2. Vous fixez 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) Construire le modèle

L'étape suivante est similaire à la classification linéaire. Vous utilisez l'estimateur intégré KernelLinearClassifier. Notez qu'il faut ajouter le noyau mapper défini précédemment et modifier le répertoire du modèle.

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

Les avertissements de dépréciation ci-dessous sont attendus sur TensorFlow 1.x, car le module kernel_methods est construit sur les anciens estimateurs tf.contrib.learn.

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: {&#x27;_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
}
, &#x27;_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) Entraîner le modèle

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

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

WARNING:tensorflow:Casting <dtype: &#x27;int32'> labels to bool.
WARNING:tensorflow:Casting <dtype: &#x27;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={&#x27;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: &#x27;int32'> labels to bool.
WARNING:tensorflow:Casting <dtype: &#x27;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 environ 1.6 point de pourcentage de plus que la régression logistique de référence (0.83975184 contre 0.82353663). Il existe un compromis entre l'amélioration de la précision et le coût de calcul. Il convient d'évaluer si cette amélioration justifie le temps de calcul plus important qu'implique l'utilisation d'un classificateur plus lourd et si elle aura un impact significatif sur votre activité.

FAQ

L'astuce du noyau calcule le produit scalaire que deux vecteurs auraient après une application de grande dimension.ping, sans jamais construire cette cartepingLa fonction polynomial_kernel de ce tutoriel renvoie directement 8100, la même valeur que celle produite par la transformation tridimensionnelle explicite.

Non. La couche `tf.contrib` a été supprimée dans TensorFlow 2.0 et la couche `tf.estimator` dans la version 2.16 ; par conséquent, les couches `real_valued_column`, `RandomFourierFeatureMapper` et `KernelLinearClassifier` ne sont plus disponibles. Utilisez la couche `tf.keras.layers.experimental.RandomFourierFeatures` avec une sortie Dense, ou `RBFSampler` avec `SGDClassifier`.

Les outils de recherche automatisés analysent le type de noyau, le degré, le gamma ou l'écart type, ainsi que la force de régularisation lors d'exécutions parallèles, puis les classent selon un score validé par validation croisée. Ils transforment la sélection de noyau en une comparaison mesurée, même si vous définissez toujours le budget de recherche et la métrique de score.

Il définit rapidement la structure de base : mise à l’échelle des caractéristiques, appel au mappeur, estimateur et boucle d’évaluation. Considérez les suggestions comme une première approche, car Copilote GitHub reproduit facilement les API TensorFlow 1.x supprimées qui ne sont plus importées dans les versions actuelles.

Il détermine la largeur de la courbe de similarité. Un écart type faible ne considère comme similaires que les points très proches, ce qui produit une frontière étroite et sinueuse pouvant entraîner un surapprentissage. Un écart type élevé lisse la frontière et rapproche le modèle d'un ajustement linéaire.

Il s'agit du nombre de caractéristiques de Fourier aléatoires utilisées pour approximer le noyau gaussien. Plus le nombre de caractéristiques est élevé, meilleure est l'approximation du noyau et généralement meilleure est la précision, au prix d'un vecteur de poids plus large et d'un apprentissage plus lent pour chaque lot.

Une méthode à noyau exact compare chaque paire de points d'entraînement, ce qui fait que le coût augmente approximativement avec le carré du nombre d'échantillons. Les caractéristiques de Fourier aléatoires contournent ce problème en approximant le noyau par une projection de largeur fixe.

Une méthode à noyau corrige la carte des caractéristiquesping Il apprend à l'avance et ne connaît que les poids linéaires, ce qui lui permet de s'entraîner rapidement sur des données modestes. Réseau neuronal elle apprend sa propre représentation, qui s'adapte mieux aux très grands ensembles de données non structurés comme les images.

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

Pourquoi avez-vous besoin des méthodes du noyau ?

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

Transformez x1 et x2 dans une nouvelle dimension

Calculer le produit scalaire

Types de méthodes du noyau

Entraîner le classificateur à noyau gaussien avec TensorFlow

Étape 1) Importez les bibliothèques

Étape 2) Importez les données

Étape 3) Préparez les données

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

Étape 5) Évaluer le modèle

Étape 6) Construire le classificateur du noyau

Étape A) Définir la fonction noyau de grande dimension

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

Étape C) Construire le modèle

Étape D) Entraîner le modèle

Étape E) Évaluer le modèle

FAQ

Résumez cet article avec :

Enregistrez-vous pour recevoir le bulletin d'informations

Pourquoi avez-vous besoin des méthodes du noyau ?

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

Transformez x1 et x2 dans une nouvelle dimension

Calculer le produit scalaire

ARTICLES LIÉS

Types de méthodes du noyau

Entraîner le classificateur à noyau gaussien avec TensorFlow

Étape 1) Importez les bibliothèques

Étape 2) Importez les données

Étape 3) Préparez les données

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

Étape 5) Évaluer le modèle

Étape 6) Construire le classificateur du noyau

Étape A) Définir la fonction noyau de grande dimension

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

Étape C) Construire le modèle

Étape D) Entraîner le modèle

Étape E) Évaluer le modèle

FAQ

Résumez cet article avec :

Enregistrez-vous pour recevoir le bulletin d'informations