Modèles de vision par ordinateur

Un modèle de vision par ordinateur est un logiciel conçu pour détecter des objets dans des images. Un modèle apprend à reconnaître un ensemble d'objets en analysant d'abord des images de ces objets par le biais d'un entraînement. Un modèle de vision par ordinateur prend une image en entrée et génère des informations sur les objets qu'il détecte, tels que le type d'objet et son emplacement. AWS Panorama prend en charge les modèles de vision par ordinateur PyTorch créés avec Apache MXNet etTensorFlow.

Note

Pour obtenir la liste des modèles prédéfinis qui ont été testés avec AWS Panorama, consultez la section Compatibilité des modèles.

Utilisation de modèles dans le code

Un modèle renvoie un ou plusieurs résultats, qui peuvent inclure des probabilités pour les classes détectées, des informations de localisation et d'autres données. L'exemple suivant montre comment exécuter une inférence sur une image à partir d'un flux vidéo et envoyer la sortie du modèle à une fonction de traitement.

Exemple application.py — Inférence

    def process_media(self, stream):
        """Runs inference on a frame of video."""
        image_data = preprocess(stream.image,self.MODEL_DIM)
        logger.debug('Image data: {}'.format(image_data))
        # Run inference
        inference_start = time.time()
        inference_results = self.call({"data":image_data}, self.MODEL_NODE)
         # Log metrics
        inference_time = (time.time() - inference_start) * 1000
        if inference_time > self.inference_time_max:
            self.inference_time_max = inference_time
        self.inference_time_ms += inference_time
        # Process results (classification)
        self.process_results(inference_results, stream)

L'exemple suivant montre une fonction qui traite les résultats du modèle de classification de base. Le modèle d'échantillon renvoie un tableau de probabilités, qui est la première et unique valeur du tableau de résultats.

Exemple application.py — Traitement des résultats

    def process_results(self, inference_results, stream):
        """Processes output tensors from a computer vision model and annotates a video frame."""
        if inference_results is None:
            logger.warning("Inference results are None.")
            return
        max_results = 5
        logger.debug('Inference results: {}'.format(inference_results))
        class_tuple = inference_results[0]
        enum_vals = [(i, val) for i, val in enumerate(class_tuple[0])]
        sorted_vals = sorted(enum_vals, key=lambda tup: tup[1])
        top_k = sorted_vals[::-1][:max_results]
        indexes =  [tup[0] for tup in top_k]

        for j in range(max_results):
            label = 'Class [%s], with probability %.3f.'% (self.classes[indexes[j]], class_tuple[0][indexes[j]])
            stream.add_label(label, 0.1, 0.1 + 0.1*j)

Le code de l'application trouve les valeurs présentant les probabilités les plus élevées et les mappe aux étiquettes d'un fichier de ressources chargé lors de l'initialisation.

Création d'un modèle personnalisé

Vous pouvez utiliser des modèles que vous créez dans PyTorch Apache MXNet et TensorFlow dans les applications AWS Panorama. Au lieu de créer et d'entraîner des modèles dansSageMaker, vous pouvez utiliser un modèle entraîné ou créer et entraîner votre propre modèle à l'aide d'un framework compatible et l'exporter dans un environnement local ou dans Amazon EC2.

Note

Pour en savoir plus sur les versions du framework et les formats de fichiers pris en charge par SageMaker Neo, consultez la section Frameworks pris en charge dans le manuel Amazon SageMaker Developer Guide.

Le référentiel de ce guide fournit un exemple d'application qui illustre ce flux de travail pour un modèle Keras au TensorFlow SavedModel format. Il utilise TensorFlow 2 et peut s'exécuter localement dans un environnement virtuel ou dans un conteneur Docker. L'exemple d'application inclut également des modèles et des scripts permettant de créer le modèle sur une instance Amazon EC2.

• Exemple d'application de modèle personnalisé

AWS Panorama utilise SageMaker Neo pour compiler des modèles à utiliser sur l'appliance AWS Panorama. Pour chaque framework, utilisez le format pris en charge par SageMaker Neo et empaquetez le modèle dans une .tar.gz archive.

Pour plus d'informations, consultez Compiler et déployer des modèles avec Neo dans le manuel Amazon SageMaker Developer Guide.

Empaqueter un modèle

Un package de modèle comprend un descripteur, une configuration de package et une archive de modèles. Comme dans un package d'images d'application, la configuration du package indique au service AWS Panorama où le modèle et le descripteur sont stockés dans Amazon S3.

Exemple /Paquets/123456789012-squeezenet_pytorch-1.0/descriptor.json

{
    "mlModelDescriptor": {
        "envelopeVersion": "2021-01-01",
        "framework": "PYTORCH",
        "frameworkVersion": "1.8",
        "precisionMode": "FP16",
        "inputs": [
            {
                "name": "data",
                "shape": [
                    1,
                    3,
                    224,
                    224
                ]
            }
        ]
    }
}

Note

Spécifiez uniquement les versions majeure et secondaire de la version du framework. Pour obtenir la liste des versions et des TensorFlow versions d'Apache MXNet prises en chargePyTorch, consultez la section Frameworks pris en charge.

Pour importer un modèle, utilisez la import-raw-model commande CLI de l'application AWS Panorama. Si vous apportez des modifications au modèle ou à son descripteur, vous devez réexécuter cette commande pour mettre à jour les ressources de l'application. Pour plus d'informations, veuillez consulter Changer le modèle de vision par ordinateur.

Pour le schéma JSON du fichier descripteur, voir AssetDescriptor.schema.json.

Entraînement de modèles

Lorsque vous entraînez un modèle, utilisez des images provenant de l'environnement cible ou d'un environnement de test qui ressemble étroitement à l'environnement cible. Tenez compte des facteurs suivants qui peuvent affecter les performances du modèle :

• Éclairage : la quantité de lumière réfléchie par un sujet détermine le niveau de détail que le modèle doit analyser. Un modèle entraîné avec des images de sujets bien éclairés peut ne pas fonctionner correctement dans un environnement faiblement éclairé ou à contre-jour.

• Résolution : la taille d'entrée d'un modèle est généralement fixée à une résolution comprise entre 224 et 512 pixels de large dans un format carré. Avant de transmettre une image vidéo au modèle, vous pouvez la réduire ou la recadrer pour l'adapter à la taille requise.

• Distorsion de l'image : la distance focale et la forme de l'objectif d'un appareil photo peuvent entraîner une distorsion des images loin du centre du cadre. La position d'une caméra détermine également quelles caractéristiques d'un sujet sont visibles. Par exemple, une caméra aérienne équipée d'un objectif grand angle affichera le haut d'un sujet lorsque celui-ci se trouve au centre du cadre, et une vue oblique du côté du sujet lorsqu'il s'éloigne du centre.

Pour résoudre ces problèmes, vous pouvez prétraiter les images avant de les envoyer au modèle et entraîner le modèle sur une plus grande variété d'images qui reflètent les variations dans des environnements réels. Si un modèle doit fonctionner dans des conditions d'éclairage et avec diverses caméras, vous avez besoin de plus de données pour l'entraînement. En plus de collecter davantage d'images, vous pouvez obtenir davantage de données d'entraînement en créant des variations de vos images existantes qui sont asymétriques ou présentent un éclairage différent.