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

S’APPLIQUE À : SDK Python azureml v1

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 caractéristiques (construites) qui fournissent des informations permettant de mieux différencier les modèles dans les données. Ce processus est appelé ingénierie de caractéristiques et décrit l’utilisation de la connaissance du domaine des données pour créer des caractéristiques qui, à leur tour, aident les algorithmes de Machine Learning à améliorer l’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. Ces techniques et l’ingénierie de caractéristiques sont appelées collectivement caractérisation dans les expériences de Machine Learning (ML) automatisé.

Prérequis

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

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

• Pour une expérience code-first : configurer l’entraînement AutoML avec Python
• Pour une expérience sans code : configurer un entraînement AutoML sans code pour des données tabulaires avec l’interface utilisateur du studio

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.

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 :

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.

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.

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 SDK : quand les paramètres "featurization": 'auto' ou validation=auto sont spécifiés dans votre objet AutoMLConfig
• Pour les expériences du studio : quand la 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 :

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 :

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 :

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 caractéristique 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.

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',ateTime','DateTime','DateTime']}]

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é 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 propre à 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 AutoML pour entraîner un modèle de traitement du langage naturel avec Python.

É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écapitulatif 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 voyez 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 distribue 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
}

Contenu connexe

• Déployer des modèles Machine Learning sur Azure
• Entraîner un modèle de régression avec AutoML et Python