Caractérisation de données dans le Machine Learning automatisé

  • Article

S’APPLIQUE À :Kit de développement logiciel (SDK) Python azureml v1

En savoir plus sur les paramètres de caractérisation de données dans Azure Machine Learning et sur la façon de personnaliser ces fonctionnalités pour les expériences Machine Learning automatisé.

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.

Même si la plupart des champs de données brutes peuvent être utilisés directement pour entraîner un modèle, il est souvent nécessaire de créer des caractéristiques supplémentaires (traitées) qui fournissent des informations qui différencient mieux les modèles dans les données. Ce processus est appelé ingénierie des caractéristiques. Dans ce processus, l’utilisation de la connaissance du domaine des données est exploitée pour créer des fonctionnalités qui, à leur tour, aident les algorithmes de Machine Learning à améliorer leur apprentissage.

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. Généralement, ces techniques et l’ingénierie de caractéristiques sont appelées caractérisation dans les expériences de Machine Learning automatisé.

Prérequis

Cet article part du principe que vous savez déjà comment configurer une expérience de Machine Learning automatisé.

Important

Les commandes python de cet article requièrent la dernière azureml-train-automl version du package.

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

Configuration de la caractérisation

Dans chaque expérience de Machine Learning automatisée, des techniques de mise à l’échelle automatique et de normalisation sont appliquées par défaut à vos données. 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 caractérisation, par exemple d’imputation des valeurs manquantes, d’encodage et de transformations.

Notes

Les étapes de caractérisation du Machine Learning automatisé (normalisation des fonctionnalités, gestion des données manquantes, conversion de texte en valeurs numériques) 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 Description
"featurization": 'auto' Indique que, dans le cadre du prétraitement, des étapes de garde-fous des données et de caractérisation doivent être effectuées automatiquement. Il s’agit du paramètre par défaut.
"featurization": 'off' Indique que des é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. Découvrez comment 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.

Notes

Si vous envisagez d’exporter vos modèles créés par ML automatisé vers un modèle ONNX, seules les options de caractérisation marquées d’un astérisque (*) sont prises en charge dans le format ONNX. Apprenez-en davantage sur la conversion de modèles au format ONNX.

Étapes de caractérisation Description
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, les codes de hachage, les ID, ou les 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 caractéristiques de type date/heure : Année, Mois, Jour, Jour de la semaine, Jour de l’année, Trimestre, Semaine de l’année, Heure, Minute, Seconde.

Pour les tâches de prévision, ces caractéristiques DateHeure supplémentaires sont créées : Année ISO, Semestre - semestre, Mois civil comme chaîne, Semaine, Jour de la semaine comme chaîne, Jour du trimestre, Jour de l’année, AM/PM (0 si l’heure se situe avant midi (12 pm), sinon 1), AM/PM comme chaîne, Heure de la journée (base de 12 heures)

Pour les caractéristiques de type texte : Fréquence des termes basée sur les unigrammes, les bigrammes et les trigrammes. En savoir plus sur comment cela se passe avec 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 fonctionnalités catégoriques de haute cardinalité.
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 de cluster Effectue l’apprentissage d’un modèle de clustering k-moyennes sur toutes les colonnes numériques. Génère de nouvelles fonctionnalités k, une nouvelle fonctionnalité numérique par cluster, contenant la distance de chaque échantillon par rapport au centroïde de chaque cluster.

Dans chaque expérience de Machine Learning automatisé, vos données sont automatiquement mises à l’échelle et normalisées pour faciliter la bonne exécution des algorithmes. Pendant l’entraînement des modèles, l’une des techniques suivantes de mise à l’échelle ou de normalisation est appliquée à chaque modèle.

Mise à l’échelle et traitement Description
StandardScaleWrapper Normaliser les fonctionnalités en supprimant la moyenne et en mettant à l’échelle de l’écart d’unité.
MinMaxScalar Transformer les fonctionnalités en les mettant à l’échelle des valeurs minimale et maximale de cette colonne.
MaxAbsScaler Mettre à l’échelle chaque fonctionnalité en fonction de sa valeur absolue maximale.
RobustScalar Mettre à l’échelle les fonctionnalités par plage de quantiles
PCA Réduction de dimensionnalité linéaire à l’aide d’une décomposition de valeur singulière des données afin de les projeter vers un espace dimensionnel inférieur.
TruncatedSVDWrapper Ce transformateur effectue une réduction de dimensionnalité linéaire au moyen d’une décomposition de valeur singulière 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 travailler efficacement avec des matrices scipy.sparse.
SparseNormalizer 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 des données vous aident à identifier les problèmes potentiels liés à vos données (par exemple, valeurs manquantes ou déséquilibre de classe). 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 objet AutoMLConfig.
  • Pour les expériences de studio: Quand l’option Caractérisation automatique 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 des données de votre exécution de ML automatisé.

États des Garde-fous des données

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

State Description
Passed Aucun problème de données n’a été détecté et aucune action n’est requise de votre part.
Done 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.
Alerted 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 Réussite


Terminé		 Aucune valeur de caractéristique manquante n’a été détectée dans vos données d’entraînement. Découvrez plus d’informations sur l’imputation d’une valeur manquante.

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 Réussite


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 jeu de données d’entraînement et un jeu de données de validation pour la validation du modèle.
Détection de l’équilibrage des classes Réussite



Alerté


Terminé		 Vos entrées ont été analysées et toutes les classes sont équilibrées dans vos données d’entraînement. 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 Réussite



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 ont été désactivées.
Détection de la fréquence Réussite



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 ou les modèles entraînés par AutoML, nous exploitons un jeu de données sur lequel le modèle n’est pas entraîné. Par conséquent, si l’utilisateur ne fournit pas de jeu de données de validation explicite, une partie du jeu de données d’apprentissage est utilisée pour y parvenir. Pour les jeux de données plus petits (moins de 20 000 exemples), la validation croisée est utilisée, sinon un ensemble de stockage unique est fractionné à partir des données d’entraînement pour servir de jeu de données de validation. Par conséquent, pour vos données d’entrée, nous exploitons la validation croisée avec 10 plis, si le nombre d’exemples d’entraînement est inférieur à 1 000 et 3 plis dans tous les autres cas.
Fractionnement des données de test d’apprentissage Terminé Pour évaluer avec précision le ou les modèles entraînés par AutoML, nous exploitons un jeu de données sur lequel le modèle n’est pas entraîné. Par conséquent, si l’utilisateur ne fournit pas de jeu de données de validation explicite, une partie du jeu de données d’apprentissage est utilisée pour y parvenir. Pour les jeux de données plus petits (moins de 20 000 exemples), la validation croisée est utilisée, sinon un ensemble de stockage unique est fractionné à partir des données d’entraînement pour servir de jeu de données de validation. Par conséquent, vos données d’entrée ont été fractionnées en un jeu de données d’entraînement et un jeu de données de validation des données d'exclusion.
Détection de l'identité des séries chronologiques Réussite



Fixe
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 Réussite



Fixe
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 Réussite



Fixe
Le ML automatisé a détecté un nombre suffisant de points de données pour chaque série dans les données d'entrée pour continuer l'entraînement.

Le ML automatisé a détecté que certaines séries ne contenaient pas suffisamment de points de données pour entraîner un modèle. Pour poursuivre l’entraînement, ces courtes séries ont été supprimées ou remplies.

Personnaliser la caractérisation

Vous pouvez personnaliser vos paramètres de caractérisation pour vous assurer que les données et les caractéristiques utilisées pour l’apprentissage de votre modèle ML génèrent des prédictions pertinentes.

Pour personnaliser les caractérisations, spécifiez "featurization": FeaturizationConfig dans votre objet AutoMLConfig. Si vous utilisez le studio Azure Machine Learning pour votre expérience, consultez le guide pratique. Pour personnaliser la caractérisation des types de tâches de prévision, reportez-vous à la manière d’effectuer les prévisions.

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.
Suppression de colonnes Indique les colonnes à supprimer de la caractérisation.
Transformateurs de blocs Indique les transformateurs de blocs à utiliser dans le processus de caractérisation.

Notes

La fonctionnalité de suppression de colonnes est déconseillée depuis la version 1.19 du kit de développement logiciel (SDK). Supprimez des colonnes de votre jeu de données dans le cadre du nettoyage des données, avant de les consommer dans votre expérience de ML automatisé.

Créez l’objet FeaturizationConfig à l’aide d’appels d’API :

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 accéder à ces informations, utilisez la sortie fitted_model de votre exécution d’expérience de ML automatisé.

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

Ingénierie des fonctionnalités automatisées

get_engineered_feature_names() retourne une liste de noms de fonctionnalités d’ingénierie.

Notes

Utilisez 'timeseriestransformer' pour task='forecasting', sinon utilisez 'datatransformer' pour la tâche 'regression' ou 'classification'.

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

Output

[{'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','DateTime','DateTime','DateTime']}]
Output 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/ma normalisation et l’algorithme sélectionné avec ses valeurs d’hyperparamètres, 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 de Machine Learning automatisé ont tous des objets wrapper qui reflètent la fonctionnalité de leur classe d’origine open source. La plupart des objets wrapper de modèle de classification retournés par le Machine Learning automatisé implémentent la fonction predict_proba() qui accepte un échantillon de données de matrice avec pointillés ou de type tableau de vos fonctionnalités (valeurs X) et retourne un tableau à n dimensions de chaque échantillon et sa probabilité de classe respective.

En supposant que vous avez récupéré le meilleur modèle exécuté et ajusté en utilisant les appels ci-dessus, vous pouvez appeler predict_proba() directement à partir du modèle ajusté, en fournissant un exemple de X_test au format approprié en fonction du 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 de la classe de modèle est levée. Pour obtenir des exemples de la manière dont cette fonction est implémentée pour différents types de modèles, consultez les documents de référence RandomForestClassifier et XGBoost.

Intégration de BERT dans les ML automatisés

BERT est utilisé dans la couche de caractérisation de ML automatisé. 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 formé à l’aide des é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 des expériences de traitement en langage naturel (NLP) qui utilisent également BERT avec le ML automatisé.

Étapes à suivre pour appeler BERT

Pour appeler BERT, définissez enable_dnn: True dans automl_settings et utiliser un calcul GPU (vm_size = "STANDARD_NC6" ou un GPU supérieur). Si un calcul de l’UC est utilisé, au lieu de BERT, AutoML active le caractériseur BiLSTM DNN.

Le ML automatisé procède comme suit pour BERT.

  1. Prétraitement et création de jetons pour toutes les colonnes de texte. Par exemple, le transformateur « StringCast » se trouve dans le résumé de caractérisation du modèle final. Vous trouverez un exemple de la façon de générer le résumé de caractérisation du modèle dans ce notebook.

  2. Concaténez toutes les colonnes de texte en une seule colonne de texte, d’où le 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 verrez le PretrainedTextDNNTransformer dans le modèle final.

BERT s’exécute généralement plus longtemps que les autres caractériseurs. Pour de meilleures performances, nous vous conseillons d’utiliser « STANDARD_NC24r » ou « STANDARD_NC24rs_V3 » pour leurs capacités RDMA.

AutoML distribuera l’entraînement BERT sur plusieurs nœuds s’ils sont disponibles (avec un maximum de huit nœuds). Pour ce faire, vous pouvez définir le paramètre max_concurrent_iterations sur une valeur supérieure à 1 dans votre objet AutoMLConfig.

Langues prises en charge pour BERT dans AutoML

AutoML prend actuellement en charge environ 100 langues et choisit le modèle BERT approprié en fonction de la langue du jeu de données. 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é, étant donné que la langue du jeu de données est définie sur deu le code de langue à trois lettres pour l’allemand conformément à 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
}

Étapes suivantes