Modèles et algorithmes Amazon SageMaker JumpStart désormais disponibles via l'API

En décembre 2020, AWS a annoncé la disponibilité générale of Amazon SageMaker JumpStart, une capacité de Amazon Sage Maker qui vous aide à démarrer rapidement et facilement avec l'apprentissage automatique (ML). JumpStart permet d'ajuster et de déployer en un clic 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.

Auparavant, tout le contenu JumpStart n'était disponible que via Amazon SageMakerStudio, qui fournit un interface graphique conviviale pour interagir avec la fonction. Aujourd'hui, nous sommes ravis d'annoncer le lancement de API JumpStart en tant qu'extension du SDK SageMaker Python. Ces API vous permettent de déployer et d'affiner par programmation 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 fournissons une mise à jour sur l'état actuel des capacités de JumpStart et vous guidons à travers le flux d'utilisation de l'API JumpStart avec un exemple de cas d'utilisation.

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 résoudre 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 acquises dans un domaine vers un autre domaine 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 à partir de zéro. 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 et la classification des données tabulaires.
• Utiliser des solutions prédéfinies – JumpStart fournit un ensemble de 17 solutions pré-construites pour les cas d'utilisation courants du 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 relient 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 de algorithmes intégrés pour aider les scientifiques des données et les praticiens du ML à démarrer rapidement la formation et le déploiement de modèles de ML. JumpStart fournit des exemples de blocs-notes que vous pouvez utiliser pour utiliser rapidement ces algorithmes.
• Profitez des vidéos de formation et des 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 les clés de chiffrement 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 SageMaker Studio ou via le SDK SageMaker Python.

Tâches de ML prises en charge par JumpStart et exemples d'API

JumpStart prend actuellement en charge 15 des tâches ML les plus populaires ; 13 d'entre eux sont des tâches basées sur la vision et la PNL, dont 8 prennent en charge le réglage fin sans code. Il prend également en charge quatre algorithmes populaires pour la modélisation de données tabulaires. Les tâches et les liens vers leurs exemples de blocs-notes sont résumés dans le tableau suivant.

Selon la tâche, les exemples de notebooks liés dans le tableau précédent peuvent vous guider sur tout ou partie des processus suivants :

• Sélectionnez un modèle préformé pris en charge par JumpStart pour votre tâche spécifique.
• Hébergez un modèle pré-entraîné, obtenez-en des prédictions en temps réel et affichez correctement les résultats.
• Affinez un modèle pré-formé avec votre propre sélection d'hyperparamètres et déployez-le pour l'inférence.

Affinez et déployez un modèle de détection d'objets avec les API JumpStart

Dans les sections suivantes, nous expliquons étape par étape comment utiliser les nouvelles API JumpStart sur la tâche représentative de détection d'objets. Nous montrons comment utiliser un modèle de détection d'objets pré-formé pour identifier des objets à partir d'un ensemble prédéfini de classes dans une image avec des boîtes englobantes. Enfin, nous montrons comment affiner un modèle pré-formé sur votre propre ensemble de données pour détecter des objets dans des images spécifiques aux besoins de votre entreprise, simplement en apportant vos propres données. Nous fournissons un cahier d'accompagnement pour cette procédure pas à pas.

Nous suivons les étapes de haut niveau suivantes :

1. Exécutez l'inférence sur le modèle pré-entraîné.
   1. Récupérez les artefacts JumpStart et déployez un point de terminaison.
   2. Interrogez le point de terminaison, analysez la réponse et affichez les prédictions du modèle.
2. Ajustez le modèle pré-entraîné sur votre propre jeu de données.
   1. Récupérer des artefacts de formation.
   2. Exécutez la formation.

Exécuter l'inférence sur le modèle pré-entraîné

Dans cette section, nous choisissons un modèle pré-formé approprié dans JumpStart, déployons ce modèle sur un point de terminaison SageMaker et montrons comment exécuter l'inférence sur le point de terminaison déployé. Toutes les étapes sont disponibles dans le accompagnant le cahier Jupyter.

Récupérer les artefacts JumpStart et déployer un point de terminaison

SageMaker est une plateforme basée sur des conteneurs Docker. JumpStart utilise le framework spécifique disponible Conteneurs d'apprentissage en profondeur SageMaker (DLC). Nous récupérons tous les packages supplémentaires, ainsi que les scripts pour gérer la formation et l'inférence pour la tâche sélectionnée. Enfin, les artefacts de modèle pré-formés sont récupérés séparément avec model_uris, qui offre de la flexibilité à la plate-forme. Vous pouvez utiliser n'importe quel nombre de modèles pré-formés pour la même tâche avec un seul script de formation ou d'inférence. Voir le code suivant :

infer_model_id, infer_model_version = "pytorch-od-nvidia-ssd", "*" # Retrieve the inference docker container uri. This is the base container PyTorch image for the model selected above. deploy_image_uri = image_uris.retrieve(region=None, framework=None, image_scope="inference",model_id=infer_model_id, model_version=infer_model_version, instance_type=inference_instance_type) # Retrieve the inference script uri. This includes all dependencies and scripts for model loading, inference handling etc.
deploy_source_uri = script_uris.retrieve(model_id=infer_model_id, model_version=infer_model_version, script_scope="inference") # Retrieve the base model uri. This includes the pre-trained nvidia-ssd model and parameters.
base_model_uri = model_uris.retrieve(model_id=infer_model_id, model_version=infer_model_version, model_scope="inference")

Ensuite, nous introduisons les ressources dans un Modèle Sage Maker instance et déployer un point de terminaison :

# Create the SageMaker model instance
model = Model(image_uri=deploy_image_uri, source_dir=deploy_source_uri, model_data=base_model_uri, entry_point="inference.py", role=aws_role, predictor_cls=Predictor, name=endpoint_name) # deploy the Model. Note that we need to pass Predictor class when we deploy model through Model class for being able to run inference through the sagemaker API.
base_model_predictor = model.deploy(initial_instance_count=1, instance_type=inference_instance_type, predictor_cls=Predictor, endpoint_name=endpoint_name)

Le déploiement du point de terminaison peut prendre quelques minutes.

Interroger le point de terminaison, analyser la réponse et afficher les prédictions

Pour obtenir des inférences à partir d'un modèle déployé, une image d'entrée doit être fournie au format binaire avec un type d'acceptation. Dans JumpStart, vous pouvez définir le nombre de cadres de délimitation renvoyés. Dans l'extrait de code suivant, nous prévoyons dix cadres de délimitation par image en ajoutant ;n_predictions=10 à Accept. Pour prédire xx cases, vous pouvez le changer en ;n_predictions=xx , ou obtenir toutes les cases prédites en omettant ;n_predictions=xx entièrement.

def query(model_predictor, image_file_name): with open(image_file_name, "rb") as file: input_img_rb = file.read() return model_predictor.predict(input_img_rb,{ "ContentType": "application/x-image", "Accept": "application/json;verbose;n_predictions=10"}) query_response = query(base_model_predictor, Naxos_Taverna)

L'extrait de code suivant vous donne un aperçu de ce à quoi ressemble la détection d'objet. La probabilité prédite pour chaque classe d'objets est visualisée, ainsi que sa boîte englobante. Nous utilisons le parse_response ainsi que le display_predictions fonctions d'assistance, qui sont définies dans les cahier.

normalized_boxes, classes_names, confidences = parse_response(query_response)
display_predictions(Naxos_Taverna, normalized_boxes, classes_names, confidences)

La capture d'écran suivante montre la sortie d'une image avec des étiquettes de prédiction et des cadres de délimitation.

Affiner un modèle pré-formé sur votre propre jeu de données

Les modèles de détection d'objets existants dans JumpStart sont pré-formés sur les ensembles de données COCO ou VOC. Toutefois, si vous devez identifier des classes d'objets qui n'existent pas dans le jeu de données de pré-formation d'origine, vous devez affiner le modèle sur un nouveau jeu de données qui inclut ces nouveaux types d'objets. Par exemple, si vous devez identifier des ustensiles de cuisine et exécuter une inférence sur un modèle SSD pré-entraîné déployé, le modèle ne reconnaît aucune caractéristique des nouveaux types d'images et, par conséquent, la sortie est incorrecte.

Dans cette section, nous montrons à quel point il est facile d'affiner un modèle pré-formé pour détecter de nouvelles classes d'objets à l'aide des API JumpStart. L'exemple de code complet avec plus de détails est disponible dans le carnet d'accompagnement.

Récupérer des artefacts de formation

Les artefacts de formation sont similaires aux artefacts d'inférence abordés dans la section précédente. La formation nécessite un conteneur Docker de base, à savoir le conteneur MXNet dans l'exemple de code suivant. Tous les packages supplémentaires requis pour la formation sont inclus avec les scripts de formation dans train_sourcer_uri. Le modèle pré-entraîné et ses paramètres sont emballés séparément.

train_model_id, train_model_version, train_scope = "mxnet-od-ssd-512-vgg16-atrous-coco","*","training"
training_instance_type = "ml.p2.xlarge" # Retrieve the docker image. This is the base container MXNet image for the model selected above. train_image_uri = image_uris.retrieve(region=None, framework=None, model_id=train_model_id, model_version=train_model_version, image_scope=train_scope,instance_type=training_instance_type) # Retrieve the training script and dependencies. This contains all the necessary files including data processing, model training etc.
train_source_uri = script_uris.retrieve(model_id=train_model_id, model_version=train_model_version, script_scope=train_scope) # Retrieve the pre-trained model tarball to further fine-tune
train_model_uri = model_uris.retrieve(
model_id=train_model_id, model_version=train_model_version, model_scope=train_scope)

Entraînement à la course

Pour exécuter la formation, nous transmettons simplement les artefacts requis ainsi que certains paramètres supplémentaires à un Estimateur SageMaker et appelez le .fit fonction:

# Create SageMaker Estimator instance
od_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", # Entry-point file in source_dir and present in train_source_uri. 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
od_estimator.fit({"training": training_dataset_s3_path}, logs=True)

Pendant que l'algorithme s'entraîne, vous pouvez surveiller sa progression soit dans le bloc-notes SageMaker où vous exécutez le code lui-même, soit sur Amazon Cloud Watch. Lorsque la formation est terminée, les artefacts du modèle affiné sont téléchargés vers le Service de stockage simple Amazon (Amazon S3) emplacement de sortie spécifié dans la configuration de la formation. Vous pouvez maintenant déployer le modèle de la même manière que le modèle pré-entraîné. Vous pouvez suivre le reste du processus dans le carnet d'accompagnement.

Conclusion

Dans cet article, nous avons décrit la valeur des API JumpStart nouvellement publiées et comment les utiliser. Nous avons fourni des liens vers 17 exemples de blocs-notes pour les différentes tâches de ML prises en charge dans JumpStart et vous avons présenté le bloc-notes de détection d'objets.

Nous attendons avec impatience d'avoir de vos nouvelles pendant que vous expérimentez JumpStart.

À propos des auteurs

Dr Vivek Madan est un scientifique appliqué au sein de l'équipe Amazon SageMaker JumpStart. Il a obtenu son doctorat à 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 des modèles de Deep Learning.

Dr Ashish Khetan est un scientifique appliqué senior avec Amazon SageMaker JumpStart ainsi que le 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 et ACL.

• Coinsmart. Le meilleur échange Bitcoin et Crypto d'Europe.
• Platoblockchain. Intelligence métaverse Web3. Connaissance amplifiée. ACCÈS LIBRE.
• CryptoHawk. Radar Altcoins. Essai gratuit.
• Source : https://aws.amazon.com/blogs/machine-learning/amazon-sagemaker-jumpstart-models-and-algorithms-now-available-via-api/