Transfert d'apprentissage pour les modèles de classification de texte TensorFlow dans Amazon SageMaker

Amazon Sage Maker offre une suite de algorithmes intégrés, modèles pré-entraînéset une modèles de solutions prédéfinis pour aider les scientifiques des données et les praticiens de l'apprentissage automatique (ML) à commencer à former et à déployer rapidement des modèles ML. Vous pouvez utiliser ces algorithmes et modèles pour l'apprentissage supervisé et non supervisé. Ils peuvent traiter différents types de données d'entrée, notamment des tableaux, des images et du texte.

Cet article est le troisième d'une série sur les nouveaux algorithmes intégrés dans SageMaker. Dans le premier message, nous avons montré comment SageMaker fournit un algorithme intégré pour la classification des images. Dans le deuxième message, nous avons montré comment SageMaker fournit un algorithme intégré pour la détection d'objets. Aujourd'hui, nous annonçons que SageMaker fournit un nouvel algorithme intégré pour la classification de texte à l'aide de TensorFlow. Cet algorithme d'apprentissage supervisé prend en charge l'apprentissage par transfert pour de nombreux modèles pré-formés disponibles dans Hub TensorFlow. Il prend un morceau de texte en entrée et génère la probabilité pour chacune des étiquettes de classe. Vous pouvez affiner ces modèles pré-formés à l'aide de l'apprentissage par transfert même lorsqu'un grand corpus de texte n'est pas disponible. Il est disponible via le SageMaker algorithmes intégrés, ainsi qu'à travers le Interface utilisateur JumpStart de SageMaker in Amazon SageMakerStudio. Pour plus d'informations, reportez-vous à Classification du texte et l'exemple de cahier Introduction à JumpStart – Classification de texte.

La classification de texte avec TensorFlow dans SageMaker fournit un apprentissage par transfert sur de nombreux modèles pré-formés disponibles dans le hub TensorFlow. En fonction du nombre d'étiquettes de classe dans les données d'entraînement, une couche de classification est associée au modèle de hub TensorFlow pré-entraîné. La couche de classification se compose d'une couche d'abandon et d'une couche dense, entièrement connectée, avec un régularisateur à 2 normes, qui est initialisée avec des poids aléatoires. La formation du modèle a des hyper-paramètres pour le taux d'abandon de la couche d'abandon et le facteur de régularisation L2 pour la couche dense. Ensuite, soit l'ensemble du réseau, y compris le modèle pré-entraîné, soit seule la couche de classification supérieure peut être affiné sur les nouvelles données d'apprentissage. Dans ce mode d'apprentissage par transfert, la formation peut être réalisée même avec un ensemble de données plus petit.

Comment utiliser le nouvel algorithme de classification de texte TensorFlow

Cette section décrit comment utiliser l'algorithme de classification de texte TensorFlow avec le Kit de développement logiciel (SDK) SageMaker Python. Pour plus d'informations sur son utilisation à partir de l'interface utilisateur de Studio, consultez SageMaker JumpStart.

L'algorithme prend en charge l'apprentissage par transfert pour les modèles pré-formés répertoriés dans Modèles Tensorflow. Chaque modèle est identifié par un identifiant unique model_id. Le code suivant montre comment affiner le modèle de base BERT identifié par model_id tensorflow-tc-bert-en-uncased-L-12-H-768-A-12-2 sur un jeu de données d'entraînement personnalisé. Pour chaque model_id, pour lancer une tâche de formation SageMaker via le Estimateur classe du SDK Python SageMaker, vous devez récupérer l'URI de l'image Docker, l'URI du script de formation et l'URI du modèle pré-formé via les fonctions utilitaires fournies dans SageMaker. L'URI du script de formation contient tout le code nécessaire au traitement des données, au chargement du modèle pré-formé, à la formation du modèle et à l'enregistrement du modèle formé pour l'inférence. L'URI du modèle pré-formé contient la définition de l'architecture du modèle pré-formé et les paramètres du modèle. L'URI de modèle pré-formé est spécifique au modèle particulier. Les archives tar du modèle pré-entraîné ont été pré-téléchargées à partir de TensorFlow et enregistrées avec la signature de modèle appropriée dans Service de stockage simple Amazon (Amazon S3), afin que la tâche de formation s'exécute en isolation réseau. Voir le code suivant :

from sagemaker import image_uris, model_uris, script_urisfrom sagemaker.estimator import Estimator

model_id, model_version = "tensorflow-tc-bert-en-uncased-L-12-H-768-A-12-2", "*"
training_instance_type = "ml.p3.2xlarge"
# Retrieve the docker image
train_image_uri = image_uris.retrieve(model_id=model_id,model_version=model_version,image_scope="training",instance_type=training_instance_type,region=None,framework=None)# Retrieve the training script
train_source_uri = script_uris.retrieve(model_id=model_id, model_version=model_version, script_scope="training")# Retrieve the pre-trained model tarball for transfer learning
train_model_uri = model_uris.retrieve(model_id=model_id, model_version=model_version, model_scope="training")

output_bucket = sess.default_bucket()
output_prefix = "jumpstart-example-tensorflow-tc-training"
s3_output_location = f"s3://{output_bucket}/{output_prefix}/output"

Avec ces artefacts de formation spécifiques au modèle, vous pouvez construire un objet du Estimateur classe:

# Create SageMaker Estimator instance
tf_tc_estimator = Estimator(
    role=aws_role,
    image_uri=train_image_uri,
    source_dir=train_source_uri,
    model_uri=train_model_uri,
    entry_point="transfer_learning.py",
    instance_count=1,
    instance_type=training_instance_type,
    max_run=360000,
    hyperparameters=hyperparameters,
    output_path=s3_output_location,)

Ensuite, pour l'apprentissage par transfert sur votre jeu de données personnalisé, vous devrez peut-être modifier les valeurs par défaut des hyperparamètres de formation, qui sont répertoriés dans Hyperparamètres. Vous pouvez récupérer un dictionnaire Python de ces hyperparamètres avec leurs valeurs par défaut en appelant hyperparameters.retrieve_default, mettez-les à jour si nécessaire, puis transmettez-les à la classe Estimator. Notez que les valeurs par défaut de certains des hyperparamètres sont différentes pour différents modèles. Pour les grands modèles, la taille de lot par défaut est plus petite et le train_only_top_layer l'hyperparamètre est défini sur True. L'hyperparamètre Train_only_top_layer définit les paramètres du modèle qui changent pendant le processus de réglage fin. Si train_only_top_layer is True, les paramètres des couches de classification changent et les autres paramètres restent constants pendant le processus de réglage fin. D'autre part, si train_only_top_layer is False, alors tous les paramètres du modèle sont affinés. Voir le code suivant :

from sagemaker import hyperparameters# Retrieve the default hyper-parameters for fine-tuning the model
hyperparameters = hyperparameters.retrieve_default(model_id=model_id, model_version=model_version)# [Optional] Override default hyperparameters with custom values
hyperparameters["epochs"] = "5"

Nous offrons le temps de réponse SST2 comme ensemble de données par défaut pour affiner les modèles. L'ensemble de données contient des critiques de films positives et négatives. Il a été téléchargé depuis TensorFlow sous Licence Apache 2.0. Le code suivant fournit l'ensemble de données d'entraînement par défaut hébergé dans des compartiments S3.

# Sample training data is available in this bucket
training_data_bucket = f"jumpstart-cache-prod-{aws_region}"
training_data_prefix = "training-datasets/SST2/"

training_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}"

Enfin, pour lancer la tâche d'entraînement SageMaker pour affiner le modèle, appelez .fit sur l'objet de la classe Estimator, tout en transmettant l'emplacement Amazon S3 de l'ensemble de données d'entraînement :

# Launch a SageMaker Training job by passing s3 path of the training data
tf_od_estimator.fit({"training": training_dataset_s3_path}, logs=True)

Pour plus d'informations sur l'utilisation du nouvel algorithme de classification de texte SageMaker TensorFlow pour l'apprentissage par transfert sur un jeu de données personnalisé, déployez le modèle affiné, exécutez l'inférence sur le modèle déployé et déployez le modèle pré-formé tel quel sans ajustement préalable sur un ensemble de données personnalisé, consultez l'exemple de bloc-notes suivant : Introduction à JumpStart – Classification de texte.

Interface d'entrée/sortie pour l'algorithme de classification de texte TensorFlow

Vous pouvez affiner chacun des modèles pré-formés répertoriés dans Modèles TensorFlow à n'importe quel ensemble de données composé de phrases de texte avec n'importe quel nombre de classes. Le modèle pré-entraîné attache une couche de classification au modèle d'incorporation de texte et initialise les paramètres de la couche sur des valeurs aléatoires. La dimension de sortie de la couche de classification est déterminée en fonction du nombre de classes détectées dans les données d'entrée. L'objectif est de minimiser les erreurs de classification sur les données d'entrée. Le modèle renvoyé par le réglage fin peut être déployé davantage pour l'inférence.

Les instructions suivantes décrivent comment les données d'apprentissage doivent être formatées pour être entrées dans le modèle :

• Entrée – Un répertoire contenant un fichier data.csv. Chaque ligne de la première colonne doit avoir des étiquettes de classe entières comprises entre 0 et le nombre de classes. Chaque ligne de la deuxième colonne doit contenir les données textuelles correspondantes.
• Sortie - Un modèle affiné qui peut être déployé pour l'inférence ou formé davantage à l'aide d'une formation incrémentielle. Un fichier de mappage des index de classe aux étiquettes de classe est enregistré avec les modèles.

Voici un exemple de fichier CSV d'entrée. Notez que le fichier ne doit pas avoir d'en-tête. Le fichier doit être hébergé dans un compartiment S3 avec un chemin semblable au suivant : s3://bucket_name/input_directory/. Notez que la fin / est nécessaire.

|0 |hide new secretions from the parental units|
|0 |contains no wit , only labored gags|
|1 |that loves its characters and communicates something rather beautiful about human nature|
|...|...|

Inférence avec l'algorithme de classification de texte TensorFlow

Les modèles générés peuvent être hébergés pour l'inférence et le texte de support en tant que application/x-text type de contenu. La sortie contient les valeurs de probabilité, les étiquettes de classe pour toutes les classes et l'étiquette prédite correspondant à l'index de classe avec la probabilité la plus élevée encodée au format JSON. Le modèle traite une seule chaîne par requête et ne génère qu'une seule ligne. Voici un exemple de réponse au format JSON :

accept: application/json;verbose
{"probabilities": [prob_0, prob_1, prob_2, ...],
 "labels": [label_0, label_1, label_2, ...],
 "predicted_label": predicted_label}

If accept est fixé à application/json, alors le modèle ne produit que des probabilités. Pour plus de détails sur la formation et l'inférence, consultez l'exemple de bloc-notes Introduction à Introduction à JumpStart – Classification de texte.

Utiliser les algorithmes intégrés de SageMaker via l'interface utilisateur JumpStart

Vous pouvez également utiliser la classification de texte SageMaker TensorFlow et l'un des autres algorithmes intégrés en quelques clics via l'interface utilisateur JumpStart. JumpStart est une fonctionnalité SageMaker qui vous permet de former et de déployer des algorithmes intégrés et des modèles pré-formés à partir de divers frameworks ML et hubs de modèles via une interface graphique. De plus, il vous permet de déployer des solutions ML complètes qui associent des modèles ML et divers autres services AWS pour résoudre un cas d'utilisation ciblé.

Voici deux vidéos qui montrent comment vous pouvez reproduire le même processus de réglage fin et de déploiement que nous venons de suivre en quelques clics via l'interface utilisateur JumpStart.

Affiner le modèle pré-entraîné

Voici le processus pour affiner le même modèle de classification de texte pré-formé.

Déployer le modèle affiné

Une fois la formation du modèle terminée, vous pouvez déployer directement le modèle sur un point de terminaison persistant en temps réel en un seul clic.

Conclusion

Dans cet article, nous avons annoncé le lancement de l'algorithme intégré de classification de texte SageMaker TensorFlow. Nous avons fourni un exemple de code expliquant comment effectuer l'apprentissage par transfert sur un ensemble de données personnalisé à l'aide d'un modèle pré-formé du hub TensorFlow à l'aide de cet algorithme.

Pour plus d'informations, consultez le Documentation et l'exemple de cahier Introduction à JumpStart – Classification de texte.

À propos des auteurs

Dr Vivek Madan est un scientifique appliqué avec le Équipe Amazon SageMaker JumpStart. Il a obtenu son doctorat de l'Université de l'Illinois à Urbana-Champaign et a été chercheur postdoctoral à Georgia Tech. Il est un chercheur actif en apprentissage automatique et en conception d'algorithmes et a publié des articles dans les conférences EMNLP, ICLR, COLT, FOCS et SODA.

Joao Moura est architecte de solutions spécialisées en IA/ML chez Amazon Web Services. Il se concentre principalement sur les cas d'utilisation du NLP et aide les clients à optimiser la formation et le déploiement de modèles d'apprentissage en profondeur. Il est également un partisan actif des solutions ML low-code et du matériel spécialisé ML.

Dr Ashish Khetan est un scientifique appliqué senior avec Algorithmes intégrés d'Amazon SageMaker et aide à développer des algorithmes d'apprentissage automatique. Il a obtenu son doctorat à l'Université de l'Illinois Urbana Champaign. Il est un chercheur actif en apprentissage automatique et en inférence statistique et a publié de nombreux articles dans les conférences NeurIPS, ICML, ICLR, JMLR, ACL et EMNLP.