Proyecto 1 de conducción autónoma - detección de objetos en entorno urbano

1. Introducción del proyecto

En este proyecto, se creará una red neuronal convolucional para detectar y clasificar objetos utilizando el conjunto de datos de Waymo. Se le proporcionará un conjunto de datos de imágenes de entornos urbanos con ciclistas, peatones y vehículos etiquetados.

En primer lugar, se realiza un extenso análisis de datos, incluido el cálculo de las distribuciones de etiquetas, la visualización de imágenes de muestra y la comprobación de la oclusión de objetos.

                           Ejemplo de imágenes nocturnas del conjunto de datos de Waymo, con anotaciones para vehículos y peatones

Utilice este análisis para decidir qué aumentos tienen sentido para este proyecto; luego, entrene una red neuronal para detectar y clasificar objetos.

Usa TensorBoard para monitorear el entrenamiento y decidir cuándo termina. Finalmente, experimente con diferentes hiperparámetros para mejorar el rendimiento del modelo.

Este proyecto incluirá el uso de la API de detección de objetos de TensorFlow (API de detección de objetos de TensorFlow), donde el modelo se puede implementar para obtener predicciones sobre las imágenes enviadas a la API; y se proporcionará el código relacionado para crear videos cortos de las predicciones del modelo.

2. Configuración del entorno

crear proyecto

Configuración local : use las instrucciones a continuación para crear un contenedor de Docker con una GPU local o cree un entorno similar en la instancia de GPU de un proveedor de la nube.

archivos de proyecto

Primero, obtenga los archivos del proyecto del repositorio de Github asociado ( https://github.com/udacity/nd013-c1-vision-starter )
.

Instalación de la ventana acoplable

Para instalaciones locales, si tiene su propia GPU Nvidia, puede usar el Dockerfile y los requisitos proporcionados en el directorio de compilación del código de inicio.

Las instrucciones a continuación también se incluyen en el directorio de compilación del código de inicio.

necesidad

• GPU NVIDIA con los últimos controladores instalados
• Docker / nvidia-docker

Construir

Usa el siguiente comando:

docker build -t project-dev -f Dockerfile .

Crear un contenedor:

docker run --gpus all -v <PATH TO LOCAL PROJECT FOLDER>:/app/project/ --network=host -ti project-dev bash

y cualquier otra marca útil para el sistema (por ejemplo, --shm-size ).

configuración

Una vez dentro del contenedor, se debe instalar gsutil ejecutando:

Rizo https://sdk.cloud.google.com | intento

Una vez que gsutil esté instalado y agregado a su ruta, puede verificarlo con:

gcloud auth login

Depurar (Depurar)

• Si tiene problemas para instalar la API de detección de objetos de TF (API de detección de objetos de TF), siga este tutorial Instalación: documentación del tutorial de la API de detección de objetos de TensorFlow 2 .

3. Descripción del proyecto

Detección de objetos en entornos urbanos ( GitHub - udacity/nd013-c1-vision-starter: código de inicio para el proyecto del curso 1 del programa de nanogrado para ingenieros de vehículos autónomos de Udacity )

configuraciones locales

Para la instalación local, si tiene su propia GPU Nvidia, puede usar el Dockerfile y los requisitos proporcionados en el directorio de compilación (https://github.com/udacity/nd013-c1-vision-starter/tree/main/build ).

Siga el archivo LÉAME ( nd013-c1-vision-starter/build/README.md en main udacity/nd013-c1-vision-starter GitHub ) para crear un contenedor docker e instalar todos los requisitos previos.

Descargar y procesar datos

Para este proyecto, utilizaremos datos del  conjunto de datos de Waymo Open .

Estos archivos se pueden descargar directamente desde el sitio web como un archivo tar o desde  Google Cloud Bucket como  registros tf  individuales .

El primer objetivo de este proyecto es descargar datos de Google Cloud Storage de Waymo a una máquina local. Para este proyecto, solo necesitamos proporcionar un subconjunto de los datos (por ejemplo, no es necesario usar datos Lidar). Por lo tanto, descargaremos y recortaremos cada archivo de inmediato. , consulte la función create_tf_example, que realizará este procesamiento. Esta función obtiene el componente de registro de Waymo Tf y lo guarda en formato de api de detección de objetos Tf (api de detección de objetos Tf). A continuación, se describe un ejemplo de una función de este tipo ( Entrenamiento del detector de objetos personalizados: documentación del tutorial de la API de detección de objetos de TensorFlow 2 ) . Hemos proporcionado los documentos.在download_process.pylabel_map.pbtxt 

El comando para ejecutar el script es el siguiente:

python download_process.py --data_dir {processed_file_location} --size {number of files you want to download}

¡Descargue 100 archivos (a menos que se cambie el parámetro de tamaño) Después de que finalice el script, puede verificar la carpeta data_dir para ver si los archivos se descargaron y procesaron correctamente.

estructura

datos

Los datos que se utilizarán para el entrenamiento, la validación y las pruebas se pueden organizar de la siguiente manera:

• entrenar : contiene datos de entrenamiento
• val : contiene datos de validación
• prueba  : contiene archivos de prueba para probar el modelo y crear videos de inferencia

Al completar y ejecutar el archivo create_split.py, los datos descargados se dividirán en conjuntos de entrenamiento, validación y prueba.

experimento

Las carpetas de experimentos se organizarán de la siguiente manera:

experiments/ 
    - pretrained_model/ 
    - exporter_main_v2.py 
    - to create an inference model 
    - model_main_tf2.py 
    - to launch training 
    - reference/ 
    - reference training with the unchanged config file 
    - experiment0/ 
    - create a new folder for each experiment you run 
    - experiment1/ 
    - create a new folder for each experiment you run 
    - experiment2/ 
    - create a new folder for each experiment you run 
    - label_map.pbtxt 
    ...

guía

---

Paso 1a - Análisis de datos exploratorios (EDA)

Explore conjuntos de datos usando datos que ya están en el directorio /home/workspace/data/ Esta es la tarea más importante en cualquier proyecto de aprendizaje automático.

• Implemente la función display_images en el cuaderno de análisis de datos exploratorios. La salida de esta función se muestra en la siguiente figura:

                                  Salida esperada de la función display_images

• EDA adicional : siéntase libre de pasar más tiempo explorando los datos y reportando sus hallazgos. Informe cualquier cosa relacionada con el conjunto de datos en el informe escrito.

Consulte este análisis para crear diferentes pruebas (conjuntos de entrenamiento y validación).

Paso 1b: crear una división de validación de trenes

Discutimos la validación cruzada y la importancia de crear divisiones significativas de capacitación y validación. Para este proyecto, los conjuntos de entrenamiento, validación y prueba relevantes deben crearse utilizando archivos ubicados en /home/workspace/data/. La función de división en el archivo create_split.py hace lo siguiente:

• Cree tres subcarpetas: /home/workspace/data/train/, /home/workspace/data/val/ y /home/workspace/data/test/

• Divida los archivos de grabación tf en estas tres carpetas.

Después de implementar la función, ejecute el script con el siguiente comando:

python create_splits.py --data-dir /home/workspace/data

También puede usar cualquier otro método para dividir los datos en entrenamiento, validación y prueba.

Paso 2: edite el archivo de configuración

Ahora puede comenzar a entrenar, la API de detección de objetos Tf depende del archivo de configuración. La configuración utilizada en este proyecto es pipeline.config, configurada para un dispositivo SSD Resnet 50 640x640. Puede obtener más información sobre los detectores de disparo único aquí ( https://arxiv.org/pdf/1512.02325.pdf ) .

• Primero, descarguemos el modelo preentrenado ( http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_resnet50_v1_fpn_640x640_coco17_tpu-8.tar.gz ) y muévalo a /home/workspace/experiments/pretrained_model/. Siga los pasos a continuación:

cd /home/workspace/experiments/pretrained_model/ 
wget http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_resnet50_v1_fpn_640x640_coco17_tpu-8.tar.gz 
tar -xvzf ssd_resnet50_v1_fpn_640x640_coco17_tpu-8.tar.gz 
rm -rf ssd_resnet50_v1_fpn_640x640_coco17_tpu-8.tar.gz

• Necesitamos editar el archivo de configuración para cambiar la ubicación de los archivos de entrenamiento y validación, así como la ubicación del archivo label_map para los pesos preentrenados. También necesitamos ajustar el tamaño del lote. Para hacer esto, ejecute el siguiente comando:

cd /home/workspace/ 
python edit_config.py --train_dir /home/workspace/data/train/ --eval_dir /home/workspace/data/val/ --batch_size 2 --checkpoint /home/workspace/experiments/pretrained_model/ssd_resnet50_v1_fpn_640x640_coco17_tpu-8/checkpoint/ckpt-0 --label_map /home/workspace/experiments/label_map.pbtxt

Se creará un nuevo archivo de configuración denominado pipeline_new.config en el directorio /home/workspace/. Mueva el archivo al directorio /home/workspace/experiments/reference/.

​Paso 3 - Capacitación y evaluación del modelo

Inicie el proceso de formación:

• Proceso de entrenamiento:

python experiments/model_main_tf2.py --model_dir=experiments/reference/ --pipeline_config_path=experiments/reference/pipeline_new.config

Para monitorear el entrenamiento, inicie una instancia de tensorboard ejecutando python -m tensorboard.main --logdir experiments/reference/ . Comunique sus hallazgos en un informe escrito. El registro se muestra en la siguiente figura:

                                                 Registro de entrenamiento de Tensorboard

Después de la capacitación, inicie el proceso de evaluación. Iniciar el proceso de evaluación en paralelo con el proceso de capacitación provocará errores OOM en el espacio de trabajo.

• Proceso de evaluación:

python experiments/model_main_tf2.py --model_dir=experiments/reference/ --pipeline_config_path=experiments/reference/pipeline_new.config --checkpoint_dir=experiments/reference/

De forma predeterminada, el script de evaluación solo se ejecuta durante una época. Por lo tanto, el registro de evaluación en Tensorboard se verá como un punto azul.

Nota: Ambos procesos mostrarán algunas advertencias de Tensorflow, que se pueden ignorar. Es posible que deba finalizar manualmente el script de evaluación con CTRL+C.

Paso 4: mejora el rendimiento

Lo más probable es que este experimento inicial no haya dado los mejores resultados. Sin embargo, puede realizar varios cambios en el archivo de configuración para mejorar este modelo.

• Un cambio obvio es la estrategia mejorada de aumento de datos. El archivo preprocessor.proto ( https://github.com/tensorflow/models/blob/master/research/object_detection/protos/preprocessor.proto ) contiene los diferentes métodos de aumento de datos disponibles en la API de detección de objetos Tf. Para ayudar a visualizar estas mejoras, se proporciona un cuaderno: Explorar Augments.ipynb. Usando el cuaderno, pruebe diferentes combinaciones de aumentos de datos y elija la que crea que funciona mejor para su conjunto de datos. Justifique su elección en una declaración escrita.

• Tenga en cuenta que los siguientes también están disponibles:

  • Experimente con optimizadores: tipos de optimizadores, tasas de aprendizaje, planificadores, etc.
  • Experimenta con la arquitectura. El modelo zoológico de API de detección de objetos Tf ( https://github.com/tensorflow/models/blob/master/research/object_detection/g3doc/tf2_detection_zoo.md ) proporciona muchas arquitecturas. Recuerde que el archivo pipeline.config es único para cada arquitectura y debe editarlo.

Crear videos animados

Exportar el modelo entrenado

Modifique los parámetros de las siguientes funciones para adaptarlos a su modelo:

python experiments/exporter_main_v2.py --input_type image_tensor --pipeline_config_path experiments/reference/pipeline_new.config --trained_checkpoint_dir experiments/reference/ --output_directory experiments/reference/exported/

Esto creará una nueva carpeta experimentos/referencia/exportado/modelo_guardado. Puede leer más sobre el formato de modelo guardado de Tensorflow aquí ( https://www.tensorflow.org/guide/saved_model ) .

Finalmente, se puede crear un video de inferencia del modelo para cualquier archivo de registro tf. Para hacer esto, ejecute el siguiente comando (modifíquelo en su archivo):

python inference_video.py --labelmap_path label_map.pbtxt --model_path experiments/reference/exported/saved_model --tf_record_path data/test/segment-12200383401366682847_2552_140_2572_140_with_camera_labels.tfrecord --config_path experiments/reference/pipeline_new.config --output_path animation.gif

enviar plantilla

Descripción del proyecto

Esta sección debe contener una breve descripción del proyecto y lo que estamos tratando de lograr. ¿Por qué la detección de objetos es una parte importante de los sistemas de vehículos autónomos?

configuración

Esta sección debe contener una breve descripción de los pasos que debe seguir para ejecutar el código desde este repositorio.

conjunto de datos

Análisis de conjuntos de datos

Esta sección debe contener una descripción cuantitativa y cualitativa del conjunto de datos. Debe incluir imágenes, gráficos y otras visualizaciones.

Validación cruzada

Esta sección debe detallar la estrategia de validación cruzada y justificar su enfoque.

tren

experimento de referencia

Esta sección debe detallar los resultados de los experimentos de referencia. Debe incluir métricas de entrenamiento y explicaciones detalladas del rendimiento del algoritmo.

mejorar la referencia

Esta sección destacará las diferentes estrategias que puede emplear para mejorar su modelo. Debe contener datos relevantes y detalles sobre sus hallazgos.

Código de referencia---

GitHub - jeffnd/nd013-c1-vision-starter: código de inicio para el proyecto del curso 1 del programa de nanogrados para ingenieros de vehículos autónomos de Udacity