Créer des modèles Amazon SageMaker à l'aide du zoo de modèles PyTorch

Créer des modèles Amazon SageMaker à l'aide du zoo de modèles PyTorch

Horodatage: 19 décembre 2022 12:46
Nœud source: 1778255

Le déploiement de modèles d'apprentissage automatique (ML) formés et de haute qualité pour effectuer des inférences par lots ou en temps réel est un élément essentiel pour apporter de la valeur aux clients. Cependant, le processus d'expérimentation ML peut être fastidieux - il existe de nombreuses approches nécessitant beaucoup de temps à mettre en œuvre. C'est pourquoi des modèles de ML pré-entraînés comme ceux fournis dans le Zoo modèle PyTorch sont si utiles. Amazon Sage Maker fournit une interface unifiée pour expérimenter différents modèles ML, et le zoo de modèles PyTorch nous permet d'échanger facilement nos modèles de manière standardisée.

Cet article de blog montre comment effectuer une inférence ML à l'aide d'un modèle de détection d'objet du zoo de modèles PyTorch dans SageMaker. Les modèles ML pré-formés du zoo de modèles PyTorch sont prêts à l'emploi et peuvent facilement être utilisés dans le cadre d'applications ML. Configurer ces modèles ML en tant que point de terminaison SageMaker ou Transformation par lots SageMaker travail pour l'inférence en ligne ou hors ligne est facile avec les étapes décrites dans ce billet de blog. Nous utiliserons un R-CNN plus rapide modèle de détection d'objets pour prédire les boîtes englobantes pour les classes d'objets prédéfinies.

Nous passons en revue un exemple de bout en bout, du chargement des poids du modèle de détection d'objets Faster R-CNN à leur enregistrement dans un Service de stockage simple Amazon (Amazon S3) bucket, et d'écrire un fichier de point d'entrée et de comprendre les paramètres clés de l'API PyTorchModel. Enfin, nous déploierons le modèle ML, effectuerons une inférence à l'aide de SageMaker Batch Transform, inspecterons la sortie du modèle ML et apprendrons à interpréter les résultats. Cette solution peut être appliquée à tout autre modèle pré-formé sur le PyTorch Model Zoo. Pour une liste des modèles disponibles, consultez le Documentation du zoo modèle PyTorch.

Vue d'ensemble de la solution

Ce billet de blog passera par les étapes suivantes. Pour une version de travail complète de toutes les étapes, voir create_pytorch_model_sagemaker.ipynb

  • Étape 1 : configuration
  • Étape 2 : Charger un modèle ML à partir de PyTorch Model Zoo
  • Étape 3 Enregistrez et chargez les artefacts du modèle ML sur Amazon S3
  • Étape 4 : Créer des scripts d'inférence de modèle de ML
  • Étape 5 : Lancement d'une tâche de transformation par lots SageMaker
  • Étape 6 : Visualiser les résultats

Diagramme d'architecture

Structure du répertoire

Le code de ce blog se trouve dans ce GitHub référentiel. La base de code contient tout ce dont nous avons besoin pour créer des artefacts de modèle ML, lancer la tâche de transformation et visualiser les résultats.

C'est le flux de travail que nous utilisons. Toutes les étapes suivantes feront référence aux modules de cette structure.

sagemaker_pytorch_model_zoo --> root directory |- inference.py --> entry point file |- create_pytorch_model_sagemaker.ipynb --> walks through all steps in this blog post |- cars.jpg --> input image

Les sagemaker_torch_model_zoo dossier doit contenir inference.py en tant que fichier de point d'entrée, et create_pytorch_model_sagemaker.ipynb pour charger et enregistrer les pondérations du modèle, créer un objet de modèle SageMaker et enfin le transmettre à une tâche de transformation par lots SageMaker. Afin d'apporter vos propres modèles ML, modifiez les chemins dans la section Étape 1 : configuration du notebook et chargez un nouveau modèle dans la section Étape 2 : Chargement d'un modèle ML à partir de la section Zoo de modèles PyTorch. Le reste des étapes suivantes ci-dessous resterait le même.

Étape 1 : configuration

Rôles IAM

SageMaker effectue des opérations sur une infrastructure gérée par SageMaker. SageMaker ne peut effectuer que les actions autorisées telles que définies dans le rôle d'exécution IAM associé au bloc-notes pour SageMaker. Pour une documentation plus détaillée sur la création de rôles IAM et la gestion des autorisations IAM, consultez le Documentation des rôles AWS SageMaker. Nous pouvons créer un nouveau rôle, ou nous pourrions obtenir le Bloc-notes SageMaker (Studio)le rôle d'exécution par défaut de en exécutant les lignes de code suivantes :

import sagemaker session = sagemaker.Session() # Set a default S3 bucket
default_bucket = session.default_bucket() # Get the region
region = boto3.Session().region_name # Get the SageMaker Execution Role
role_arn = sagemaker.get_execution_role()

Le code ci-dessus obtient le rôle d'exécution SageMaker pour l'instance de bloc-notes. Il s'agit du rôle IAM que nous avons créé pour notre instance de bloc-notes SageMaker ou SageMaker Studio.

Paramètres configurables par l'utilisateur

Voici tous les paramètres configurables nécessaires à la création et au lancement de notre tâche de transformation par lots SageMaker :

INSTANCE_TYPE= "ml.m5.xlarge"
INSTANCE_COUNT= 1
BUCKET = os.path.join("s3://", default_bucket) DATA_PATH= os.path.join(BUCKET, "images")
IMAGE_NAME = "cars.jpg"
RANDOM_STRING_LENGTH= 16
MODEL_NAME= "FasterRCNNResnet50" # Needs to be set to version 1.2 or higher to enable automatic PyTorch model repackaging
FRAMEWORK_VERSION= "1.2"
ENTRY_POINT_FILE_NAME= "inference.py" SAGEMAKER_EXECUTION_ROLE_ARN= role_arn
MODEL_ARTIFACTS_FILE_NAME= os.path.join(BUCKET, "modelzoo/fasterrcnn_resnet50_fpn/model.tar.gz")
IMAGE_URI= sagemaker.image_uris.retrieve(framework="pytorch",
region=region,
version="1.9.1",
py_version="py38",
image_scope='inference',
instance_type=INSTANCE_TYPE)

Étape 2 : Charger un modèle ML à partir du zoo de modèles PyTorch

Ensuite, nous spécifions un modèle de détection d'objet à partir du zoo de modèles PyTorch et enregistrons ses poids de modèle ML. En règle générale, nous enregistrons un modèle PyTorch en utilisant les extensions de fichier .pt ou .pth. L'extrait de code ci-dessous télécharge un modèle Faster R-CNN ResNet50 ML pré-formé à partir du zoo de modèles PyTorch :

modèle = torchvision.models.detection.fasterrcnn_resnet50_fpn(pretrained=True)

La transformation par lots SageMaker nécessite en entrée certaines pondérations de modèle, nous allons donc enregistrer le modèle ML pré-formé sous model.pt. Si nous voulons charger un modèle personnalisé, nous pourrions enregistrer les poids du modèle à partir d'un autre modèle PyTorch en tant que model.pt à la place.

H = 1080
W = 1920
scripted_fn = torch.jit.script(model, torch.randn(1, 3, H, W))
scripted_fn.save("model.pt")

Étape 3 : Enregistrer et charger des artefacts de modèle ML sur Amazon S3

Étant donné que nous utiliserons SageMaker pour l'inférence ML, nous devons télécharger les pondérations du modèle dans un compartiment S3. Nous pouvons le faire en utilisant les commandes suivantes ou en téléchargeant et en faisant simplement glisser et déposer le fichier directement dans S3. Les commandes suivantes vont d'abord compresser le groupe de fichiers dans model.pt dans une archive tar et copiez les poids du modèle de notre machine locale vers le compartiment S3.

Notes: Pour exécuter les commandes suivantes, vous devez disposer du Interface de ligne de commande AWS (AWS CLI) installé.

tar -czvf model.tar.gz model.pt
aws s3 cp model.tar.gz $MODEL_ARTIFACTS_FILE_NAME

Ensuite, nous copions notre image d'entrée sur S3. Vous trouverez ci-dessous le chemin S3 complet de l'image.

car_image_path = os.path.join(DATA_PATH, IMAGE_NAME)

Nous pouvons copier cette image sur S3 avec une autre commande aws s3 cp.

aws s3 cp cars.jpg $car_image_path

Étape 4 : Créer des scripts d'inférence de modèle de ML

Nous allons maintenant passer en revue notre fichier entrypoint, inference.py module. Nous pouvons déployer un modèle PyTorch formé en dehors de SageMaker à l'aide de la classe PyTorchModel. Tout d'abord, nous instancions l'objet PyTorchModelZoo. Ensuite, nous allons construire un fichier de point d'entrée inference.py pour effectuer une inférence ML à l'aide de la transformation par lots SageMaker sur des exemples de données hébergées dans Amazon S3.

Comprendre l'objet PyTorchModel

Les PyTorchModèle La classe dans l'API Python SageMaker nous permet d'effectuer une inférence ML à l'aide de notre artefact de modèle téléchargé.

Pour lancer la classe PyTorchModel, nous devons comprendre les paramètres d'entrée suivants :

  • name: Nom du modèle; nous vous recommandons d'utiliser soit le nom du modèle + la date et l'heure, soit une chaîne aléatoire + la date et l'heure pour l'unicité.
  • model_data: L'URI S3 de l'artefact de modèle de ML empaqueté.
  • entry_point: fichier Python défini par l'utilisateur à utiliser par l'image Docker d'inférence pour définir des gestionnaires pour les demandes entrantes. Le code définit le chargement du modèle, le prétraitement des entrées, la logique de prédiction et le post-traitement des sorties.
  • framework_version: Doit être défini sur la version 1.2 ou supérieure pour activer le reconditionnement automatique du modèle PyTorch.
  • source_dir: Le répertoire du fichier entry_point.
  • role: Un rôle IAM pour faire des demandes de service AWS.
  • image_uri: utilisez cette image de conteneur Amazon ECR Docker comme base pour l'environnement de calcul du modèle ML.
  • sagemaker_session: La session SageMaker.
  • py_version: La version de Python à utiliser

L'extrait de code suivant instancie la classe PyTorchModel pour effectuer une inférence à l'aide du modèle PyTorch pré-entraîné :

model = PyTorchModel( name=RANDOM_STRING, model_data=MODEL_ARTIFACTS_FILE_NAME, entry_point=ENTRY_POINT_FILE_NAME, framework_version=FRAMEWORK_VERSION, role=SAGEMAKER_EXECUTION_ROLE_ARN, sagemaker_session=sagemaker_session, image_uri=IMAGE_URI, )

Comprendre le fichier de point d'entrée (inference.py)

Le paramètre entry_point pointe vers un fichier Python nommé inference.py. Ce point d'entrée définit le chargement du modèle, le prétraitement des entrées, la logique de prédiction et le post-traitement des sorties. Il complète le code de service de modèle ML dans le PyTorch prédéfini Conteneur d'apprentissage en profondeur SageMaker l'image.

Inference.py contiendra les fonctions suivantes. Dans notre exemple, nous implémentons la model_fn, input_fn, predict_fn ainsi que output_fn fonctions pour remplacer les gestionnaire d'inférence PyTorch par défaut.

  1. model_fn: prend dans un répertoire contenant des points de contrôle de modèle statique dans l'image d'inférence. Ouvre et charge le modèle à partir d'un chemin spécifié et renvoie un modèle PyTorch.
  2. input_fn: prend en entrée la charge utile de la requête entrante (request_body) et le type de contenu d'une requête entrante (request_content_type). Gère le décodage des données. Cette fonction doit être ajustée en fonction de l'entrée attendue par le modèle.
  3. predict_fn: Appelle un modèle sur des données désérialisées dans input_fn. Effectue une prédiction sur l'objet désérialisé avec le modèle ML chargé.
  4. output_fn: sérialise le résultat de la prédiction dans le type de contenu de réponse souhaité. Convertit les prédictions obtenues à partir de la fonction predict_fn aux formats JSON, CSV ou NPY.

Étape 5 : Lancement d'une tâche de transformation par lots SageMaker

Pour cet exemple, nous obtiendrons des résultats d'inférence ML via une tâche de transformation par lots SageMaker. Les tâches de transformation par lots sont particulièrement utiles lorsque nous voulons obtenir des inférences à partir d'ensembles de données une seule fois, sans avoir besoin d'un point de terminaison persistant. Nous instancions un sagemaker.transformer.Transformateur objet pour créer et interagir avec les tâches de transformation par lots SageMaker.

transformer = model.transformer(instance_type=INSTANCE_TYPE, instance_count=INSTANCE_COUNT )
transformer.transform(data=DATA_PATH, data_type="S3Prefix", content_type="application/x-image", wait=True )

Consultez la documentation relative à la création d'une tâche de transformation par lots à l'adresse Créer un travail de transformation.

Étape 6 : Visualiser les résultats

Une fois la tâche de transformation par lots SageMaker terminée, nous pouvons charger les sorties d'inférence ML à partir d'Amazon S3. Pour cela, accédez au Console de gestion AWS et recherchez Amazon SageMaker. Sur le panneau de gauche, sous Inférence, Voir Tâches de transformation par lots.

Après avoir sélectionné Transformation par lots, consultez la page Web répertoriant toutes les tâches de transformation par lots SageMaker. Nous pouvons voir la progression de l'exécution de notre tâche la plus récente.

Tout d'abord, le travail aura le statut "En cours". Une fois que c'est fait, voyez le statut passer à Terminé.

Une fois que le statut est marqué comme terminé, nous pouvons cliquer sur le travail pour afficher les résultats. Cette page Web contient le résumé du travail, y compris les configurations du travail que nous venons d'exécuter.

Sous Configuration des données de sortie, nous verrons un chemin de sortie S3. C'est là que nous trouverons notre sortie d'inférence ML.

Sélectionnez le chemin de sortie S3 et voyez un fichier [image_name].[file_type].out avec nos données de sortie. Notre fichier de sortie contiendra une liste de mappages. Exemple de sortie :

[ { "boxes": [ [ 214.32322692871094, 192.18418884277344, 830.3932495117188, 521.6996459960938 ], [ 235.6244354248047, 301.3315734863281, 253.6448516845703, 312.3525695800781 ], [ 183.92031860351562, 291.7759704589844, 207.28196716308594, 312.1448669433594 ], ], "labels": [ 3, 3, 9, ], "scores": [ 0.8823906183242798, 0.7710548639297485, 0.4969744384288788, ] }
]


Afin de visualiser ces prédictions, nous lisons d'abord le chemin de sortie de notre objet transformateur.

def get_output_from_s3(s3uri, file_name): parsed_url = urlparse(s3uri) bucket_name = parsed_url.netloc prefix = parsed_url.path[1:] s3 = boto3.resource('s3') obj = s3.Object(bucket_name, '{}/{}'.format(prefix, file_name)) return obj.get()["Body"].read().decode('utf-8') # Output path from Batch Transform job
output_path = transformer.output_path # Get the output file from S3
predictions = get_output_from_s3(output_path, "car.jpg.out")

Ensuite, nous traitons ce fichier de sortie et visualisons nos prédictions. Ci-dessous, nous précisons notre seuil de confiance. Nous obtenons la liste des classes de la Mappage d'objets de l'ensemble de données COCO. Lors de l'inférence, le modèle ne nécessite que les tenseurs d'entrée et renvoie les prédictions post-traitées sous forme de List[Dict[Tensor]], une pour chaque image d'entrée. Les champs du Dict sont les suivants, où N est le nombre de détections :

  1. box (FloatTensor[N, 4]) : les boîtes prédites dans [x1, y1, x2, y2] format, avec 0 <= x1 < x2 <= W and 0 <= y1 < y2 <= H, Où W est la largeur de l'image et H est la hauteur de l'image
  2. Étiquettes (Int64Tensor[N]) : les étiquettes prédites pour chaque détection
  3. partitions (Tensor[N]) : les scores de prédiction pour chaque détection

Pour plus de détails sur la sortie, reportez-vous au Documentation PyTorch Faster R-CNN FPN.

La sortie du modèle contient des cadres de délimitation avec des scores de confiance respectifs. Nous pouvons optimiser l'affichage des faux positifs en supprimant les boîtes englobantes pour lesquelles le modèle n'est pas sûr. Les extraits de code suivants traitent les prédictions dans le fichier de sortie et dessinent des cadres de délimitation sur les prédictions où le score est supérieur à notre seuil de confiance. Nous fixons le seuil de probabilité, CONF_THRESH, à 75 pour cet exemple.

def procress_batch_transform_output(predictions): predictions = eval(predictions) for pred in predictions[1:]: pred = pred[0] boxes = np.array(pred["boxes"]) labels = np.array(pred["labels"]) scores = np.array(pred["scores"]) scores_idx = scores >= CONF_THRESH boxes_meet = boxes[scores_idx, :] labels_meet = labels[scores_idx] scores_meet = scores[scores_idx] labels_str = [CLASSES[i] for i in labels_meet] # Return a tuple containing labels, label index, score, and bounding box processed_predictions = list(zip(labels_str, labels_meet, scores_meet, boxes_meet)) return processed_predictions def visualize_batch_transform_output(input_image, processed_predictions): # read input image from computer img = read_image(input_image) for label, label_index, score, box in processed_predictions: label = label + ", score: " + str(round(score, 2)) # draw bounding box and fill color box = torch.tensor(box) box = box.unsqueeze(0) img = draw_bounding_boxes(img, box, width=5,labels=[label], font_size=16) # transform this image to PIL image img = torchvision.transforms.ToPILImage()(img) # display output img.show() # Process the predictions in the output file
processed_predictions = procress_batch_transform_output(predictions)
visualize_batch_transform_output("car.jpg", processed_predictions)

Enfin, nous visualisons ces mappages pour comprendre notre sortie.

Notes: si l'image ne s'affiche pas dans votre bloc-notes, veuillez la localiser dans l'arborescence des répertoires sur le côté gauche de JupyterLab et l'ouvrir à partir de là.

Exécution de l'exemple de code

Pour un exemple de travail complet, clonez le code dans le amazon-sagemaker-exemples GitHub et exécuter les cellules dans le create_pytorch_model_sagemaker.ipynb carnet.

Conclusion

Dans cet article de blog, nous avons présenté un exemple de bout en bout d'inférence ML à l'aide d'un modèle de détection d'objets du zoo de modèles PyTorch à l'aide de la transformation par lots SageMaker. Nous avons couvert le chargement des pondérations du modèle de détection d'objets Faster R-CNN, leur enregistrement dans un compartiment S3, l'écriture d'un fichier de point d'entrée et la compréhension des paramètres clés de l'API PyTorchModel. Enfin, nous avons déployé le modèle et effectué l'inférence du modèle ML, visualisé la sortie du modèle et appris à interpréter les résultats.

À propos des auteurs

Dipika Khullar est un ingénieur ML dans le Laboratoire de solutions Amazon ML. Elle aide les clients à intégrer des solutions ML pour résoudre leurs problèmes commerciaux. Plus récemment, elle a construit des pipelines de formation et d'inférence pour les clients des médias et des modèles prédictifs pour le marketing.

Marcelo Aberlé est ingénieur ML au sein de l'organisation AWS AI. Il dirige les efforts de MLOps au Laboratoire de solutions Amazon ML, aidant les clients à concevoir et à mettre en œuvre des systèmes de ML évolutifs. Sa mission est de guider les clients dans leur parcours ML d'entreprise et d'accélérer leur parcours ML vers la production.

Ninad Kulkarni est un scientifique appliqué dans le Laboratoire de solutions Amazon ML. Il aide les clients à adopter le ML et l'IA en créant des solutions pour résoudre leurs problèmes commerciaux. Plus récemment, il a construit des modèles prédictifs pour les clients du sport, de l'automobile et des médias.

Yash Shah est directeur scientifique au Laboratoire de solutions Amazon ML. Lui et son équipe de scientifiques appliqués et d'ingénieurs ML travaillent sur une gamme de cas d'utilisation ML dans les domaines de la santé, du sport, de l'automobile et de la fabrication.

Horodatage:

Plus de Apprentissage automatique AWS