Formation incrémentielle avec Amazon SageMaker JumpStart

Republié par Platon

Suiveurs: 0

En décembre 2020, AWS a annoncé la disponibilité générale d'Amazon SageMaker JumpStart, une capacité de Amazon Sage Maker qui vous aide à démarrer rapidement et facilement avec l'apprentissage automatique (ML). SageMaker JumpStart fournit un réglage fin et un déploiement en un clic d'une grande variété de modèles pré-formés pour les tâches ML courantes, ainsi qu'une sélection de solutions de bout en bout qui résolvent les problèmes commerciaux courants. Ces fonctionnalités simplifient chaque étape du processus de ML, ce qui facilite le développement de modèles de haute qualité et réduit le temps de déploiement.

Tout le contenu JumpStart n'était auparavant disponible que via Amazon SageMakerStudio, qui fournit un interface graphique conviviale pour interagir avec la fonctionnalité. Récemment, nous avons également a annoncé le lancement d'utilisation facile API JumpStart en tant qu'extension du SDK Python SageMaker, vous permettant de déployer et d'affiner par programme une vaste sélection de modèles pré-formés pris en charge par JumpStart sur vos propres ensembles de données. Ce lancement déverrouille l'utilisation des fonctionnalités JumpStart dans vos workflows de code, vos pipelines MLOps et partout où vous interagissez avec SageMaker via le SDK.

Dans cet article, nous sommes ravis d'annoncer que tous les modèles JumpStart pouvant être formés prennent désormais en charge la formation incrémentielle. La formation incrémentielle vous permet de former un modèle que vous avez déjà affiné à l'aide d'un jeu de données étendu qui contient un modèle sous-jacent non pris en compte dans les exécutions de réglage fin précédentes, ce qui a entraîné de mauvaises performances du modèle. La formation incrémentielle permet d'économiser du temps et des ressources car vous n'avez pas besoin de recycler le modèle à partir de zéro. Si vous souhaitez accéder directement au code de l'API JumpStart que nous expliquons dans cet article, vous pouvez vous référer au exemple de cahier.

Présentation de JumpStart

JumpStart est un produit à multiples facettes qui comprend différentes fonctionnalités pour vous aider à démarrer rapidement avec ML sur SageMaker. Au moment de la rédaction, JumpStart vous permet d'effectuer les opérations suivantes :

Déployer des modèles pré-formés pour les tâches ML courantes – JumpStart vous permet de traiter des tâches ML courantes sans effort de développement en fournissant un déploiement facile de modèles pré-formés sur de grands ensembles de données accessibles au public. La communauté des chercheurs en ML a déployé des efforts considérables pour rendre la majorité des modèles récemment développés accessibles au public ; JumpStart héberge une collection de plus de 300 modèles, couvrant les 15 tâches ML les plus populaires telles que la détection d'objets, la classification de texte et la génération de texte, ce qui facilite leur utilisation par les débutants. Ces modèles sont tirés de hubs de modèles populaires, tels que TensorFlow, PyTorch, Hugging Face et MXNet Hub.
Affiner les modèles pré-formés – JumpStart vous permet d'affiner les modèles pré-formés sans avoir besoin d'écrire votre propre algorithme de formation. En ML, la capacité de transférer les connaissances apprises dans un domaine à un autre est appelée transférer l'apprentissage. Vous pouvez utiliser l'apprentissage par transfert pour produire des modèles précis sur vos ensembles de données plus petits, avec des coûts de formation bien inférieurs à ceux impliqués dans la formation du modèle d'origine. JumpStart comprend également des algorithmes de formation populaires basés sur LightGBM, CatBoost, XGBoost et Scikit-learn que vous pouvez former à partir de zéro pour la régression tabulaire et la classification.
Utiliser des solutions prédéfinies – JumpStart fournit un ensemble de 17 solutions pour les cas d'utilisation courants de ML tels que la prévision de la demande et les applications industrielles et financières, que vous pouvez déployer en quelques clics. Les solutions sont des applications ML de bout en bout qui regroupent divers services AWS pour résoudre un cas d'utilisation métier particulier. Ils utilisent AWS CloudFormation modèles et architectures de référence pour un déploiement rapide, ce qui signifie qu'ils sont entièrement personnalisables.
Utiliser des exemples de bloc-notes pour les algorithmes SageMaker – SageMaker fournit une suite d'algorithmes intégrés pour aider les scientifiques des données et les praticiens du ML à se lancer rapidement dans la formation et le déploiement de modèles de ML. JumpStart fournit des exemples de blocs-notes que vous pouvez utiliser pour appliquer rapidement ces algorithmes.
Consultez les vidéos de formation et les blogs – JumpStart propose également de nombreux articles de blog et vidéos qui vous apprennent à utiliser différentes fonctionnalités dans SageMaker.

JumpStart accepte les paramètres VPC personnalisés et Service de gestion des clés AWS (AWS KMS), afin que vous puissiez utiliser les modèles et solutions disponibles en toute sécurité dans votre environnement d'entreprise. Vous pouvez transmettre vos paramètres de sécurité à JumpStart dans Studio ou via le SDK Python SageMaker.

Classification des images

La classification d'image fait référence à la classification d'une image dans l'une des étiquettes de classe de l'ensemble de données d'apprentissage. Vous pouvez ajuster le modèle à n'importe quel jeu de données comprenant des images appartenant à n'importe quel nombre de classes. Le modèle disponible pour un réglage fin sur JumpStart attache une couche de classification au modèle d'extracteur d'entités correspondant 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 dans les données d'entrée. L'étape de réglage fin règle les paramètres de la couche de classification, tout en maintenant les paramètres du modèle d'extracteur de caractéristiques figés, et renvoie le modèle affiné. L'objectif est de minimiser l'erreur de prédiction sur les données d'entrée.

Pour notre jeu de données, l'entrée est un répertoire avec autant de sous-répertoires que le nombre de classes. Chaque sous-répertoire doit contenir des images appartenant à cette classe au format .jpg. Le répertoire d'entrée doit ressembler à la hiérarchie suivante si les données d'entraînement contiennent des images de deux classes : roses ainsi que dandelion:

input_directory |--roses |--abc.jpg |--def.jpg |--dandelion |--ghi.jpg |--jkl.jpg

Les noms des dossiers, des classes et des noms de fichiers .jpg peuvent être n'importe quoi.

Nous offrons le temps de réponse tf_flowers¹jeu de données comme jeu de données par défaut pour affiner le modèle. Cet ensemble de données comprend des images de cinq types de fleurs. Le jeu de données a été téléchargé depuis TensorFlow.

Présentation pas à pas

Les sections suivantes fournissent une démonstration étape par étape pour effectuer la classification des images avec JumpStart, à la fois via l'interface utilisateur de Studio et les API JumpStart.

Nous suivons les étapes suivantes :

Accédez à JumpStart via l'interface utilisateur de Studio :
1. Affiner le modèle pré-formé.
2. Déployez le modèle affiné.
3. Entraînez progressivement le modèle affiné et redéployez-le.
Utilisez JumpStart par programmation avec le SDK SageMaker Python :
1. Affiner le modèle pré-formé.
2. Déployez le modèle affiné.
3. Entraînez progressivement le modèle affiné et redéployez-le.

Accéder à JumpStart via l'interface utilisateur de Studio

Dans cette section, nous montrons comment affiner et déployer des modèles JumpStart via l'interface utilisateur de Studio. De plus, nous montrons comment former progressivement un modèle que vous avez préalablement affiné.

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

La vidéo suivante vous montre comment trouver un modèle de classification d'images pré-entraîné sur JumpStart et l'affiner. La page du modèle contient des informations précieuses sur le modèle, comment l'utiliser, le format de données attendu et quelques détails de réglage fin.

À des fins de démonstration, nous affinons le modèle en utilisant le jeu de données fourni par défaut, qui est le tf_flowers ensemble de données, composé de différentes variétés de fleurs. Le réglage fin de votre propre ensemble de données implique de prendre le formatage correct des données (comme expliqué sur la page du modèle), de le télécharger sur Service de stockage simple Amazon (Amazon S3) et en spécifiant son emplacement dans la configuration de la source de données.

Nous utilisons les mêmes valeurs d'hyperparamètres définies par défaut (nombre d'époques, taux d'apprentissage et taille de lot). Nous utilisons également une instance ml.p3.2xlarge soutenue par GPU comme instance de formation SageMaker.

Vous pouvez surveiller votre tâche d'entraînement directement sur la console Studio et êtes averti lorsqu'elle est terminée.

Déployer le modèle affiné

Une fois la formation terminée, vous pouvez déployer le modèle affiné à partir de la même page qui contient les détails de la tâche de formation. Pour déployer notre modèle, nous choisissons un type d'instance différent, ml.p2.xlarge. Il fournit toujours l'accélération GPU nécessaire pour une faible latence d'inférence, mais à un prix inférieur. Après avoir configuré l'instance d'hébergement SageMaker, choisissez Déployer. Cela peut prendre 5 à 10 minutes pour que votre point de terminaison persistant soit opérationnel.

Votre endpoint est alors opérationnel et prêt à répondre aux requêtes d'inférence !

Pour accélérer votre temps d'inférence, JumpStart fournit un exemple de bloc-notes qui vous montre comment exécuter l'inférence sur votre point de terminaison fraîchement déployé. Choisir Cahier ouvert sous Utiliser le point de terminaison de Studio.

Entraînez progressivement le modèle affiné et déployez-le

Lorsque le réglage fin est terminé, vous pouvez entraîner davantage le modèle pour améliorer les performances. Cette étape est très similaire au processus d'ajustement initial, sauf que nous utilisons le modèle déjà affiné comme point de départ. Vous pouvez utiliser de nouvelles données, mais le format du jeu de données doit être le même (même jeu de classes).

Utiliser JumpStart par programmation avec le SDK SageMaker

Dans les sections précédentes, nous avons montré comment vous pouvez utiliser l'interface utilisateur JumpStart pour affiner, déployer et former de manière incrémentielle un modèle de manière interactive en quelques clics. Vous pouvez également utiliser les modèles de JumpStart et les ajuster facilement par programmation à l'aide d'API intégrées au SDK SageMaker. Nous passons maintenant en revue un exemple rapide de la façon dont vous pouvez reproduire le processus précédent. Toutes les étapes de cette démo sont disponibles dans les cahiers d'accompagnement Introduction à JumpStart - Classification des images.

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

Pour affiner un modèle sélectionné, nous devons obtenir l'URI de ce modèle, ainsi que celui du script de formation et de l'image de conteneur utilisée pour la formation. Heureusement, ces trois entrées dépendent uniquement du nom du modèle, de la version (pour une liste des modèles disponibles, voir Tableau des modèles JumpStart disponibles) et le type d'instance sur laquelle vous souhaitez vous entraîner. Ceci est démontré dans l'extrait de code suivant :

from sagemaker import image_uris, model_uris, script_uris model_id, model_version = "pytorch-ic-mobilenet-v2", "1.0.0"
training_instance_type = "ml.p3.2xlarge" # Retrieve the docker image
train_image_uri = image_uris.retrieve( region=None, framework=None, model_id=model_id, model_version=model_version, image_scope="training", instance_type=training_instance_type,
) # 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 to further fine-tune
train_model_uri = model_uris.retrieve(model_id=model_id, model_version=model_version, model_scope="training")

Nous récupérons le model_id correspondant au même modèle que nous avons utilisé précédemment. L'ic dans l'identifiant correspond à la classification de l'image.

Vous pouvez maintenant affiner ce modèle JumpStart sur votre propre jeu de données personnalisé à l'aide du SDK SageMaker. Nous utilisons le même tf_flowers ensemble de données hébergé publiquement sur Amazon S3, axé sur l'analyse des sentiments. Votre ensemble de données doit être structuré pour un réglage fin, comme expliqué dans la section précédente. Voir l'exemple de code suivant :

# URI of your training dataset
training_dataset_s3_path = "s3://jumpstart-cache-prod-us-west-2/training-datasets/tf_flowers/"
training_job_name = name_from_base(f"jumpstart-example-{model_id}-transfer-learning") # Create SageMaker Estimator instance
ic_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,
) # Launch a SageMaker Training job by passing s3 path of the training data
ic_estimator.fit({"training": training_dataset_s3_path}, logs=True)

Nous obtenons les mêmes hyperparamètres par défaut pour notre modèle sélectionné que ceux que nous avons vus dans la section précédente, en utilisant sagemaker.hyperparameters.retrieve_default(). Nous instancions ensuite un estimateur SageMaker et appelons la méthode .fit pour commencer à affiner notre modèle, en lui transmettant l'URI Amazon S3 pour nos données de formation. Comme vous pouvez le voir, le entry_point le script fourni est nommé transfer_learning.py (le même pour les autres tâches et modèles), et le canal de données d'entrée transmis à .fit doit être nommé training.

Déploiement du modèle affiné

Lorsque la formation est terminée, vous pouvez déployer votre modèle affiné. Pour ce faire, tout ce que nous devons obtenir est l'URI du script d'inférence (le code qui détermine comment le modèle est utilisé pour l'inférence une fois déployé) et l'URI de l'image du conteneur d'inférence, qui comprend un serveur de modèle approprié pour héberger le modèle que nous avons choisi. Voir le code suivant :

# Retrieve the inference docker container uri
deploy_image_uri = image_uris.retrieve( region=None, framework=None, image_scope="inference", model_id=model_id, model_version=model_version, instance_type=inference_instance_type,
)
# Retrieve the inference script uri
deploy_source_uri = script_uris.retrieve( model_id=model_id, model_version=model_version, script_scope="inference"
) endpoint_name = name_from_base(f"jumpstart-example-FT-{model_id}-") # Use the estimator from the previous step to deploy to a SageMaker endpoint
finetuned_predictor = ic_estimator.deploy( initial_instance_count=1, instance_type=inference_instance_type, entry_point="inference.py", image_uri=deploy_image_uri, source_dir=deploy_source_uri, endpoint_name=endpoint_name,
)

Après quelques minutes, notre modèle est déployé et nous pouvons en tirer des prédictions en temps réel !

Ensuite, nous invoquons le point de terminaison pour prédire quel type de fleurs existe dans l'exemple d'image. Nous utilisons le query_endpoint ainsi que parse_response fonctions d'assistance, qui sont définies dans les cahier.

query_response = finetuned_predictor.predict( img, {"ContentType": "application/x-image", "Accept": "application/json;verbose"} )
model_predictions = json.loads(query_response)
predicted_label = model_predictions["predicted_label"]
display( HTML( f'<img src={image_filename} alt={image_filename} align="left" style="width: 250px;"/>' f"<figcaption>Predicted Label: {predicted_label}</figcaption>" )
)

Former progressivement le modèle affiné et le redéployer

Nous pouvons augmenter les performances d'un modèle affiné en l'entraînant davantage sur de nouvelles images. Vous pouvez utiliser n'importe quel nombre d'images nouvelles ou anciennes pour cela, mais le format de l'ensemble de données doit rester le même (même ensemble de classes). L'étape de formation incrémentielle est similaire au processus de réglage fin, avec une différence importante : dans le réglage fin initial, nous commençons avec un modèle pré-formé, tandis que dans la formation incrémentale, nous commençons avec un modèle pré-réglé existant. Voir le code suivant :

last_trained_model_path = f"{s3_output_location}/{last_training_job_name}/output/model.tar.gz"
incremental_s3_output_location = f"s3://{output_bucket}/{incremental_output_prefix}/output"incremental_train_estimator = Estimator( role=aws_role, image_uri=train_image_uri, source_dir=train_source_uri, model_uri=last_trained_model_path, entry_point="transfer_learning.py", instance_count=1, instance_type=training_instance_type, max_run=360000, hyperparameters=hyperparameters, output_path=incremental_s3_output_location, base_job_name=incremental_training_job_name,
) incremental_train_estimator.fit({"training": training_dataset_s3_path}, logs=True)

Lorsque la formation est terminée, nous pouvons utiliser les mêmes étapes que celles décrites dans la section précédente pour déployer le modèle.

Conclusion

JumpStart est une fonctionnalité de SageMaker qui vous permet de démarrer rapidement avec ML. JumpStart utilise des modèles pré-entraînés open source pour résoudre des problèmes de ML courants tels que la classification d'images, la détection d'objets, la classification de texte, la classification de paires de phrases et la réponse aux questions.

Dans cet article, nous vous avons montré comment affiner et déployer un modèle de classification d'images pré-entraîné. Nous avons également montré comment former progressivement un modèle affiné pour la classification des images. Avec JumpStart, vous pouvez facilement effectuer ce processus sans avoir besoin de coder. Essayez la solution par vous-même et faites-nous savoir comment cela se passe dans les commentaires. Pour en savoir plus sur JumpStart, consultez la vidéo AWS re:Invent 2020 Démarrez avec le ML en quelques minutes avec Amazon SageMaker JumpStart.

Bibliographie

L'équipe TensorFlow2019

À propos des auteurs

Dr Vivek Madan est un scientifique appliqué au sein de l'é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 Amazon SageMaker JumpStart ainsi que Algorithmes intégrés d'Amazon SageMaker et aide à développer des algorithmes d'apprentissage automatique. 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.