Protegiendo a las personas de áreas peligrosas a través de límites virtuales con Computer Vision

A medida que las empresas dan la bienvenida a más robots autónomos y otros equipos pesados ​​al lugar de trabajo, debemos asegurarnos de que los equipos puedan funcionar de manera segura alrededor de compañeros humanos. En esta publicación, le mostraremos cómo construir un límite virtual con visión por computadora y Lente profunda de AWS, la cámara de video habilitada para aprendizaje profundo de AWS diseñada para que los desarrolladores aprendan el aprendizaje automático (ML). Con las técnicas de aprendizaje automático de esta publicación, puede crear límites virtuales para áreas restringidas que apagan automáticamente el equipo o emiten una alerta cuando los humanos se acercan.

Para este proyecto, entrenará un modelo de detección de objetos personalizado con Amazon SageMaker e implementar el modelo en un dispositivo AWS DeepLens. La detección de objetos es un algoritmo ML que toma una imagen como entrada e identifica los objetos y su ubicación dentro de la imagen. Además de las soluciones de límites virtuales, puede aplicar las técnicas aprendidas en esta publicación cuando necesite detectar dónde están ciertos objetos dentro de una imagen o contar la cantidad de instancias de un objeto deseado en una imagen, como contar elementos en un contenedor de almacenamiento o en un estante minorista.

Resumen de la solución

El tutorial incluye los siguientes pasos:

1. Prepare su conjunto de datos para incorporarlo a un algoritmo de AA.
2. Entrene un modelo con Amazon SageMaker.
3. Modelo de prueba con zonas de restricción personalizadas.
4. Implemente la solución en AWS DeepLens.

También discutimos otros casos de uso del mundo real en los que puede aplicar esta solución.

El siguiente diagrama ilustra la arquitectura de la solución.

Requisitos previos

Para completar este tutorial, debe tener los siguientes requisitos previos:

Prepare su conjunto de datos para incorporarlo a un algoritmo de AA

Esta publicación utiliza un algoritmo ML llamado modelo de detección de objetos para crear una solución que detecta si una persona se encuentra en una zona restringida personalizada. Usas el disponible públicamente Conjunto de datos de detección de peatones disponible en Kaggle, que tiene más de 2,000 imágenes. Este conjunto de datos tiene etiquetas para objetos humanos y similares a los humanos (como maniquíes) para que el modelo entrenado pueda distinguir con mayor precisión entre humanos reales y estatuas o accesorios de cartón.

Por ejemplo, las siguientes imágenes son ejemplos de la detección de un trabajador de la construcción y si están en la zona de restricción personalizada (contorno rojo).

Para comenzar a entrenar su modelo, primero crea un bucket de S3 para almacenar los datos de entrenamiento y la salida del modelo. Para los proyectos de AWS DeepLens, los nombres de los depósitos de S3 deben comenzar con el prefijo deeplens-. Utiliza estos datos para entrenar un modelo con SageMaker, un servicio completamente administrado que brinda la capacidad de construir, entrenar e implementar modelos de ML rápidamente.

Entrene un modelo con Amazon SageMaker

Utiliza los cuadernos de SageMaker Jupyter como entorno de desarrollo para entrenar el modelo. Jupyter Notebook es una aplicación web de código abierto que le permite crear y compartir documentos que contienen código en vivo, ecuaciones, visualizaciones y texto narrativo. Para esta publicación, proporcionamos Train_Object_Detection_People_DeepLens.ipynb, un cuaderno completo para que lo sigas.

Para crear un modelo de detección de objetos personalizado, debe utilizar una instancia de trabajo de entrenamiento habilitada para la unidad de procesamiento gráfico (GPU). Las GPU son excelentes para paralelizar los cálculos necesarios para entrenar una red neuronal. Aunque el cuaderno en sí es una única instancia ml.t2.medium, el trabajo de entrenamiento usa específicamente una instancia ml.p2.xlarge. Para acceder a una instancia de trabajo de entrenamiento habilitada para GPU, debe enviar una solicitud para un aumento del límite de servicio al Centro de soporte de AWS.

Después de recibir el aumento de su límite, complete los siguientes pasos para crear una instancia de cuaderno de SageMaker:

1. En la consola de SageMaker, elija Instancias de cuaderno.
2. Elige Crear instancia de cuaderno.
3. Nombre de instancia de cuaderno, ingrese un nombre para su instancia de notebook.
4. Tipo de instancia, escoger t2.medio.

Este es el tipo de instancia menos costoso que admiten las instancias de notebook y es suficiente para este tutorial.

5. Rol de IAM, escoger Crear un nuevo rol.

Asegúrese de esto Gestión de identidades y accesos de AWS La función (IAM) tiene acceso al depósito de S3 que creó anteriormente (prefijo deeplens-).

6. Elige Crear instancia de cuaderno. La instancia de su cuaderno puede tardar un par de minutos en iniciarse.

7. Cuando el estado en la página de instancias del bloc de notas cambia a InService, elija Jupyter abierto para iniciar su instancia de notebook Jupyter recién creada.
8. Elige Subir para subir el Train_Object_Detection_people_DeepLens.ipynb archivo que descargó anteriormente.

9. Abra el cuaderno y sígalo hasta el final.
10. Si se le pregunta acerca de cómo configurar el kernel, seleccione conda_mxnet_p36.

El cuaderno de Jupyter contiene una combinación de texto y celdas de código. Para ejecutar un fragmento de código, elija la celda y presione Shift + Enter. Mientras la celda se está ejecutando, aparece un asterisco al lado de la celda. Cuando la celda está completa, un número de salida y una nueva celda de salida aparecen debajo de la celda original.

11. Descargue el conjunto de datos del depósito público de S3 en la instancia local de SageMaker y descomprima los datos. Esto se puede hacer siguiendo el código en el cuaderno:

     !aws s3 cp s3://deeplens-public/samples/pedestriansafety/humandetection_data.zip . !rm -rf humandetection/ !unzip humandetection_data.zip -d humandetection 

12. Convierta el conjunto de datos a un formato (GrabarIO) que se pueden introducir en el algoritmo de SageMaker:

     !python $mxnet_path/tools/im2rec.py --pass-through --pack-label $DATA_PATH/train_mask.lst $DATA_PATH/ !python $mxnet_path/tools/im2rec.py --pass-through --pack-label $DATA_PATH/val_mask.lst $DATA_PATH/ 

13. Transfiera los archivos RecordIO de nuevo a Amazon S3.

Ahora que ha terminado con toda la preparación de datos, está listo para entrenar el detector de objetos.

Hay muchos tipos diferentes de algoritmos de detección de objetos. Para esta publicación, usa el Algoritmo de detección de caja múltiple de disparo único (SSD). El algoritmo SSD tiene un buen equilibrio entre velocidad y precisión, lo que lo hace ideal para ejecutarse en dispositivos periféricos como AWS DeepLens.

Como parte del trabajo de entrenamiento, tiene muchas opciones para hiperparámetros que ayudan a configurar el comportamiento de entrenamiento (como el número de épocas, la tasa de aprendizaje, el tipo de optimizador y el tamaño de mini lotes). Los hiperparámetros le permiten ajustar la velocidad de entrenamiento y la precisión de su modelo. Para obtener más información sobre los hiperparámetros, consulte Algoritmo de detección de objetos.

15. Configure sus hiperparámetros y canales de datos. Considere usar la siguiente definición de ejemplo de hiperparámetros:

     od_model = sagemaker.estimator.Estimator(training_image, role, train_instance_count=1, train_instance_type='ml.p2.xlarge', train_volume_size = 50, train_max_run = 360000, input_mode= 'File', output_path=s3_output_location, sagemaker_session=sess) od_model.set_hyperparameters(base_network='resnet-50', use_pretrained_model=1, num_classes=2, mini_batch_size=32, epochs=100, learning_rate=0.003, lr_scheduler_step='3,6', lr_scheduler_factor=0.1, optimizer='sgd', momentum=0.9, weight_decay=0.0005, overlap_threshold=0.5, nms_threshold=0.45, image_shape=300, num_training_samples=n_train_samples) 

El cuaderno tiene algunos hiperparámetros predeterminados que se han preseleccionado. Para la detección de peatones, entrena el modelo durante 100 épocas. Este paso de entrenamiento debería tomar aproximadamente 2 horas usando una instancia ml.p2.xlarge. Puede experimentar con diferentes combinaciones de los hiperparámetros o entrenar para más épocas para mejorar el rendimiento. Para obtener información sobre los precios más recientes, consulte Precios de Amazon SageMaker.

16. Puede comenzar un trabajo de capacitación con una sola línea de código y monitorear la precisión a lo largo del tiempo en la consola de SageMaker:

    od_model.fit(inputs=data_channels, logs=True) 

Para obtener más información sobre cómo funciona la formación, consulte Creartrabajodeformación. El aprovisionamiento y la descarga de datos llevan tiempo, según el tamaño de los datos. Por lo tanto, es posible que pasen unos minutos antes de que comience a obtener registros de datos para sus trabajos de entrenamiento.

Puede monitorear el progreso de su trabajo de entrenamiento a través de la precisión media media métrica (mAP), que le permite monitorear la calidad de la capacidad del modelo para clasificar objetos y detectar los cuadros delimitadores correctos. Los registros de datos también imprimen el mapa de los datos de validación, entre otras pérdidas, para cada ejecución del conjunto de datos, una vez por una época. Esta métrica es un proxy de la calidad del rendimiento del algoritmo para detectar con precisión la clase y el cuadro delimitador preciso que la rodea.

Cuando finaliza el trabajo, puede encontrar los archivos de modelo entrenados en el depósito y la carpeta de S3 especificados anteriormente en s3_output_location:

s3_output_location = 's3://{}/{}/output'.format(BUCKET, PREFIX)

Para esta publicación, mostramos los resultados del conjunto de validación al completar la décima época y la centésima. Al final de la décima época, vemos una mAP de validación de aproximadamente 10, mientras que la 100ª época fue de aproximadamente 10.

Para lograr mejores resultados de detección, puede intentar ajustar los hiperparámetros utilizando la capacidad integrada en SageMaker para ajuste automático del modelo y entrenar el modelo para más épocas. Por lo general, dejas de entrenar cuando ves una disminución en la precisión.

Modelo de prueba con zonas de restricción personalizadas

Antes de implementar el modelo entrenado en AWS DeepLens, puede probarlo en la nube mediante un punto de enlace alojado en SageMaker. Un punto final de SageMaker es un servicio totalmente administrado que le permite realizar inferencias en tiempo real a través de una API REST. SageMaker le permite implementar rápidamente nuevos puntos finales para probar sus modelos, de modo que no tenga que alojar el modelo en la instancia local que se utilizó para entrenar el modelo. Esto le permite hacer predicciones (o inferencias) a partir del modelo en imágenes que el algoritmo no vio durante el entrenamiento.

No tiene que alojar en el mismo tipo de instancia que solía entrenar. La capacitación es un trabajo prolongado y con muchos recursos informáticos que requiere un conjunto diferente de requisitos informáticos y de memoria que el alojamiento no suele tener. Puede elegir cualquier tipo de instancia en la que desee alojar el modelo. En este caso, elegimos la instancia ml.p3.2xlarge para entrenar, pero elegimos alojar el modelo en la instancia de CPU menos costosa, ml.m4.xlarge. El siguiente fragmento de código muestra nuestra implementación de endpoints.

object_detector = od_model.deploy(initial_instance_count = 1, instance_type = 'ml.m4.xlarge') 

Detección en una zona de restricción personalizada (región de interés)

El formato de la salida se puede representar como [índice_clase, puntuación_confianza, xmin, ymin, xmax, ymax]. Las predicciones de baja confianza a menudo tienen mayores posibilidades de un falso positivo o falso negativo, por lo que probablemente debería descartar las predicciones de baja confianza. Puede utilizar el siguiente código para detectar si el cuadro delimitador de la persona se superpone con la zona restringida.

def inRestrictedSection(ImShape = None, R1 = None, restricted_region = None, kclass = None, score = None, threshold = None): statement = 'Person Not Detected in Restricted Zone' if (kclass == 1) and (score > threshold): Im1 = np.zeros((ImShape[0],ImShape[1],3), np.int32) cv2.fillPoly(Im1, [R1], 255) Im2 = np.zeros((ImShape[0],ImShape[1],3), np.int32) if restricted_region is None: restricted_region = np.array([[0,ImShape[0]],[ImShape[1],ImShape[0]],[ImShape[1],0], [0,0]], np.int32) cv2.fillPoly(Im2, [restricted_region], 255) Im = Im1 * Im2 if np.sum(np.greater(Im, 0))>0: statement = 'Person Detected in Restricted Zone' else: statement = statement return statement 

De forma predeterminada, el fotograma completo se evalúa para detectar la presencia humana. Sin embargo, puede especificar fácilmente la región de interés dentro de la cual la presencia de una persona se considera de alto riesgo. Si desea agregar una zona de restricción personalizada, agregue las coordenadas de los vértices de la región representada por [eje X, eje Y] y cree el polígono. Las coordenadas deben ingresarse en sentido horario o antihorario. Vea el siguiente código:

restricted_region = None #restricted_region = np.array([[0,200],[100,200],[100,0], [10,10]], np.int32) 

El siguiente código de muestra muestra a los peatones que se identifican dentro de una zona restringida:

file_name = 'humandetection/test_images/t1_image.jpg' img = cv2.imread(file_name) img =cv2.cvtColor(img,cv2.COLOR_BGR2RGB) thresh = 0.2 height = img.shape[0] width = img.shape[1] colors = dict() with open(file_name, 'rb') as image: f = image.read() b = bytearray(f) ne = open('n.txt','wb') ne.write(b) results = object_detector.predict(b, initial_args={'ContentType': 'image/jpeg'}) detections = json.loads(results) object_categories = ['no-person', 'person'] for det in detections['prediction']: (klass, score, x0, y0, x1, y1) = det if score < thresh: continue cls_id = int(klass) prob = score if cls_id not in colors: colors[cls_id] = (random.random(), random.random(), random.random()) xmin = int(x0 * width) ymin = int(y0 * height) xmax = int(x1 * width) ymax = int(y1 * height) R1 = np.array([[xmin,ymin],[xmax,ymin],[xmax,ymax], [xmin,ymax]], np.int32) cv2.polylines(img,[R1],True, (255,255,0), thickness = 5) cv2.polylines(img,[restricted_region],True, (255,0,0), thickness = 5) plt.imshow(img) print(inRestrictedSection(img.shape,R1 = R1, restricted_region= restricted_region, kclass = cls_id, score = prob, threshold=0.2)) 

Las siguientes imágenes muestran nuestros resultados.

Implemente la solución en AWS DeepLens

Convierta el modelo para la implementación en AWS DeepLens

Al implementar un modelo SSD entrenado por SageMaker en AWS DeepLens, primero debe ejecutar desplegar.py para convertir el artefacto del modelo en un modelo desplegable:

!rm -rf incubator-mxnet !git clone -b v1.7.x https://github.com/apache/incubator-mxnet MODEL_PATH = od_model.model_data TARGET_PATH ='s3://'+BUCKET+'/'+PREFIX+'/patched/' !rm -rf tmp && mkdir tmp rm -rf tmp && mkdir tmp !aws s3 cp $MODEL_PATH tmp !tar -xzvf tmp/model.tar.gz -C tmp !mv tmp/model_algo_1-0000.params tmp/ssd_resnet50_300-0000.params !mv tmp/model_algo_1-symbol.json tmp/ssd_resnet50_300-symbol.json !python incubator-mxnet/example/ssd/deploy.py --network resnet50 --data-shape 300 --num-class 2 --prefix tmp/ssd_ !tar -cvzf ./patched_model.tar.gz -C tmp ./deploy_ssd_resnet50_300-0000.params ./deploy_ssd_resnet50_300-symbol.json ./hyperparams.json !aws s3 cp patched_model.tar.gz $TARGET_PATH

Importe su modelo en AWS DeepLens

Para ejecutar el modelo en un dispositivo AWS DeepLens, debe crear un proyecto de AWS DeepLens. Empiece por importar su modelo a AWS DeepLens.

1. En la consola de AWS DeepLens, debajo de Recursos, escoger fexibles.
2. Elige Modelo de importación.

3. Fuente de importación, seleccione Modelo entrenado externamente.
4. Ingrese la ubicación de Amazon S3 del modelo parcheado que guardó al ejecutar deploy.py en el paso anterior.
5. Marco modelo, escoger MXNet.
6. Elige Modelo de importación.

Crear la función de inferencia

La función de inferencia alimenta cada fotograma de la cámara al modelo para obtener predicciones y ejecuta cualquier lógica comercial personalizada sobre el uso de los resultados de la inferencia. Tu usas AWS Lambda para crear una función que implemente en AWS DeepLens. La función ejecuta la inferencia localmente en el dispositivo AWS DeepLens.

Primero, necesitamos crear una función Lambda para implementar en AWS DeepLens.

1. Descargue nuestra función Lambda de inferencia.
2. En la consola Lambda, elija Clave.
3. Elige Crear función.
4. Seleccione Autor desde cero.
5. Nombre de la función, ingresa un nombre.
6. Runtime, escoger 3.7 Python.
7. Elegir o crear un rol de ejecución, escoger Use un rol existente.
8. Elige service-role / AWSDeepLensLambdaRole.
9. Elige Crear función.

10. En la página de detalles de la función, en el Acciones menú, seleccione Subir un archivo .zip.

11. Cargar la inferencia Lambda archivo que descargó anteriormente.
12. Elige Guardar para guardar el código que ingresó.
13. En Acciones menú, seleccione Publicar nueva versión.

La publicación de la función la hace disponible en la consola de AWS DeepLens para que pueda agregarla a su proyecto personalizado.

14. Ingrese un número de versión y elija Publicar.

Entendiendo la función de inferencia

Esta sección lo guía a través de algunas partes importantes de la función de inferencia. Primero, debes prestar atención a dos archivos específicos:

• etiquetas.txt - Contiene un mapeo de la salida de la red neuronal (números enteros) a etiquetas legibles por humanos (cadena)
• función_lambda.py - Contiene código para la función que se llama para generar predicciones en cada cuadro de la cámara y enviar resultados

En lambda_function.py, primero carga y optimiza el modelo. En comparación con las máquinas virtuales en la nube con GPU, AWS DeepLens tiene menos potencia informática. AWS DeepLens utiliza el optimizador de modelos Intel OpenVino para optimizar el modelo entrenado en SageMaker para que se ejecute en su hardware. El siguiente código optimiza su modelo para ejecutarse localmente:

client.publish(topic=iot_topic, payload='Optimizing model...') ret, model_path = mo.optimize('deploy_ssd_resnet50_300', INPUT_W, INPUT_H) # Load the model onto the GPU. client.publish(topic=iot_topic, payload='Loading model...') model = awscam.Model(model_path, {'GPU': 1}) 

Luego, ejecuta el modelo cuadro por cuadro sobre las imágenes de la cámara. Ver el siguiente código:

while True: # Get a frame from the video stream ret, frame = awscam.getLastFrame() if not ret: raise Exception('Failed to get frame from the stream') # Resize frame to the same size as the training set. frame_resize = cv2.resize(frame, (INPUT_H, INPUT_W)) # Run the images through the inference engine and parse the results using # the parser API, note it is possible to get the output of doInference # and do the parsing manually, but since it is a ssd model, # a simple API is provided. parsed_inference_results = model.parseResult(model_type, model.doInference(frame_resize)) 

Finalmente, envía los resultados de la predicción de texto a la nube. Ver los resultados de texto en la nube es una forma conveniente de asegurarse de que el modelo esté funcionando correctamente. Cada dispositivo AWS DeepLens tiene un iot_topic dedicado creado automáticamente para recibir los resultados de la inferencia. Vea el siguiente código:

# Send results to the cloud client.publish(topic=iot_topic, payload=json.dumps(cloud_output)) 

Cree un proyecto personalizado de AWS DeepLens

Para crear un nuevo proyecto de AWS DeepLens, complete los siguientes pasos:

1. En la consola de AWS DeepLens, en la Proyectos página, elige Crear proyecto.
2. Tipo de proyecto, seleccione Crea un nuevo proyecto en blanco.
3. Elige Siguiente.

4. Nombra tu proyecto yourname-pedestrian-detector-.
5. Elige Agregar modelo.
6. Seleccione el modelo que acaba de crear.
7. Elige Añadir función.
8. Busque la función Lambda que creó anteriormente por nombre.
9. Elige Crear proyecto.
10. En Proyectos página, seleccione el proyecto que desea implementar.
11. Elija Implementar en dispositivo.
12. Dispositivo de destino, elige tu dispositivo.
13. Elige Revisar.
14. Revise su configuración y elija Despliegue.

La implementación puede tardar hasta 10 minutos en completarse, según la velocidad de la red a la que esté conectado AWS DeepLens. Cuando se complete la implementación, debería ver un banner verde en la página con el mensaje "¡Felicitaciones, su modelo ahora se está ejecutando localmente en AWS DeepLens!"

Para ver la salida de texto, desplácese hacia abajo en la página de detalles del dispositivo hasta Salida del proyecto sección. Siga las instrucciones de la sección para copiar el tema y vaya al Núcleo de AWS IoT consola para suscribirse al tema. Debería ver los resultados como en la siguiente captura de pantalla.

Para obtener instrucciones paso a paso sobre cómo ver la transmisión de video o la salida de texto, consulte Visualización de resultados de AWS DeepLens.

Casos de uso en el mundo real.

Ahora que tiene predicciones de su modelo ejecutándose en AWS DeepLens, convierta esas predicciones en alertas e información. Algunos de los usos más comunes de un proyecto como este incluyen:

• Comprender cuántas personas en un día determinado ingresaron a una zona restringida para que los sitios de construcción puedan identificar los lugares que requieren más señales de seguridad. Esto se puede hacer recopilando los resultados y usándolos para crear un tablero usando Amazon QuickSight. Para obtener más detalles sobre la creación de un tablero con QuickSight, consulte Cree un rastreador de postura de trabajo desde casa con AWS DeepLens y GluonCV.
• Recopilar la salida de AWS DeepLens y configurar una Raspberry Pi para que suene una alerta cuando alguien ingrese a una zona restringida. Para obtener más detalles sobre cómo conectar un dispositivo AWS DeepLens a un dispositivo Raspberry Pi, consulte Creación de un clasificador de basura con AWS DeepLens.

Conclusión

En esta publicación, aprendió cómo entrenar un modelo de detección de objetos e implementarlo en AWS DeepLens para detectar personas que ingresan a zonas restringidas. Puede utilizar este tutorial como referencia para entrenar e implementar sus propios proyectos de detección de objetos personalizados en AWS DeepLens.

Para obtener un tutorial más detallado de este tutorial y otros tutoriales, ejemplos e ideas de proyectos con AWS DeepLens, consulte Recetas de AWS DeepLens.

Acerca de los autores

Yash Shah es científico de datos en el laboratorio de soluciones de Amazon ML, donde trabaja en una variedad de casos de uso de aprendizaje automático, desde la atención médica hasta la fabricación y el comercio minorista. Tiene experiencia formal en Factores Humanos y Estadísticas, y anteriormente fue parte del equipo de Amazon SCOT diseñando productos para guiar a los vendedores 3P con una gestión eficiente del inventario.

phu nguyen es Product Manager de AWS Panorama. Desarrolla productos que brindan a los desarrolladores de cualquier nivel de habilidad una introducción fácil y práctica al aprendizaje automático.

Fuente: https://aws.amazon.com/blogs/machine-learning/protecting-people-through-virtual-bo limits-computer-vision/