Partager via

Caractérisation des données dans le Machine Learning automatisé (AutoML)

S’APPLIQUE À :Kit de développement logiciel (SDK) Azure Machine Learning v1 pour Python

Important

Cet article fournit des informations sur l’utilisation du Kit de développement logiciel (SDK) Azure Machine Learning v1. Le SDK v1 est déprécié depuis le 31 mars 2025 et la prise en charge de celui-ci prendra fin le 30 juin 2026. Vous pouvez installer et utiliser le Kit de développement logiciel (SDK) v1 jusqu’à cette date.

Nous vous recommandons de passer au SDK v2 avant le 30 juin 2026. Pour plus d’informations sur le Kit de développement logiciel (SDK) v2, consultez Présentation du Kit de développement logiciel (SDK) Python Azure Machine Learning v2 et référence du Kit de développement logiciel (SDK) v2.

Cet article décrit comment personnaliser les paramètres de caractérisation de données dans Azure Machine Learning pour vos expériences de Machine Learning automatisé (AutoML).

Ingénierie des caractéristiques et caractérisation

Les données pour l’apprentissage se composent de lignes et de colonnes. Chaque ligne est une observation ou un enregistrement et les colonnes de chaque ligne sont les caractéristiques qui décrivent chaque enregistrement. En général, les caractéristiques qui caractérisent le mieux les modèles dans les données sont sélectionnées pour créer des modèles prédictifs.

Bien que la plupart des champs de données brutes puissent être utilisés directement pour entraîner un modèle, il est souvent nécessaire de créer d’autres fonctionnalités (conçues) qui fournissent des informations pour mieux différencier les modèles dans les données. Ce processus est appelé ingénierie des fonctionnalités, où l'utilisation des connaissances du domaine des données est utilisée pour créer des fonctionnalités qui, à leur tour, aident les algorithmes d'apprentissage automatique à mieux apprendre.

Dans Azure Machine Learning, des techniques de mise à l’échelle et de normalisation des données sont appliquées pour faciliter l’ingénierie de caractéristiques. Collectivement, ces techniques et cette ingénierie de caractéristiques sont appelées caractérisation dans les expériences AutoML.

Prérequis

Cet article suppose que vous savez déjà comment configurer une expérience AutoML.

Important

Les commandes Python de cet article nécessitent la dernière version du package azureml-train-automl.

Pour plus d'informations sur la configuration, consultez les articles suivants :

Configuration de la caractérisation

Dans chaque expérience AutoML, les techniques de mise à l’échelle et de normalisation automatiques sont appliquées à vos données par défaut. Ces techniques sont des types de caractérisation qui aident certains algorithmes sensibles aux caractéristiques à des échelles différentes. Vous pouvez activer davantage de fonctionnalités, telles que l'imputation des valeurs manquantes, l'encodage et les transformations.

Remarque

Les étapes de caractérisation AutoML (telles que la normalisation des fonctionnalités, la gestion des données manquantes ou la conversion de texte en texte numérique) font partie du modèle sous-jacent. Lorsque vous utilisez le modèle pour des prédictions, les étapes de caractérisation qui sont appliquées pendant la formation sont appliquées automatiquement à vos données d’entrée.

Pour les expériences configurées avec le Kit de développement logiciel (SDK) Python, vous pouvez activer ou désactiver le paramètre de caractérisation et spécifier les étapes de caractérisation qui doivent être utilisées pour votre expérience. Si vous utilisez le studio Azure Machine Learning, consultez les étapes pour activer la caractérisation.

Le tableau suivant présente les paramètres acceptés pour featurization dans la classe AutoMLConfig :

Configuration de la caractérisation Descriptif
"featurization": 'auto' Spécifie que, dans le cadre du prétraitement, les garde-fous des données et les étapes de caractérisation doivent être effectués automatiquement. Il s’agit du paramètre par défaut.
"featurization": 'off' Indique que les étapes de caractérisation ne doivent pas être effectuées automatiquement.
"featurization": 'FeaturizationConfig' Indique que des étapes de caractérisation personnalisées doivent être utilisées. Pour plus d’informations, consultez Personnaliser la caractérisation.

Caractérisation automatique

Le tableau suivant récapitule les techniques appliquées automatiquement à vos données. Ces techniques sont appliquées pour les expériences configurées à l’aide du SDK ou de l’interface utilisateur du studio. Pour désactiver ce comportement, définissez "featurization": 'off' dans votre objet AutoMLConfig.

Étapes de caractérisation Descriptif
Supprimer les caractéristiques de cardinalité élevée ou d’absence de variance* Supprime ces fonctionnalités des ensembles de formation et de validation. S'applique aux fonctionnalités dont toutes les valeurs sont manquantes, avec la même valeur sur toutes les lignes ou avec une cardinalité élevée (par exemple, des hachages, des IDs ou des GUID).
Imputer des valeurs manquantes* Pour les fonctionnalités numériques, remplacement par la moyenne des valeurs dans la colonne.

Pour les fonctionnalités catégorielles, remplacement par la valeur la plus fréquente.
Générer davantage de caractéristiques* Pour les fonctionnalités DateTime : année, mois, jour, jour de semaine, jour de l’année, trimestre, semaine de l’année, heure, minute, seconde.

Pour les tâches de prévision, ces fonctionnalités DateTime supplémentaires sont créées : année ISO, demi-année, mois calendrier sous forme de chaîne, semaine, jour de semaine sous forme de chaîne, jour de trimestre, jour de l’année, AM/PM (0 pour am, 1 pour pm), AM/PM comme chaîne, heure de jour (base de 12 heures).

Pour les caractéristiques de Texte : fréquence de terme basée sur des unigrammes, des bigrammes et des trigrammes. Pour en savoir plus, consultez l’intégration de BERT.
Transformer et encoder* Les fonctionnalités numériques avec très peu de valeurs uniques sont transformées en fonctionnalités catégorielles.

L’encodage one-hot est utilisé pour les fonctionnalités catégoriques de faible cardinalité. L'encodage one-hot-hash est utilisé pour les caractéristiques catégorielles à cardinalité élevée.
Incorporations de mots Caractériseur de texte convertissant les vecteurs de jetons de texte en vecteurs de phrase à l’aide d’un modèle déjà formé. Le vecteur d’incorporation de chaque mot d’un document est agrégé avec le reste pour produire un vecteur de fonctionnalité de document.
Distance du cluster Effectue l’apprentissage d’un modèle de clustering k-moyennes sur toutes les colonnes numériques. Produit k nouvelles fonctionnalités (une nouvelle fonctionnalité numérique par cluster) qui contiennent la distance de chaque échantillon au centroïde de chaque cluster.

Remarque

*Si vous envisagez d’exporter vos modèles créés automatiquement vers un modèle ONNX, seules les options de caractérisation indiquées avec un astérisque sont prises en charge au format ONNX. Pour plus d’informations, consultez Effectuer des prédictions avec un modèle ONNX AutoML.

Dans chaque expérience AutoML, vos données sont automatiquement mises à l’échelle ou normalisées pour aider les algorithmes à s’exécuter correctement. Lors de la formation du modèle, l’une des techniques de mise à l’échelle ou de normalisation suivantes est appliquée à chaque modèle.

Mise à l’échelle et traitement Descriptif
StandardScaler Normalise les fonctionnalités en supprimant la moyenne et la mise à l’échelle en variance unitaire.
MinMaxScaler Transforme les entités en mettant à l'échelle chaque entité en fonction du minimum et du maximum de cette colonne.
MaxAbsScaler Met à l’échelle chaque fonctionnalité en fonction de sa valeur absolue maximale.
RobustScaler Met à l’échelle les caractéristiques selon leur plage de quantiles.
PCA Analyse du composant principal. Réduction de dimensionnalité linéaire en utilisant une décomposition de valeur singulière des données pour les projeter sur un espace dimensionnel inférieur.
TruncatedSVD Ce transformateur effectue une réduction de dimensionnalité linéaire en utilisant une décomposition de valeur singulière (SVD) tronquée. Contrairement à PCA, cet estimateur ne centre pas les données avant de calculer la décomposition de valeur singulière, ce qui signifie qu’il peut fonctionner avec scipy.sparse des matrices efficacement.
Normalizer Chaque exemple (autrement dit, chaque ligne de la matrice de données) avec au moins un composant différent de zéro est remis à l’échelle indépendamment des autres exemples afin que sa norme (l1 ou l2) soit égale à un.

Garde-fous des données

Les garde-fous de données vous aident à identifier les problèmes potentiels liés à vos données, tels que les valeurs manquantes ou les données déséquilibrées. Ils vous aident également à prendre des mesures correctives pour améliorer les résultats.

Les Garde-fous des données sont appliqués :

  • Pour les expériences du Kit de développement logiciel (SDK) : lorsque les paramètres "featurization": 'auto' ou validation=auto sont spécifiés dans votre AutoMLConfig objet.
  • Pour les expériences en studio : lorsque la création de fonctionnalités automatisée est activée.

Vous pouvez consulter les Garde-fous des données pour votre expérience :

  • En définissant show_output=True lorsque vous soumettez une expérience à l’aide du kit de développement logiciel (SDK).
  • Dans le studio, sous l’onglet Garde-fous de données de votre exécution AutoML.

États des Garde-fous des données

Les garde-fous des données affichent l’un des trois états suivants :

État Descriptif
Passé Aucun problème de données n’a été détecté et aucune action n’est requise de votre part.
Fait Des modifications ont été appliquées à vos données. Nous vous encourageons à passer en revue les actions correctives prises par le ML automatisé pour vérifier que les modifications s’alignent sur les résultats attendus.
Alerté Un problème de données a été détecté mais n’a pas pu être résolu. Nous vous encourageons à examiner et à résoudre le problème.

Garde-fous des données pris en charge

Le tableau suivant décrit les garde-fous des données pris en charge ainsi que les états associés que vous pouvez rencontrer lors l’envoi de votre expérience :

Garde-fou Statut Condition de déclenchement
Imputation des valeurs de caractéristique manquantes Passé


Terminé		 Aucune valeur de fonctionnalité manquante n'a été détectée dans vos données de formation. Pour plus d’informations, consultez Configurer les paramètres de caractérisation.

Des valeurs de caractéristique manquantes ont été détectées dans vos données de formation et imputées.
Détection de caractéristiques à cardinalité élevée Passé


Terminé		 Aucune caractéristique à cardinalité élevée n’a été détectée après analyse de vos entrées.

Des caractéristiques à cardinalité élevée ont été détectées dans vos entrées et ont été gérées.
Gestion du fractionnement de la validation Terminé La configuration de la validation a été définie sur 'auto' et les données de formation contenaient moins de 20 000 lignes.
Chaque itération du modèle entraîné a été validée à l’aide de la validation croisée. Découvrez-en plus sur les données de validation.

La configuration de la validation a été définie sur 'auto' et les données de formation contenaient plus de 20 000 lignes.
Les données d’entrée ont été divisées en un ensemble de données de formation et un ensemble de données de validation pour la validation du modèle.
Détection de l’équilibrage des classes Passé




Alerté



Terminé		 Vos entrées ont été analysées et toutes les classes sont équilibrées dans vos données de formation. Un jeu de données est considéré comme équilibré si chaque classe a une bonne représentation dans le jeu de données, telle que mesurée par le nombre et le ratio des échantillons.

Des classes déséquilibrées ont été détectées dans vos entrées. Pour corriger le biais du modèle, résolvez le problème d’équilibrage. Découvrez-en plus sur les données déséquilibrées.

Des classes déséquilibrées ont été détectées dans vos entrées et la logique de balayage a déterminé d’appliquer l’équilibrage.
Détection des problèmes de mémoire Passé



Terminé		 Aucun problème potentiel d’insuffisance de mémoire n’a été détecté après analyse des valeurs {horizon, décalage, fenêtre dynamique} sélectionnées. Découvrez-en plus sur les configurations de prévision de série chronologique.

Les valeurs {horizon, décalage, fenêtre dynamique} sélectionnées ont été analysées et peuvent entraîner une insuffisance de mémoire dans votre expérience. Les configurations de la fenêtre dynamique ou de décalage sont désactivées.
Détection de la fréquence Passé


Terminé		 La série chronologique a été analysée et tous les points de données sont alignés sur la fréquence détectée.

La série chronologique a été analysée et les points de données qui ne sont pas alignés sur la fréquence détectée ont été détectés. Ces points de données ont été supprimés du jeu de données.
Validation croisée Terminé Pour évaluer avec précision le modèle entraîné par AutoML, nous utilisons un jeu de données sur lequel le modèle n’est pas entraîné. Par conséquent, si l'utilisateur ne fournit pas d'ensemble de données de validation explicite, une partie de l'ensemble de données de formation est utilisée pour y parvenir. Pour les ensembles de données plus petits (moins de 20 000 échantillons), la validation croisée est utilisée, sinon un seul ensemble de réserve est séparé des données de formation pour servir d'ensemble de données de validation. Par conséquent, pour vos données d'entrée, nous utilisons une validation croisée avec 10 plis, si le nombre d'échantillons de formation est inférieur à 1000, et 3 plis dans tous les autres cas.
Fractionnement des données de test d’apprentissage Terminé Pour évaluer avec précision le modèle entraîné par AutoML, nous utilisons un jeu de données sur lequel le modèle n’est pas entraîné. Par conséquent, si l'utilisateur ne fournit pas d'ensemble de données de validation explicite, une partie de l'ensemble de données de formation est utilisée pour y parvenir. Pour les ensembles de données plus petits (moins de 20 000 échantillons), la validation croisée est utilisée, sinon un seul ensemble de réserve est séparé des données de formation pour servir d'ensemble de données de validation. Par conséquent, vos données d’entrée sont divisées en un ensemble de données de formation et un ensemble de données de validation de maintien.
Détection d’ID de série chronologique Passé


Résolution		 Le jeu de données a été analysé et aucun index de temps en double n’a été détecté.

Plusieurs séries chronologiques ont été trouvées dans le jeu de données et les identificateurs de série chronologique ont été créés automatiquement pour votre jeu de données.
Agrégation de séries chronologiques Passé


Résolution		 La fréquence du jeu de données est alignée avec la fréquence spécifiée par l’utilisateur. Aucune agrégation n’a été effectuée.

Les données ont été agrégées pour se conformer à la fréquence fournie par l’utilisateur.
Gestion des séries courtes Passé


Résolution		 AutoML a détecté suffisamment de points de données pour chaque série dans les données d’entrée pour poursuivre l’entraînement.

AutoML a détecté que certaines séries ne contenaient pas suffisamment de points de données pour entraîner un modèle. Pour poursuivre la formation, ces courtes séries ont été abandonnées ou rembourrées.

Personnaliser la caractérisation

Vous pouvez personnaliser vos paramètres de caractérisation pour vous assurer que les données et fonctionnalités utilisées pour entraîner votre modèle Machine Learning entraînent des prédictions pertinentes.

Pour personnaliser les fonctionnalités, spécifiez "featurization": FeaturizationConfig dans votre objet AutoMLConfig. Si vous utilisez Azure Machine Learning Studio pour votre expérience, consultez les paramètres de configuration de caractérisation. Pour personnaliser la caractérisation pour les types de tâches de prévision, reportez-vous à la fonctionnalité Personnaliser la caractérisation.

Les personnalisations prises en charge sont notamment les suivantes :

Personnalisation Définition
Mise à jour de l’objectif de la colonne Remplacer le type de caractéristique détecté automatiquement pour la colonne spécifiée.
Mise à jour des paramètres du transformateur Mettre à jour les paramètres du transformateur spécifié. Prend actuellement en charge Imputer (moyen, le plus fréquent et médian) et HashOneHotEncoder.
Supprimer des colonnes* Indique les colonnes à supprimer de la caractérisation.
Transformateurs de blocs Indique les transformateurs de blocs à utiliser dans le processus de caractérisation.

Remarque

*La fonctionnalité de suppression des colonnes est déconseillée depuis la version 1.19 du Kit de développement logiciel (SDK). Supprimez les colonnes de votre jeu de données dans le cadre du nettoyage des données, avant de l’utiliser dans votre expérience AutoML.

Vous pouvez créer l’objet à l’aide d’appels d’API FeaturizationConfig :

featurization_config = FeaturizationConfig()
featurization_config.blocked_transformers = ['LabelEncoder']
featurization_config.drop_columns = ['aspiration', 'stroke']
featurization_config.add_column_purpose('engine-size', 'Numeric')
featurization_config.add_column_purpose('body-style', 'CategoricalHash')
#default strategy mean, add transformer param for 3 columns
featurization_config.add_transformer_params('Imputer', ['engine-size'], {"strategy": "median"})
featurization_config.add_transformer_params('Imputer', ['city-mpg'], {"strategy": "median"})
featurization_config.add_transformer_params('Imputer', ['bore'], {"strategy": "most_frequent"})
featurization_config.add_transformer_params('HashOneHotEncoder', [], {"number_of_bits": 3})

Transparence de la caractérisation

La caractérisation est appliquée automatiquement à chaque modèle AutoML. La caractérisation comprend une ingénierie de caractéristiques automatisée (quand "featurization": 'auto') et une fonction de mise à l’échelle et de normalisation, qui ont un impact sur l’algorithme sélectionné et ses valeurs d’hyperparamètres. AutoML prend en charge différentes méthodes pour garantir la visibilité de ce qui a été appliqué à votre modèle.

Prenons l’exemple suivant :

  • Il existe quatre fonctionnalités d’entrée : A (numérique), B (numérique), C (numérique), D (DateTime).
  • La fonctionnalité numérique C est supprimée car il s'agit d'une colonne d'ID avec toutes les valeurs uniques.
  • Il manque des valeurs dans les caractéristiques numériques A et B : une moyenne leur est donc affectée.
  • La fonctionnalité DateTime D a 11 fonctionnalités d’ingénierie différentes.

Pour obtenir ces informations, utilisez la fitted_model sortie de votre exécution d’expérience AutoML.

automl_config = AutoMLConfig(…)
automl_run = experiment.submit(automl_config …)
best_run, fitted_model = automl_run.get_output()

Ingénierie des fonctionnalités automatisées

Le get_engineered_feature_names() renvoie une liste de noms de fonctionnalités conçues.

Remarque

Utiliser 'timeseriestransformer' pour task='forecasting', sinon utiliser 'datatransformer' pour 'regression' ou 'classification' tâche.

fitted_model.named_steps['timeseriestransformer']. get_engineered_feature_names ()

Cette liste inclut tous les noms des fonctionnalités d’ingénierie.

['A', 'B', 'A_WASNULL', 'B_WASNULL', 'year', 'half', 'quarter', 'month', 'day', 'hour', 'am_pm', 'hour12', 'wday', 'qday', 'week']

get_featurization_summary() obtient un résumé de caractérisation de toutes les fonctionnalités d’entrée.

fitted_model.named_steps['timeseriestransformer'].get_featurization_summary()

Sortie

[{'RawFeatureName': 'A',
  'TypeDetected': 'Numeric',
  'Dropped': 'No',
  'EngineeredFeatureCount': 2,
  'Tranformations': ['MeanImputer', 'ImputationMarker']},
 {'RawFeatureName': 'B',
  'TypeDetected': 'Numeric',
  'Dropped': 'No',
  'EngineeredFeatureCount': 2,
  'Tranformations': ['MeanImputer', 'ImputationMarker']},
 {'RawFeatureName': 'C',
  'TypeDetected': 'Numeric',
  'Dropped': 'Yes',
  'EngineeredFeatureCount': 0,
  'Tranformations': []},
 {'RawFeatureName': 'D',
  'TypeDetected': 'DateTime',
  'Dropped': 'No',
  'EngineeredFeatureCount': 11,
  'Tranformations': ['DateTime','DateTime','DateTime','DateTime','DateTime','DateTime','DateTime','DateTime',ateTime','DateTime','DateTime']}]
Sortie Définition
RawFeatureName Fonctionnalité/colonne d’entrée du jeu de données fournis.
TypeDetected Type de données détecté de la fonctionnalité d’entrée.
Supprimé Indique si la fonctionnalité d’entrée a été supprimée ou utilisée.
EngineeringFeatureCount Nombre de fonctionnalités générées par le biais de transformations d’ingénierie de la fonctionnalité automatisée.
Transformations Liste des transformations appliquées à des fonctionnalités d’entrée pour générer des fonctionnalités d’ingénierie.

Mise à l’échelle et normalisation

Pour comprendre la mise à l’échelle/la normalisation et l’algorithme sélectionné avec ses valeurs d’hyperparamètre, utilisez fitted_model.steps.

L’exemple de sortie suivant est l’exécution de fitted_model.steps pour une série choisie :

[('RobustScaler', 
  RobustScaler(copy=True, 
  quantile_range=[10, 90], 
  with_centering=True, 
  with_scaling=True)), 

  ('LogisticRegression', 
  LogisticRegression(C=0.18420699693267145, class_weight='balanced', 
  dual=False, 
  fit_intercept=True, 
  intercept_scaling=1, 
  max_iter=100, 
  multi_class='multinomial', 
  n_jobs=1, penalty='l2', 
  random_state=None, 
  solver='newton-cg', 
  tol=0.0001, 
  verbose=0, 
  warm_start=False))]

Pour obtenir plus de détails, utilisez cette fonction d’assistance :

from pprint import pprint

def print_model(model, prefix=""):
    for step in model.steps:
        print(prefix + step[0])
        if hasattr(step[1], 'estimators') and hasattr(step[1], 'weights'):
            pprint({'estimators': list(e[0] for e in step[1].estimators), 'weights': step[1].weights})
            print()
            for estimator in step[1].estimators:
                print_model(estimator[1], estimator[0]+ ' - ')
        elif hasattr(step[1], '_base_learners') and hasattr(step[1], '_meta_learner'):
            print("\nMeta Learner")
            pprint(step[1]._meta_learner)
            print()
            for estimator in step[1]._base_learners:
                print_model(estimator[1], estimator[0]+ ' - ')
        else:
            pprint(step[1].get_params())
            print()

Cette fonction d’assistance retourne la sortie suivante pour une exécution particulière à l’aide de LogisticRegression with RobustScalar en tant qu’algorithme spécifique.

RobustScaler
{'copy': True,
'quantile_range': [10, 90],
'with_centering': True,
'with_scaling': True}

LogisticRegression
{'C': 0.18420699693267145,
'class_weight': 'balanced',
'dual': False,
'fit_intercept': True,
'intercept_scaling': 1,
'max_iter': 100,
'multi_class': 'multinomial',
'n_jobs': 1,
'penalty': 'l2',
'random_state': None,
'solver': 'newton-cg',
'tol': 0.0001,
'verbose': 0,
'warm_start': False}

Prédire une probabilité de classe

Les modèles produits à l’aide d’AutoML ont tous des objets wrapper qui reflètent les fonctionnalités de leur classe d’origine open source. La plupart des objets wrapper de modèle de classification retournés par AutoML implémentent la predict_proba() fonction, qui accepte un exemple de données de matrice de type tableau ou éparse de vos fonctionnalités (valeurs X) et retourne un tableau ndimensionnel de chaque échantillon et sa probabilité de classe respective.

En supposant que vous avez récupéré la meilleure série et le meilleur modèle ajusté en utilisant les mêmes appels, vous pouvez appeler predict_proba() directement à partir du modèle ajusté, en fournissant un échantillon de X_test au format approprié par rapport au type de modèle.

best_run, fitted_model = automl_run.get_output()
class_prob = fitted_model.predict_proba(X_test)

Si le modèle sous-jacent ne prend pas en charge la fonction predict_proba() ou si le format est incorrect, une exception spécifique à la classe de modèle est levée. Consultez les documents de référence RandomForestClassifier et XGBoost pour obtenir des exemples de la manière dont cette fonction est implémentée pour différents types de modèles.

Intégration de BERT dans AutoML

Les représentations de l’encodeur bidirectionnel de Transformateurs (BERT) sont utilisées dans la couche de caractérisation d’AutoML. Dans cette couche, si une colonne contient du texte libre ou d’autres types de données tels que des horodateurs ou des nombres simples, nous les caractérisons en conséquence.

Pour BERT, le modèle est affiné et entraîné en utilisant les étiquettes fournies par l’utilisateur. À partir de là, les incorporations de documents sont générées en tant que fonctionnalités en aux côtés d’autres, comme les fonctionnalités de timestamp, de jour de la semaine.

Découvrez comment Configurer AutoML pour former un modèle de traitement du langage naturel avec Python.

Étapes à suivre pour appeler BERT

Pour invoquer BERT, définissez enable_dnn: True dans votre automl_settings et utilisez un calcul GPU (vm_size = "STANDARD_NC6" ou un GPU de performance supérieure). Si un calcul CPU est utilisé, alors au lieu de BERT, AutoML active le featureizer BiLSTM DNN.

AutoML effectue les étapes suivantes pour BERT.

  1. Prétraitez et tokenisez toutes les colonnes de texte. Par exemple, le transformateur StringCast se trouve dans le récapitulatif de caractérisation du modèle final. Un exemple de comment produire le sommaire de caractérisation du modèle peut être trouvé dans ce notebook Jupyter.

  2. Concatène toutes les colonnes de texte en une seule colonne de texte, par conséquent StringConcatTransformer dans le modèle final.

    Notre implémentation de BERT limite la longueur totale du texte d’un exemple de formation à 128 jetons. Cela signifie qu’en cas de concaténation, toutes les colonnes de texte doivent idéalement avoir une longueur maximale de 128 jetons. S’il y a plusieurs colonnes, chaque colonne doit être élaguée de telle sorte que cette condition soit remplie. Sinon, pour les colonnes concaténées de longueur > 128 jetons, la couche du générateur de jetons de BERT va tronquer cette entrée à 128 jetons.

  3. Dans le cadre du balayage de fonctionnalité, AutoML compare BERT avec la ligne de base (conteneur de fonctionnalités de mots) sur un échantillon de données. Cette comparaison détermine si BERT donne des améliorations de précision. Si BERT s’exécute mieux que la ligne de base, AutoML utilise BERT pour la caractérisation de texte pour l’ensemble des données. Dans ce cas, vous voyez le PretrainedTextDNNTransformer dans le modèle final.

BERT dure généralement plus longtemps que les autres featureurs. Pour de meilleures performances, nous vous conseillons d’utiliser STANDARD_NC24r ou STANDARD_NC24rs_V3 pour leurs capacités RDMA.

AutoML distribue la formation BERT sur plusieurs nœuds s'ils sont disponibles (jusqu'à un maximum de huit nœuds). Cela peut être fait dans votre objet AutoMLConfig en définissant le paramètre max_concurrent_iterations sur une valeur supérieure à 1.

Langues prises en charge pour BERT

AutoML prend actuellement en charge environ 100 langues. En fonction du langage du jeu de données, AutoML choisit le modèle BERT approprié. Pour les données en allemand, nous utilisons le modèle BERT allemand. Pour l’anglais, nous utilisons le modèle BERT anglais. Pour toutes les autres langues, nous utilisons le modèle BERT multilingue.

Dans le code suivant, le modèle BERT allemand est déclenché, car la langue du jeu de données est spécifiée à deu, le code de langue à trois lettres pour l’allemand en fonction de la classification ISO :

from azureml.automl.core.featurization import FeaturizationConfig

featurization_config = FeaturizationConfig(dataset_language='deu')

automl_settings = {
    "experiment_timeout_minutes": 120,
    "primary_metric": 'accuracy',
# All other settings you want to use
    "featurization": featurization_config,
    
    "enable_dnn": True, # This enables BERT DNN featurizer
    "enable_voting_ensemble": False,
    "enable_stack_ensemble": False
}

Contenu connexe