Desarrollo de aplicaciones de AWS Panorama

Puede utilizar la aplicación de muestra de para obtener información sobre la estructura de la aplicación de AWS Panorama y como punto de partida para su propia aplicación.

El siguiente diagrama muestra los componentes principales de la aplicación que se ejecuta en un dispositivo de AWS Panorama. El código de la aplicación utiliza el SDK de aplicaciones de AWS Panorama para obtener imágenes e interactuar con el modelo, al que no tiene acceso directo. La aplicación envía vídeo a una pantalla conectada, pero no envía datos de imagen fuera de la red local.

En este ejemplo, la aplicación utiliza el SDK de aplicaciones de AWS Panorama para obtener fotogramas de vídeo de una cámara, preprocesar los datos de vídeo y enviar los datos a un modelo de visión artificial que detecta objetos. La aplicación muestra el resultado en una pantalla HDMI conectada al dispositivo.

El manifiesto de la aplicación

El manifiesto de la aplicación es un archivo cuyo nombre es graph.json en la carpeta graphs. El manifiesto define los componentes de la aplicación, que son paquetes, nodos y periferias.

Los paquetes son archivos de código, configuración y binarios para el código, los modelos, las cámaras y las pantallas de la aplicación. La aplicación de muestra utiliza 4 paquetes:

        "packages": [
            {
                "name": "123456789012::SAMPLE_CODE",
                "version": "1.0"
            },
            {
                "name": "123456789012::SQUEEZENET_PYTORCH_V1",
                "version": "1.0"
            },
            {
                "name": "panorama::abstract_rtsp_media_source",
                "version": "1.0"
            },
            {
                "name": "panorama::hdmi_data_sink",
                "version": "1.0"
            }
        ],

Los dos primeros paquetes se definen dentro de la aplicación, en el directorio packages. Contienen el código y el modelo específicos de esta aplicación. Los dos segundos paquetes son paquetes genéricos de cámara y pantalla proporcionados por el servicio AWS Panorama. El paquete abstract_rtsp_media_source es un marcador de posición para una cámara que usted puede anular durante la implementación. El paquete hdmi_data_sink representa el conector de salida HDMI del dispositivo.

Los nodos son interfaces de paquetes, así como parámetros ajenos al paquete que pueden tener valores predeterminados que se anulan en el momento de la implementación. Los paquetes de código y modelo definen las interfaces en los archivos package.json que especifican las entradas y las salidas, que pueden ser transmisiones de vídeo o un tipo de datos básico, como un float, un booleano o una cadena.

Por ejemplo, el nodo code_node hace referencia a una interfaz del paquete SAMPLE_CODE.

        "nodes": [
            {
                "name": "code_node",
                "interface": "123456789012::SAMPLE_CODE.interface",
                "overridable": false,
                "launch": "onAppStart"
            },

Esta interfaz se define en el archivo de configuración del paquete, package.json. La interfaz especifica que el paquete es de lógica empresarial y que toma como entradas una secuencia de vídeo denominada video_in y un número de coma flotante denominado threshold. La interfaz también especifica que el código requiere un búfer de flujo de vídeo denominado video_out para enviar el vídeo a una pantalla

{
    "nodePackage": {
        "envelopeVersion": "2021-01-01",
        "name": "SAMPLE_CODE",
        "version": "1.0",
        "description": "Computer vision application code.",
        "assets": [],
        "interfaces": [
            {
                "name": "interface",
                "category": "business_logic",
                "asset": "code_asset",
                "inputs": [
                    {
                        "name": "video_in",
                        "type": "media"
                    },
                    {
                        "name": "threshold",
                        "type": "float32"
                    }
                ],
                "outputs": [
                    {
                        "description": "Video stream output",
                        "name": "video_out",
                        "type": "media"
                    }
                ]
            }
        ]
    }
}

Volviendo al manifiesto de la aplicación, el nodo camera_node representa una transmisión de vídeo de una cámara. Incluye un decorador que aparece en la consola cuando despliegue la aplicación y le pide que seleccione una secuencia de cámara.

            {
                "name": "camera_node",
                "interface": "panorama::abstract_rtsp_media_source.rtsp_v1_interface",
                "overridable": true,
                "launch": "onAppStart",
                "decorator": {
                    "title": "Camera",
                    "description": "Choose a camera stream."
                }
            },

Un nodo de parámetros, threshold_param, define el parámetro de umbral de confianza utilizado por el código de la aplicación. Tiene un valor predeterminado de 60 y se puede anular durante la implementación.

            {
                "name": "threshold_param",
                "interface": "float32",
                "value": 60.0,
                "overridable": true,
                "decorator": {
                    "title": "Confidence threshold",
                    "description": "The minimum confidence for a classification to be recorded."
                }
            }

La sección final del manifiesto de la aplicación, edges, establece conexiones entre nodos. El flujo de vídeo de la cámara y el parámetro de umbral se conectan a la entrada del nodo de código, y la salida de vídeo del nodo de código se conecta a la pantalla.

        "edges": [
            {
                "producer": "camera_node.video_out",
                "consumer": "code_node.video_in"
            },
            {
                "producer": "code_node.video_out",
                "consumer": "output_node.video_in"
            },
            {
                "producer": "threshold_param",
                "consumer": "code_node.threshold"
            }
        ]

Crear con la aplicación de muestra

Puede utilizar la aplicación de muestra como punto de partida para su propia aplicación.

El nombre de cada paquete debe ser exclusivo de su cuenta. Si tanto usted como otro usuario de su cuenta utilizan un nombre de paquete genérico, por ejemplo code o model, es posible que obtengan una versión incorrecta del paquete cuando lo desplieguen. Cambie el nombre del paquete de códigos por uno que represente su aplicación.

Cambiar el modelo de visión artificial

La aplicación de muestra incluye un modelo de visión artificial. Para usar su propio modelo, modifique la configuración del nodo del modelo y utilice la CLI de la aplicación de AWS Panorama para importarlo como un activo.

El siguiente ejemplo usa un modelo ResNet50 de SSD MXNet que puedes descargar del repositorio de GitHub de esta guía: ssd_512_resnet50_v1_voc.tar.gz

Preprocesamiento de imágenes

Antes de enviar una imagen al modelo, la prepara para la inferencia redimensionándola y normalizando los datos de color. El modelo que utiliza la aplicación requiere una imagen de 224 x 224 píxeles con tres canales de color, para que coincida con el número de entradas de su primera capa. La aplicación ajusta cada valor de color convirtiéndolo en un número entre 0 y 1, restando el valor promedio de ese color y dividiéndolo por la desviación estándar. Finalmente, combina los canales de color y los convierte en una matriz NumPy que el modelo puede procesar.

    def preprocess(self, img, width):
        resized = cv2.resize(img, (width, width))
        mean = [0.485, 0.456, 0.406]
        std = [0.229, 0.224, 0.225]
        img = resized.astype(np.float32) / 255.
        img_a = img[:, :, 0]
        img_b = img[:, :, 1]
        img_c = img[:, :, 2]
        # Normalize data in each channel
        img_a = (img_a - mean[0]) / std[0]
        img_b = (img_b - mean[1]) / std[1]
        img_c = (img_c - mean[2]) / std[2]
        # Put the channels back together
        x1 = [[[], [], []]]
        x1[0][0] = img_a
        x1[0][1] = img_b
        x1[0][2] = img_c
        return np.asarray(x1)

Este proceso proporciona al modelo valores en un rango predecible centrado alrededor de 0. Coincide con el preprocesamiento aplicado a las imágenes del conjunto de datos de entrenamiento, que es un enfoque estándar, pero puede variar según el modelo.

Carga de métricas con el SDK para Python

La aplicación de muestra usa el SDK para Python para cargar métricas en Amazon CloudWatch.

    def process_streams(self):
        """Processes one frame of video from one or more video streams."""
        ...
            logger.info('epoch length: {:.3f} s ({:.3f} FPS)'.format(epoch_time, epoch_fps))
            logger.info('avg inference time: {:.3f} ms'.format(avg_inference_time))
            logger.info('max inference time: {:.3f} ms'.format(max_inference_time))
            logger.info('avg frame processing time: {:.3f} ms'.format(avg_frame_processing_time))
            logger.info('max frame processing time: {:.3f} ms'.format(max_frame_processing_time))
            self.inference_time_ms = 0
            self.inference_time_max = 0
            self.frame_time_ms = 0
            self.frame_time_max = 0
            self.epoch_start = time.time()
            self.put_metric_data('AverageInferenceTime', avg_inference_time)
            self.put_metric_data('AverageFrameProcessingTime', avg_frame_processing_time)
 
    def put_metric_data(self, metric_name, metric_value):
        """Sends a performance metric to CloudWatch."""
        namespace = 'AWSPanoramaApplication'
        dimension_name = 'Application Name'
        dimension_value = 'aws-panorama-sample'
        try:
            metric = self.cloudwatch.Metric(namespace, metric_name)
            metric.put_data(
                Namespace=namespace,
                MetricData=[{
                    'MetricName': metric_name,
                    'Value': metric_value,
                    'Unit': 'Milliseconds',
                    'Dimensions': [
                        {
                            'Name': dimension_name,
                            'Value': dimension_value
                        },
                        {
                            'Name': 'Device ID',
                            'Value': self.device_id
                        }
                    ]
                }]
            )
            logger.info("Put data for metric %s.%s", namespace, metric_name)
        except ClientError:
            logger.warning("Couldn't put data for metric %s.%s", namespace, metric_name)
        except AttributeError:
            logger.warning("CloudWatch client is not available.")

Obtiene el permiso de un rol de tiempo de ejecución que usted asigna durante la implementación. El rol se define en la plantilla aws-panorama-sample.yml AWS CloudFormation.

Resources:
  runtimeRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: "2012-10-17"
        Statement:
          -
            Effect: Allow
            Principal:
              Service:
                - panorama.amazonaws.com
            Action:
              - sts:AssumeRole
      Policies:
        - PolicyName: cloudwatch-putmetrics
          PolicyDocument:
            Version: 2012-10-17
            Statement:
              - Effect: Allow
                Action: 'cloudwatch:PutMetricData'
                Resource: '*'
      Path: /service-role/

La aplicación de muestra instala el SDK para Python y otras dependencias con pip. Al crear el contenedor de aplicaciones, Dockerfile ejecuta comandos para instalar bibliotecas sobre lo que viene con la imagen base.

FROM public.ecr.aws/panorama/panorama-application
WORKDIR /panorama
COPY . .
RUN pip install --no-cache-dir --upgrade pip && \
    pip install --no-cache-dir -r requirements.txt

Para usar el SDK de AWS en el código de la aplicación, primero modifique la plantilla para añadir permisos a todas las acciones de la API que utilice la aplicación. Actualice la pila AWS CloudFormation ejecutando 1-create-role.sh cada vez que realice un cambio. Luego, implemente los cambios en el código de su aplicación.

En el caso de las acciones que modifican o utilizan los recursos existentes, se recomienda minimizar el alcance de esta política especificando un nombre o patrón para el objetivo Resource en una declaración aparte. Para obtener información sobre las acciones y los recursos que admite cada servicio, consulte Acciones, recursos y claves de condiciones en la Referencia de autorización de servicios

Pasos siguientes

Para obtener instrucciones sobre el uso de la CLI de aplicaciones de AWS Panorama para crear aplicaciones y paquetes desde cero, consulte el README de la CLI.

Para obtener más código de muestra y una utilidad de prueba que pueda usar para validar el código de la aplicación antes de la implementación, visite el repositorio de muestras de AWS Panorama.