LD-SVM à deux classes

  • Article

Important

Le support de Machine Learning Studio (classique) prend fin le 31 août 2024. Nous vous recommandons de passer à Azure Machine Learning avant cette date.

À partir du 1er décembre 2021, vous ne pourrez plus créer de nouvelles ressources Machine Learning Studio (classique). Jusqu’au 31 août 2024, vous pouvez continuer à utiliser les ressources Machine Learning Studio (classique) existantes.

La documentation ML Studio (classique) est en cours de retrait et ne sera probablement plus mise à jour.

Crée un modèle de classification binaire en utilisant l'algorithme LD-SVM

Catégorie : Machine Learning / Initialiser le modèle / Classification

Notes

S’applique à : Machine Learning Studio (classique) uniquement

Des modules par glisser-déposer similaires sont disponibles dans Concepteur Azure Machine Learning.

Vue d’ensemble du module

Cet article explique comment utiliser le module Machine à vecteurs de support profond (SVM) à deux classes dans Machine Learning Studio (classique) pour créer un classifieur de machines à vecteurs de support non linéaire (SVM) à deux classes, optimisé pour une prédiction efficace.

Les machines à vecteurs de support (SVM) sont une classe extrêmement populaire et bien recherché de modèles d’apprentissage supervisés, qui peuvent être utilisés dans des tâches de classification linéaires et non linéaires. Les études récentes se sont concentrées sur des moyens d'optimiser ces modèles pour les adapter de manière efficace à des jeux d'apprentissage plus volumineux. Dans cette implémentation de Microsoft Research, la fonction noyau utilisée pour le mappage des points de données à l'espace de caractéristiques a été spécialement conçue pour réduire le temps nécessaire à l'apprentissage, tout en conservant en grande partie la précision de classification.

Ce modèle est une méthode d’apprentissage supervisée, et nécessite donc un jeu de données balisé, qui inclut une colonne d’étiquette.

Après avoir défini les paramètres du modèle, effectuez l’apprentissage en fournissant le modèle et un jeu de données balisé comme entrée pour entraîner des hyperparamètresde modèle ou ajuster le modèle. Le modèle formé peut ensuite être utilisé pour prédire des valeurs pour les nouvelles entrées.

Comment configurer Two-Class machine à vecteurs de support profond localement

  1. Ajoutez le module Machine à vecteurs de support Locally-Deep à votre expérience dans Studio (classique).

  2. Spécifiez le mode d’apprentissage du modèle en définissant l’option Créer un mode d’apprentissage.

    • Single Parameter (Paramètre unique) : si vous savez comment vous voulez configurer le modèle, fournissez un ensemble spécifique de valeurs en tant qu’arguments.

    • Plage de paramètres : si vous n’êtes pas sûr des meilleurs paramètres, vous pouvez trouver les paramètres optimaux en spécifiant plusieurs valeurs et en utilisant le module Tune Model Hyperparameters pour trouver la configuration optimale. Le formateur itère sur plusieurs combinaisons des paramètres que vous avez fournis et détermine la combinaison de valeurs qui produit le meilleur modèle.

  3. Pour la profondeur de l’arborescence, spécifiez la profondeur maximale de l’arborescence qui peut être créée par le modèle SVM (LD-SVM) d’apprentissage profond local.

    Le coût d'apprentissage augmente de façon linéaire avec la profondeur de l'arborescence. Par conséquent, choisissez une profondeur appropriée en fonction de la durée que vous pouvez consacrer à la création du modèle.

    Le temps d'apprentissage doit à peu près doubler lorsque la profondeur augmente d'une unité.

    La précision de prédiction doit augmenter, atteindre un pic, puis décroître à mesure que la profondeur augmente.

  4. Pour Lambda W, spécifiez le poids qui doit être donné au terme de régularisation.

    La régularisation restreint les composants de valeur volumineux dans le classifieur formé. Lorsque le nombre d'échantillons est insuffisant, en raison du nombre de fonctionnalités, vous pouvez utiliser la régularisation L2 pour éviter le surajustement. Les valeurs plus élevées pour Lambda W signifient qu’une plus grande importance est accordée à la régularisation des pondérations du classifieur et moins à l’erreur de classification du jeu d’entraînement.

    Si la valeur par défaut (0.1) ne fonctionne pas correctement, vous devez également essayer {0.0001, 0.001 et 0.01}.

  5. Pour Lambda Theta, spécifiez la quantité d’espace restant entre une limite de région et le point de données le plus proche.

    Ce modèle fonctionne en partitionnant l'espace de données et l'espace des fonctionnalités en régions. Lorsque Lambda Theta est réduit de telle sorte que les limites de la région dans le modèle formé soient trop proches des points de données d’entraînement, le modèle peut générer une erreur d’entraînement faible, mais une erreur de test élevée, en raison d’une surajustement.

    Pour réduire le nombre de paramètres qui doivent être validés, une bonne règle de pouce consiste à définir Lambda Theta sur un dixième de la valeur utilisée pour Lambda W. Les valeurs plus importantes signifient qu’il est plus important d’empêcher le surajustement que de réduire les erreurs de classification dans le jeu d’entraînement.

    Si la valeur par défaut (0,01) ne fonctionne pas correctement, vous pouvez également essayer {0,0001, 0,001 et 0,1}.

  6. Pour Lambda Theta Prime, tapez une valeur pour contrôler la quantité de courbure autorisée dans les limites de décision dans le modèle.

    Les valeurs plus volumineuses donnent au modèle la possibilité d’apprendre les limites de décision courbes, tandis que les valeurs plus petites peuvent limiter les limites de décision à un modèle linéaire au niveau des étapes.

    Ce paramètre fonctionne conjointement avec le paramètre Sigma . Pour réduire le nombre de paramètres qui doivent être validés, une règle empirique consiste à définir Thêta lambda prime sur un dixième de la valeur de Lambda W.

    Si la valeur par défaut (0,01) ne fonctionne pas correctement, vous pouvez également essayer {0,0001, 0,001 et 0,1}.

  7. Pour la netteté sigmoid, tapez une valeur à utiliser pour le paramètre de mise à l’échelle σ.

    Les valeurs plus grandes signifient que le tanh dans le noyau local Θ (théta) est saturé, tandis qu’une valeur plus petite implique une plage d’exploitation plus linéaire pour l’athée. Vous trouverez la formule d’optimisation complète dans la section Notes techniques .

    Si la valeur par défaut (1) ne donne pas satisfaction, vous pouvez aussi essayer {0,1, 0,01 et 0,001}.

  8. Dans Nombre d’itérations, indiquez combien de fois l’algorithme doit mettre à jour les paramètres du classifieur avec un sous-ensemble aléatoire d’exemples.

  9. Pour le normaliseur de fonctionnalités, choisissez une méthode à utiliser pour normaliser les valeurs de fonctionnalité. Les méthodes suivantes sont prises en charge :

    • Normaliseur de compartimentage : le normaliseur de compartimentage crée des bacs de taille égale, puis normalise chaque valeur dans chaque bac à diviser par le nombre total de compartiments.

    • Normaliseur gaussien : le normaliseur gaussien rescale les valeurs de chaque caractéristique pour avoir une moyenne de 0 et une variance de 1. Pour ce faire, calculez la moyenne et la variance de chaque fonctionnalité. Ensuite, pour chaque instance, la valeur moyenne est soustraite et le résultat divisé par la racine carrée de la variance (écart type).

    • Normaliseur Min-Max : le normaliseur min-max effectue une nouvelle mise à l’échelle linéaire de chaque fonctionnalité à l’intervalle [0,1].

      Le redimensionnement à l'intervalle [0,1] s'effectue en décalant les valeurs de chaque fonction afin que la valeur minimale soit 0, puis en divisant par la nouvelle valeur maximale (qui correspond à la différence entre les valeurs maximale et minimale d'origine).

    • Ne normalisez pas : aucune normalisation n’est effectuée.

  10. Dans valeur initiale de nombre aléatoire, tapez une valeur à utiliser comme valeur initiale si vous souhaitez garantir la reproductibilité entre les exécutions.

  11. Sélectionnez l’option Autoriser les niveaux catégoriels inconnus pour créer un groupe pour les valeurs inconnues dans les jeux de test ou de validation.

    Si vous la désélectionnez, le modèle ne peut accepter que les valeurs qui sont contenues dans les données d'apprentissage. Dans le premier cas, le modèle peut être moins précis pour les valeurs connues, mais il peut fournir de meilleures prédictions pour les nouvelles valeurs (inconnues).

  12. Connecter un jeu de données balisé et l’un des modules d’entraînement :

    Notes

    Si vous transmettez une plage de paramètres au module Entraîner le modèle, il utilise uniquement la première valeur dans la liste de plages de paramètres.

    Si vous transmettez un ensemble unique de valeurs de paramètre au module Optimiser les hyperparamètres du modèle, quand il attend une plage de paramètres pour chaque paramètre, il ignore les valeurs et utilise les valeurs par défaut pour l’apprenant.

    Si vous sélectionnez l’option Plage de paramètres et que vous entrez une valeur unique pour un paramètre, cette valeur unique que vous avez spécifiée est utilisée tout au long du balayage, même si d’autres paramètres changent sur une plage de valeurs.

  13. Exécutez l’expérience.

Résultats

Une fois l’apprentissage terminé :

  • Pour afficher un résumé des paramètres du modèle, cliquez avec le bouton droit sur la sortie du module Entraîner le modèle ou paramétrez le module Hyperparamètres de modèle , puis sélectionnez Visualiser.

  • Pour enregistrer un snapshpt du modèle entraîné, cliquez avec le bouton droit sur la sortie du modèle formé , puis sélectionnez Enregistrer en tant que modèle formé. Ce modèle n’est pas mis à jour lors des exécutions consécutives de la même expérience.

  • Pour effectuer une validation croisée sur un jeu de données étiqueté, connectez le modèle non formé au modèle de validation croisée.

Notes techniques

Cette section contient des détails, des conseils et des réponses aux questions fréquentes concernant l’implémentation.

Conseils d’utilisation

Ce classifieur LD-SVM est particulièrement utile dans les conditions suivantes :

  • Vous avez un problème de classification binaire ou vous pouvez réduire votre problème à une tâche de classification binaire.

  • Vous avez essayé un classifieur linéaire, mais il ne s'est pas avéré très efficace.

  • Vous avez essayé une SVM non linéaire ou un autre classifieur et avez obtenu une précision de classification correcte, mais l'apprentissage du modèle a pris trop de temps.

  • Vous pouvez vous permettre de sacrifier la précision de prédiction pour réduire le temps d'apprentissage.

Les modèles LD-SVM s'avèrent un bon choix si la complexité de vos données empêche les modèles linéaires (tels que la régression logistique) de fonctionner correctement. De même, les modèles LD-SVM sont assez petits pour être utilisés dans des scénarios d'appareils mobiles ou autre, là où les modèles complexes (tels que les réseaux neuronaux) sont trop volumineux pour être utilisés efficacement.

À l'inverse, ce modèle ne doit pas être utilisé si vous ne vous souciez pas de la taille du modèle ou si un modèle linéaire est requis pour des raisons de simplicité ou de vitesse de prédiction. Il n’existe pas non plus de changement vers LD-SVM si les classifieurs linéaires donnent déjà de bons résultats, ou si vous pouvez obtenir une précision de classification élevée en ajoutant de petites quantités de non-linéarité.

Informations d’implémentation

Le modèle LD-SVM a été développé par Microsoft Research dans un souci constant d'accélérer la prédiction SVM non linéaire. Les travaux de Gonen et Alpaydin (2008) sur la méthode LMKL (Localized Multiple Kernel Learning) ont été particulièrement fructueux. L'utilisation d'une fonction à noyaux locaux permet au modèle d'apprendre les incorporations de caractéristiques locales arbitraires, y compris les caractéristiques à dimensions élevées, éparpillées et exigeant des calculs intensifs qui introduisent une non-linéarité dans le modèle.

Le modèle LD-SVM est plus rapide que la plupart des autres classifieurs pour plusieurs raisons :

  • Le modèle apprend les limites de décision localement linéaires. Par conséquent, il est possible de classifier efficacement un point de test en le testant par rapport à sa limite de décision locale au lieu de le tester par rapport à l'ensemble complet de limites de décision à l'échelle de l'espace de caractéristiques.

  • Le modèle utilise des routines primales efficaces pour optimiser l'espace d'incorporations de caractéristiques locales en arborescence qui évoluent en jeux d'apprentissage volumineux comptant plus d'un demi-million de points d'apprentissage.

  • Le coût inhérent au test d'un point par rapport à sa limite de décision locale est logarithmique dans le nombre de points d'apprentissage.

En raison de ces optimisations, l'apprentissage du modèle LD-SVM est exponentiellement plus rapide que l'apprentissage des modèles SVM classiques.

Formule d'optimisation

optimization formula

Recherche

Pour plus d’informations sur l’algorithme et la recherche sous-jacente, consultez local Deep Kernel Learning for Efficient Non-Linear SVM Prediction.

Paramètres du module

Nom Plage Type Default Description
Créer le mode de formateur List Option des paramètres de l'apprenant Paramètre unique Options avancées pour apprenant :

1. Créer un apprenant à l’aide d’un seul paramètre
2. Créer un apprenant à l’aide d’une plage de paramètres
Profondeur de l'arborescence >=1 Integer 3 Profondeur de l'arborescence LD-SVM.
Lambda W >=1,401298E-45 Float 0.1 Poids de régularisation pour le paramètre de classifieur Lambda W.
Thêta lambda >=1,401298E-45 Float 0,01 Poids de régularisation pour le paramètre de classifieur Thêta lambda.
Lambda thêta prime >=1,401298E-45 Float 0,01 Poids de régularisation pour le paramètre de classifieur Lambda thêta prime.
Précision sigmoïde >=1,401298E-45 Float 1.0 Précision sigmoïde
Profondeur de l'arborescence [1;int.MaxValue] ParameterRangeSettings 1; 3; 5; 7 Plage de la profondeur de l'arborescence LD-SVM.
Lambda W [1,401298E-45;3,40282347E+38] ParameterRangeSettings 0.1; 0.01; 0.001 Plage du poids de régularisation pour le paramètre de classifieur Lambda W.
Thêta lambda [1,401298E-45;3,40282347E+38] ParameterRangeSettings 0.1; 0.01; 0.001 Plage du poids de régularisation pour le paramètre de classifieur Thêta lambda.
Lambda thêta prime [1,401298E-45;3,40282347E+38] ParameterRangeSettings 0.1; 0.01; 0.001 Plage du poids de régularisation pour le paramètre de classifieur Lambda thêta prime'.
Précision sigmoïde [1,401298E-45;3,40282347E+38] ParameterRangeSettings 1.0; 0.1; 0.01 Plage de la précision sigmoïde
Normalisation de la fonctionnalité List Type de normalisation Normalisation Min-Max Type de normalisation à appliquer aux exemples d'apprentissage
Nombre d'itérations >=1 Integer 15000 Nombre d'itérations d'apprentissage
Nombre d'itérations [1;int.MaxValue] ParameterRangeSettings 10000; 15000; 20000 Plage pour le nombre d'itérations d'apprentissage
Valeur initiale de nombre aléatoire Quelconque Integer Valeur de départ pour le générateur de nombres aléatoires utilisé par le modèle. Laissez le champ vide pour utiliser la valeur par défaut.
Autoriser les niveaux catégoriels inconnus Quelconque Boolean True Si la valeur est true, un niveau supplémentaire est créé pour chaque colonne catégorielle. Tous les niveaux du jeu de données de test qui ne sont pas disponibles dans le jeu de données d'apprentissage sont mappés à ce niveau supplémentaire.

Output

Nom Type Description
Untrained model (Modèle non entraîné) Interface ILearner Modèle de classification binaire non formé.

Voir aussi

Classification
Liste alphabétique des modules