Redes Neurais em IA e Deep Learning - página 40

[MetaQuotes]

Hoja de ruta de visión artificial | Cómo convertirse en un ingeniero de visión por computadora

Hoja de ruta de visión artificial | Cómo convertirse en un ingeniero de visión por computadora

Este video proporciona una hoja de ruta para convertirse en ingeniero de visión por computadora, dividiendo el proceso de aprendizaje en cuatro módulos: Python y OpenCV, robótica y programación de bajo nivel, inteligencia artificial y temas avanzados. Se enfatiza la importancia de los proyectos prácticos que involucran dispositivos físicos como robótica y Arduinos, junto con la necesidad de tener una comprensión básica de las matemáticas. El orador también analiza competencias y proyectos que pueden ayudar a los aspirantes a ingenieros de visión por computadora a perfeccionar sus habilidades. Además, se destaca la importancia de las habilidades blandas como la documentación y el conocimiento de herramientas de software como Git y Docker. Finalmente, se recomienda obtener títulos en matemáticas, ciencia de datos, informática o ingeniería, aunque también es posible aprender de forma independiente a través de proyectos y cursos.

• 00:00:00 En esta sección del video, el orador presenta una hoja de ruta de visión por computadora que cubre todo lo que una persona necesita aprender para convertirse en un desarrollador de visión por computadora. La hoja de ruta responde a tres preguntas principales: qué habilidades se requieren, en qué proyectos puede trabajar para adquirir estas habilidades y qué títulos universitarios están disponibles para aprender estas habilidades. La hoja de ruta se divide en cuatro modelos, con el primer modelo que cubre Python y OpenCV, que son esenciales para resolver el 70% de los problemas de visión artificial. El segundo modelo trata sobre robótica y programación de bajo nivel, que incluye trabajar con C++ y electrónica. Los modelos tercero y cuarto cubren inteligencia artificial y temas avanzados, respectivamente. El orador sugiere proyectos para principiantes para cada modelo, como trabajar en un robot seguidor de línea o un lector de códigos QR para desarrollar conocimientos y habilidades.
  
  
• 00:05:00 En esta sección del video, el orador analiza la importancia de trabajar en proyectos que involucran dispositivos físicos como robótica y Arduinos. El orador explica que la programación de tales dispositivos requiere un enfoque diferente porque el mismo código puede producir resultados diferentes debido a factores como el ruido del sensor y los cambios de iluminación. El tercer módulo que menciona el ponente se centra en la inteligencia artificial y el aprendizaje automático utilizando la popular biblioteca de Python Scikit-learn, que se puede utilizar para tareas como la clasificación de imágenes y la detección de objetos. Finalmente, el orador también enfatiza la importancia de tener una comprensión básica de las matemáticas y cómo se relaciona con la visión artificial.
  
  
• 00:10:00 En esta sección, el orador explica la importancia de dividir el entorno en diferentes regiones y cómo se puede usar para detectar situaciones como cruces de carril mientras muestra una imagen simple con diferentes regiones separadas por geometría básica. Él enfatiza la necesidad de que los ingenieros de visión por computadora dominen las matemáticas y recomienda aprender los conceptos básicos de clasificación de imágenes y detección de objetos, aprendizaje secreto y geometría, antes de pasar a habilidades más avanzadas en aprendizaje automático, matemáticas y electrónica. Sugiere proyectos como redes adversarias generativas e implementación de documentos de última generación en visión por computadora para aprender aprendizaje automático avanzado, mientras emprende proyectos avanzados de Arduino o participa en competencias de robótica para mejorar el conocimiento de la electrónica.
  
  
• 00:15:00 En esta sección, el orador analiza varios concursos y proyectos que pueden ayudar a los aspirantes a ingenieros de visión artificial a perfeccionar sus habilidades. Estas competencias involucran la construcción de robots y agentes que pueden realizar tareas complejas y competir con otros equipos. El disertante enfatiza la importancia de aprender los fundamentos de la visión por computadora, incluidos Python y OpenCV, que pueden ayudar a resolver el 70% de los problemas disponibles. Los cuatro módulos mencionados son: fundamentos, robótica, intenciones artificiales y módulos avanzados. Si bien el módulo avanzado es importante, el orador sugiere centrarse primero en los otros módulos, ya que cubren las habilidades esenciales necesarias para convertirse en un ingeniero de visión por computadora exitoso.
  
  
• 00:20:00 En esta sección, el orador analiza las diversas habilidades relacionadas con el software que debe tener un desarrollador de visión por computadora, además de tener conocimientos de visión por computadora, aprendizaje automático y Python. Estas habilidades incluyen conocer los conceptos básicos de herramientas como Git y Docker, así como proveedores de la nube como AWS o Google Cloud. Las habilidades adicionales que se consideran valiosas incluyen el desarrollo web o móvil, el conocimiento de JavaScript y saber cómo escribir la documentación adecuada, como un archivo Léame para un repositorio de GitHub o la documentación de un proceso completo. Si bien no todas estas habilidades son obligatorias, pueden ser beneficiosas para mostrar el trabajo de un desarrollador y resolver varios problemas.
  
  
• 00:25:00 En esta sección, el orador enfatiza la importancia de la documentación para los desarrolladores de visión artificial, ya que simplifica las cosas para todos. También sugieren que todos los desarrolladores, no solo los desarrolladores de visión por computadora, deben dominar la documentación, ya que es una habilidad crucial. Luego, el orador destaca la importancia de estar familiarizado con varias herramientas de software y alienta a los aspirantes a ingenieros de visión por computadora a aprender todo lo que puedan. Para aquellos interesados en obtener un título universitario, el orador recomienda títulos en matemáticas, ciencias de la información, informática, ingeniería eléctrica o cualquier título de ingeniería, ya que brindan la base para abordar problemas y encontrar soluciones. Sin embargo, el orador señala que es completamente posible aprender todo de forma independiente tomando proyectos y cursos.

[MetaQuotes]

CLASIFICACIÓN DE IMÁGENES con el conjunto de datos personalizado Yolov8 | Tutorial de visión artificial

Código: https://github.com/computervisioneng/image-classification-yolov8

CLASIFICACIÓN DE IMÁGENES con el conjunto de datos personalizado Yolov8 | Tutorial de visión artificial

En esta sección, el presentador explica cómo elegir el mejor modelo para el proyecto y hace sugerencias entre elegir el último modelo producido del proceso de capacitación o seleccionar el modelo con la mayor precisión. La decisión depende de varios factores, incluidos los datos, el problema, el caso de uso y el proceso de capacitación. El orador también explica cómo hacer todas las inferencias y predecir nuevas muestras importando YOLO y especificando la ruta absoluta al modelo, usando una imagen de la computadora local y mostrando los resultados. Los resultados proporcionan mucha información, incluidas las probabilidades y los nombres de las categorías en las que se entrenó el clasificador de imágenes.

• 00:00:00 En esta sección, el YouTuber demuestra cómo construir un clasificador de imágenes usando YOLOv8 en un conjunto de datos personalizado. Comienza mostrando el conjunto de datos, que incluye imágenes de nubes, lluvia, sol y amaneceres. También explica la estructura de archivos que espera YOLOv8 para la entrada de datos. Felipe luego procede a explicar tres formas diferentes de entrenar un clasificador de imágenes usando YOLOv8: la primera es usando un script de Python, la segunda usando Google Colab Notebook y la tercera usando darknet, que es el marco subyacente para YOLOv8.
  
  
• 00:05:00 En esta sección, el tutorial repasa las dependencias necesarias para entrenar un modelo de clasificación de imágenes usando Yolov8 y cómo instalarlas usando el intérprete de Python en PyCharm. Los dos paquetes principales que se necesitan son Ultralytics y NumPy, siendo Ultralytics crucial para importar los datos necesarios para entrenar el modelo. Luego, el tutorial repasa el código necesario para entrenar el modelo y requiere establecer la ruta absoluta a los datos en el formato correcto. También se realiza una prueba para una sola época para garantizar que todo funcione correctamente antes de continuar con la capacitación adicional.
  
  
• 00:10:00 En esta sección, el orador muestra dónde se encuentran los resultados del proceso de entrenamiento y explica la estructura de carpetas dentro de la carpeta de ejecuciones. Luego demuestra cómo entrenar un clasificador de imágenes usando Yolov8 a través de la línea de comando usando una utilidad específica y los argumentos necesarios. Procede a mostrar la simplicidad de este enfoque entrenando el modelo solo para una época y luego muestra dónde se guardan los resultados en un nuevo directorio llamado "entrenado 13". Finalmente, el ponente analiza otra forma de entrenar el modelo utilizando Google Collab y proporciona una breve explicación del proceso para configurarlo.
  
  
• 00:15:00 En esta sección, el presentador muestra un cuaderno que ya ha sido creado para entrenar modelos Yolov8 llamado "train.ipymb". Cargar conjuntos de datos en Google Drive es un paso esencial para que los usuarios accedan a sus datos desde Google Collab, ya que el proceso requiere que los usuarios ejecuten una celda que conecta Google Collab con Google Drive. Conocer la ruta al conjunto de datos de un usuario en Google Drive es fundamental, ya que los usuarios deben ingresar esta ruta en sus cuadernos para usar sus conjuntos de datos correctamente. Por último, el presentador proporciona comandos simples que los usuarios pueden ejecutar para instalar las bibliotecas necesarias para entrenar los modelos Yolov8.
  
  
• 00:20:00 En esta sección del video, el instructor demuestra cómo entrenar un clasificador de imágenes usando YOLOv8 y un conjunto de datos personalizado, y cómo copiar los resultados obtenidos en un entorno de Google Colab a Google Drive. Ejecutan el proceso de capacitación para una época, copian los resultados en Google Drive y luego ejecutan el proceso de capacitación durante 20 épocas. Finalmente, muestran cómo analizar si el proceso de entrenamiento resultó en un buen clasificador de imágenes. El instructor enfatiza la importancia de configurar correctamente la variable del directorio de datos y sugiere copiar los resultados en Google Drive para simplificar su descarga y análisis.
  
  
• 00:25:00 En esta sección, se analizan los resultados del proceso de entrenamiento para un conjunto de datos personalizado usando YOLOv8. Se examinan los archivos guardados en la computadora local, incluido un archivo de configuración que enumera todos los parámetros de la EPA utilizados durante el proceso de capacitación y un archivo de resultados que incluye la pérdida de capacitación y validación, así como la precisión. Se utilizó un archivo de Python que traza la pérdida y la precisión en diferentes épocas para determinar si la pérdida está disminuyendo y si la precisión está aumentando a través del proceso de entrenamiento. Se concluye que un enfoque simple pero poderoso es verificar si la pérdida de entrenamiento y la pérdida de validación están disminuyendo mientras la precisión aumenta.
  
  
• 00:30:00 En esta sección, el orador explica cómo se ve la precisión de la evaluación cuando aumentamos el número de épocas, mostrando que la precisión aumenta y luego se estabiliza. Se podrían utilizar diferentes parámetros y un entrenamiento más personalizado para mejorar el proceso y obtener un mejor modelo. También se explica el directorio "pesos", donde se guardan dos archivos diferentes: "last.pt" y "best.pt". El archivo "last.pt" es el modelo producido al final de la última época de entrenamiento, mientras que el archivo "best.pt" es el modelo producido al final de la mejor época de entrenamiento. En la práctica, se utilizaría el último modelo para obtener los resultados finales.
  
  
• 00:35:00 En esta sección, el orador analiza cómo elegir el mejor modelo para el proyecto y hace sugerencias entre elegir el último modelo producido a partir del proceso de capacitación o seleccionar el modelo con la mayor precisión. La decisión depende de varios factores, incluidos los datos, el problema, el caso de uso y el proceso de capacitación. El orador también explica cómo hacer todas las inferencias y predecir nuevas muestras importando YOLO y especificando la ruta absoluta al modelo, usando una imagen de la computadora local y mostrando los resultados. Los resultados proporcionan mucha información, incluidas las probabilidades y los nombres de las categorías en las que se entrenó el clasificador de imágenes.
  
  
• 00:40:00 En esta sección del video, el presentador explica cómo usar un diccionario para identificar las clasificaciones de una imagen usando YOLOv8. Los resultados del clasificador de imágenes son números enteros correspondientes a diferentes categorías, y se utiliza un diccionario para identificar qué categoría representa cada número entero. Además, se obtiene el vector de probabilidad de todas las diferentes clases para una imagen dada, y el presentador demuestra cómo identificar la probabilidad máxima y su categoría correspondiente usando numpy. El presentador concluye mostrando cómo clasificar una imagen usando el modelo YOLOv8 y sugiere suscribirse a su canal para más proyectos de ingeniería de visión artificial.
  

[MetaQuotes]

Entrene la detección de objetos Yolov8 en un conjunto de datos personalizado | Guía paso a paso | Tutorial de visión artificial

Código: https://github.com/computervisioneng/train-yolov8-custom-dataset-step-by-step-guide

Entrene la detección de objetos Yolov8 en un conjunto de datos personalizado | Guía paso a paso | Tutorial de visión artificial

Este video tutorial proporciona una guía paso a paso sobre cómo entrenar un detector de objetos usando YOLOv8 en un conjunto de datos personalizado para aplicaciones de visión por computadora. El tutorial cubre aspectos importantes como la recopilación de datos, la anotación, el formato y la capacitación, así como la importancia de analizar gráficos de función de pérdida y ejemplos de la vida real para evaluar el rendimiento del modelo. El tutorial enfatiza el uso de la herramienta CVAT para la anotación, el cumplimiento del formato de datos YOLOv8 requerido y la creación de un archivo YAML de configuración. El tutorial también demuestra el uso de Google Colab y PyCharm para entrenar y probar el detector de objetos.

El video demuestra el rendimiento de un modelo de detección de objetos YOLOv8 entrenado en un conjunto de datos de alpaca. El orador usa un script de Python para cargar videos y ejecutar predicciones, mostrando una detección casi perfecta en algunos casos y una detección estable en otros, con algunas detecciones perdidas en un video. El ponente recomienda analizar las funciones de pérdida de entrenamiento y validación y decidir si hay margen de mejora antes de volver a entrenar el modelo para obtener un modelo más potente y con mejor rendimiento.

• 00:00:00 En esta sección del video, el presentador explica la importancia de recopilar datos al entrenar un detector de objetos con YOLOv8, así como las diferentes formas en que se pueden recopilar datos, como tomar sus propias fotografías o usar un conjunto de datos disponible públicamente. como el conjunto de imágenes abiertas. El presentador utiliza un conjunto de datos de alpaca con fines de demostración y a los espectadores se les muestran ejemplos de las imágenes contenidas en el conjunto de datos. Además, el presentador menciona que pueden proporcionar a los espectadores scripts para descargar y formatear los datos del conjunto de imágenes abiertas exactamente de la manera necesaria para el tutorial.
  
  
• 00:05:00 En esta sección del video, el narrador analiza el proceso de anotación de datos con la herramienta CVAT, que es una herramienta de etiquetado que se puede usar para la detección de objetos y tareas de anotación relacionadas con la visión artificial. El narrador demuestra cómo usar la herramienta CVAT para anotar un conjunto de imágenes para un conjunto de datos personalizado, explica cómo crear un nuevo proyecto y tarea, cargar imágenes y agregar etiquetas para los objetos que se detectarán. Aunque el narrador ya tiene las anotaciones para las imágenes utilizadas, proporcionan una guía paso a paso para aquellos que necesitan anotar sus datos. El video también destaca las ventajas y desventajas de las diferentes herramientas de anotación mientras enfatiza los beneficios de usar CVAT.
  
  
• 00:10:00 En esta sección, el creador del video muestra cómo etiquetar objetos en un conjunto de datos de imágenes para la detección de objetos usando el algoritmo YOLOv8. El creador usa imágenes de alpacas y demuestra cómo encerrar el objeto en una caja de unión, lo que permite que el algoritmo detecte e identifique los objetos. También explican la importancia de anotar sus propios datos para estar más familiarizado con las diferentes situaciones que pueden surgir durante la anotación y brindar claridad sobre los objetos que se detectan. El creador señala que, si bien la anotación de datos se puede realizar mediante servicios externos, es fundamental anotar algunas de las imágenes usted mismo para comprender mejor los datos.
  
  
• 00:15:00 En esta sección, se analiza la importancia de los criterios para anotar imágenes, con el ejemplo de un conjunto de datos de alpaca. También se muestran las diferentes formas de definir cuadros delimitadores para objetos, incluido el ajuste del cuadro al objeto o tener un cuadro delimitador más relajado. La herramienta de anotación cb80 se destaca como una aplicación web útil y fácil de usar para formatear y anotar datos, lo que enfatiza la importancia de la anotación de datos en el entrenamiento de algoritmos de detección de objetos.
  
  
• 00:20:00 En esta sección del video, el presentador explica el formato de datos específico requerido por YOLOv8 para entrenar un detector de objetos. Cada algoritmo en el aprendizaje automático tiene sus propios requisitos de entrada de datos, y YOLO necesita los datos en un formato muy específico. El presentador demuestra cómo exportar datos anotados desde CV80 y convertirlos al formato YOLO. El formato YOLO requiere que las anotaciones y las imágenes correspondientes tengan el mismo nombre y diferentes extensiones de archivo, y cada anotación del cuadro delimitador contiene un número de clase y cuatro números flotantes que definen la posición central, el ancho y la altura del cuadro delimitador. Se enfatiza que tener datos en el formato correcto es crucial para entrenar un detector de objetos.
  
  
• 00:25:00 En esta sección, el orador explica cómo estructurar los datos para entrenar la detección de objetos usando YOLOv8 en un conjunto de datos personalizado. El primer paso es crear dos directorios: uno para imágenes y otro para etiquetas, con nombres de directorio específicos que no se pueden cambiar. Dentro del directorio de imágenes, se deben ubicar todas las imágenes que se usarán para el entrenamiento, y se puede usar un directorio de trenes por conveniencia. Dentro del directorio de etiquetas, debe haber archivos de anotaciones para cada imagen, siguiendo un formato estándar donde cada fila especifica el ID de clase, la posición X/Y del centro del cuadro delimitador y el ancho y alto del cuadro delimitador. El ponente también explica cómo usar directorios adicionales para validar o probar datos, o para diferentes versiones de los datos.
  
  
• 00:30:00 En esta sección, el video tutorial analiza el proceso de entrenamiento de su detector de objetos con YOLO V8 utilizando Python o la utilidad de línea de comandos. El repositorio oficial de YOLO V8 ofrece la opción de entrenar con algunas instrucciones de Python o ejecutando un comando en la terminal. Luego, el tutorial pasa por una guía paso a paso sobre cómo entrenar un detector de objetos usando YOLO V8 en un proyecto PyCharm, incluida la importación de la biblioteca Ultralytics y la creación de un archivo YAML de configuración. El tutorial también destaca que los usuarios pueden elegir entre trabajar en un entorno local o en Google Colab.
  
  
• 00:35:00 En esta sección del video, el orador analiza el archivo de configuración para entrenar un detector de objetos usando YOLO V8 en un conjunto de datos personalizado. Explican cómo establecer los nombres de las diferentes clases que se detectan, la ruta absoluta al directorio que contiene las imágenes y anotaciones, y la ruta relativa a donde se encuentran las imágenes. El orador también menciona las dos palabras clave, "entrenar" y "val", que se refieren a los datos de entrenamiento y validación, respectivamente. Destacan la importancia de utilizar una ruta absoluta en lugar de una ruta relativa para evitar problemas. Luego, el orador demuestra cómo ejecutar el archivo y comienza el proceso de capacitación para una época, enfatizando la necesidad de esperar hasta que se complete el proceso. Finalmente, muestran los archivos de salida generados después de que se completa el proceso de entrenamiento.
  
  
• 00:40:00 En esta sección del video tutorial, el orador muestra los lotes de imágenes utilizadas para entrenar el algoritmo de detección de objetos YOLOv8, así como imágenes similares para la validación. El locutor explica que están realizando un entrenamiento superficial y ficticio, y muestran los archivos utilizados para tal fin. Luego, el orador muestra cómo entrenar el algoritmo desde la línea de comando usando la terminal, y también desde un cuaderno de colaboración de Google. La computadora portátil solo consta de cinco celdas, y el orador demuestra lo simple que es cargar datos, montar Google Drive y entrenar el algoritmo simplemente especificando la ruta relativa a la ubicación de los datos.
  
  
• 00:45:00 En esta sección, el video tutorial muestra cómo usar Google Colab para entrenar un detector de objetos YOLOv8 en un conjunto de datos personalizado. El proceso implica guardar una variable específica y ejecutar el comando "pip install ultralytics" en el entorno de Google Colab a través del comando del signo de exclamación. El tutorial muestra cómo ingresar las mismas líneas de código utilizadas en el entorno local y cómo especificar una ruta absoluta al directorio de Google Drive. Una vez que se cargan los archivos y se ejecutan los comandos, el proceso de entrenamiento es similar al del entorno local. El tutorial indica a los usuarios que esperen a que se complete la ejecución y recuerden ejecutar el comando que copia el directorio de resultados en el directorio elegido en Google Colab.
  
  
• 00:50:00 En esta sección, el video tutorial se enfoca en probar el rendimiento del detector de objetos Yolov8 que fue entrenado en un conjunto de datos personalizado. El primer paso para probar el modelo consiste en ir al directorio donde se guardó toda la información sobre el proceso de entrenamiento. Luego, el video muestra diferentes resultados y gráficos que se pueden usar para analizar el rendimiento del modelo, incluidas matrices de confusión, curvas de confianza F1 y gráficos de función de pérdida. El video recomienda enfocarse en los diagramas de pérdida, asegurándose de que todas las pérdidas estén disminuyendo, ya que esta es una forma simple pero poderosa de analizar el rendimiento del modelo. También se analizan diferentes situaciones en los gráficos de la función de pérdida, como una función de pérdida plana, que podría indicar que el modelo ha aprendido todo lo que necesitaba aprender.
  
  
• 00:55:00 En esta sección del video, el presentador analiza el análisis de la función de pérdida para obtener información sobre el proceso de entrenamiento de un modelo de detección de objetos. Si la función de pérdida baja, todo va bien, pero si sube, hay un problema con el entrenamiento. Mirar las gráficas y analizar esta información es más una investigación, pero el presentador propone una forma más visual de evaluar el rendimiento del modelo, que es mirar ejemplos reales y ver cómo funciona el modelo con datos reales. El presentador muestra ejemplos del modelo detectando alpacas de la vida real en videos, que son datos completamente invisibles para probar el rendimiento del modelo. Si bien los resultados no son perfectos, el rendimiento es bueno, y el presentador argumenta que esta evaluación visual es más relevante para un profesional independiente que trabaja en el proyecto de un cliente, ya que es posible que al cliente no le importen las tramas y las métricas, sino que quiera ver cómo funciona el proyecto. el modelo funciona con datos reales.

• 01:00:00 En esta sección, el orador demuestra el rendimiento del modelo de detección de objetos YOLOv8 entrenado en un conjunto de datos de alpaca en datos no vistos a través de un script de Python que carga videos y ejecuta predicciones. Las detecciones parecen funcionar bien, con una detección casi perfecta en algunos casos y una detección estable en otros, excepto por algunas detecciones perdidas en un video. El ponente aconseja analizar las funciones de pérdida de entrenamiento y validación, comprobar su tendencia a la baja y la existencia de margen de mejora para decidir si entrenar de nuevo el modelo, que es lo que hace el ponente para conseguir un modelo más potente y con mejores prestaciones.

[MetaQuotes]

Detección de objetos Yolov8 + seguimiento de objetos de clasificación profunda | Tutorial de visión artificial

Código: https://github.com/computervisioneng/object-tracking-yolov8-deep-sort

Detección de objetos Yolov8 + seguimiento de objetos de clasificación profunda | Tutorial de visión artificial

Este video tutorial muestra cómo implementar un sistema de detección y seguimiento de objetos usando YOLOv8 y clasificación profunda. El presentador recorre el proceso paso a paso, desde configurar el entorno, cargar y detectar objetos en un video usando YOLOv8, hasta rastrear los objetos detectados a lo largo del tiempo usando clasificación profunda. También explican la importancia de crear la estructura de archivos correcta e instalar las dependencias necesarias. Una vez que las detecciones se extraen de YOLOv8, se aplica el seguimiento de objetos de clasificación profunda para realizar un seguimiento de los objetos detectados a lo largo del tiempo. Finalmente, el presentador explica cómo guardar los cuadros de salida finales en un archivo de video y alienta a los espectadores a modificar el umbral de detección para una mayor precisión.

• 00:00:00 En esta sección del video, el presentador presenta el proyecto de trabajar con detección de objetos usando YOLOv8 y seguimiento de objetos usando clasificación profunda. El objetivo es crear un algoritmo de seguimiento que pueda realizar un seguimiento de las personas que se mueven en un video y usar cuadros delimitadores de diferentes colores para indicar los objetos que se están rastreando. El host muestra los repositorios de clasificación profunda y YOLOv8 que se utilizarán, así como los datos de video que se probarán. Finalmente, el anfitrión introduce un archivo llamado "tracker.py", que es un contenedor de clasificación profunda que simplifica el proceso de seguimiento de objetos mediante el uso de funciones de alto nivel.
  
  
• 00:05:00 En esta sección del video, el presentador explica cómo configurar el entorno para el tutorial clonando el repositorio necesario, descargando los archivos requeridos e importando las bibliotecas necesarias. Explican la importancia de crear la estructura de archivos correcta e instalar las dependencias correctas para garantizar la compatibilidad con el código. Luego, el presentador demuestra cómo cargar un video y leer marcos usando OpenCV, y cómo mostrar los marcos en una ventana.
  
  
• 00:10:00 En esta sección, el presentador demuestra cómo usar el modelo preentrenado YOLOv8 para producir detecciones en un video. Con Ultralytics, se importa el modelo previamente entrenado y se llama a la función en un cuadro del video. Los resultados de la detección de salida se imprimen, pero dado que los resultados están en un tipo de objeto personalizado, deben desempaquetarse y transformarse en una lista mediante un bucle for. Las detecciones de salida final se guardan en un nuevo objeto. Una vez que el código se ejecuta con éxito, los resultados se pueden utilizar como datos de entrada para algoritmos de seguimiento de objetos.
  
  
• 00:15:00 En esta sección del video tutorial, el orador demuestra cómo desenvolver toda la información de detección importante del detector de objetos YOLOv8 y rastrear los objetos detectados usando el rastreo de objetos Deep Sort. Muestran cómo extraer información como el ID de clase, el valor de confianza y las coordenadas de cada detección para pasarla al algoritmo de seguimiento. El orador también muestra cómo inicializar y llamar al rastreador Deep Sort con las detecciones y marcos para realizar un seguimiento de los objetos detectados a lo largo del tiempo.
  
  
• 00:20:00 En esta sección, el presentador explica el proceso de seguimiento de objetos de ordenación profunda, que involucra funciones informáticas en la parte superior del marco y los objetos detectados. El algoritmo recorta el marco y extrae las características, y para iterar a través de todas las pistas, el presentador usa un bucle para acceder al cuadro delimitador y al ID de la pista. Cada persona u objeto detectado en el video tiene una identificación asignada que se mantiene estable en todos los cuadros. Por cada nuevo ID detectado, el presentador lo traza con un color diferente utilizando una lista de colores aleatorios en la visualización.
  
  
• 00:25:00 En esta sección del video, el orador resuelve el problema de guardar el video con todos los diferentes cuadros y detecciones en la computadora local. Se crea un nuevo objeto, el escritor de video CV2, para guardar el video con un nombre y una ubicación específicos. El video se guarda con un códec MP4 y la misma velocidad de fotogramas que el video original. El ponente destaca que todo funciona correctamente, aunque no se logra la detección en tiempo real debido a la cantidad de objetos que se cargan y la ejecución se ejecuta en una CPU. En general, el problema de la detección de objetos con YOLOv8 y el seguimiento de objetos con Deep SORT se ha resuelto con éxito.
  
  
• 00:30:00 En esta sección, el orador concluye el tutorial repasando los pasos finales necesarios para implementar un sistema exitoso de detección y seguimiento de objetos usando YOLOv8 y clasificación profunda. Demuestran cómo guardar los fotogramas de salida en un archivo out.mp4 y muestran cómo se completó con éxito. Además, el ponente menciona los posibles errores de detección y anima a los espectadores a modificar el umbral de detección para mejorar la precisión del sistema de detección de objetos como pájaros. En general, este tutorial sirve como una guía útil para cualquiera que busque implementar un sistema de detección y seguimiento de objetos utilizando técnicas de visión por computadora.

[MetaQuotes]

Segmentación de imágenes con el conjunto de datos personalizado Yolov8 | Tutorial de visión artificial

Código: https://github.com/computervisioneng/image-segmentation-yolov8

Datos: https://drive.google.com/drive/folders/1JvA2IvHBy2QOnAtPtoy4JbEEmtbz5dnK

Segmentación de imágenes con el conjunto de datos personalizado Yolov8 | Tutorial de visión artificial

Este tutorial cubre el proceso de anotar imágenes y crear una máscara binaria para la segmentación semántica, formatear y estructurar el conjunto de datos para entrenar con YoloV8, entrenar el modelo en Google Collab, analizar los resultados del entrenamiento y hacer predicciones usando una secuencia de comandos de Python. El presentador enfatiza la importancia de estructurar el sistema de archivos y analizar la función de pérdida y las métricas de validación para entrenar un buen modelo para el conjunto de datos personalizado de YoloV8. También discuten el impacto de los datos defectuosos en la calidad de la predicción y recomiendan usar las predicciones del modelo actual para entrenar uno nuevo y mejorado. En general, el tutorial proporciona una guía completa para la segmentación de imágenes con el conjunto de datos personalizado de YoloV8.

• 00:00:00 En esta sección del video, el instructor muestra el conjunto de datos que se utilizará para la segmentación semántica: un conjunto de imágenes de patos con las correspondientes máscaras binarias. La máscara binaria tiene todos los píxeles blancos para un objeto en la imagen y todos los píxeles negros para todo lo demás. El instructor descarga este conjunto de datos de la versión 7 de activos de imágenes abiertas y muestra el sitio web cvat.ai en caso de que uno necesite anotar sus propios datos de imagen. Luego, el instructor muestra cómo usar esta herramienta para crear una máscara binaria para una imagen en una sola anotación de imagen.
  
  
• 00:05:00 En esta sección del tutorial, el presentador demuestra cómo anotar una imagen y crear una máscara binaria para la segmentación semántica. Usando una imagen de pato como ejemplo, guían al espectador a través del proceso de dibujar un polígono para crear la máscara alrededor del cuerpo del pato, incluida una discusión sobre si se deben anotar ciertas partes debajo del agua como parte del pato o no. El presentador enfatiza que la máscara no tiene que ser perfecta en píxeles, pero debe ser lo suficientemente precisa para crear una buena máscara. Finalmente, muestran cómo guardar y descargar los datos anotados para usarlos en la creación de un conjunto de datos.
  
  
• 00:10:00 En esta sección, el ponente explica cómo formatear y estructurar el conjunto de datos para entrenar un modelo de segmentación semántica con YoloV8. El primer paso es descargar los datos requeridos utilizando la opción Exportar conjunto de datos de tareas y seleccionando la máscara de segmentación. Una vez que se descargan los datos, es necesario organizarlos en una estructura de directorio que contenga las imágenes, las máscaras y las etiquetas. Las máscaras generadas a partir de las imágenes deben convertirse a un formato de archivo diferente a través de un script de Python proporcionado por el orador. YoloV8 requiere este formato de archivo y contiene la misma información que las máscaras binarias. El ponente también destaca la importancia de estructurar el sistema de archivos de una manera particular para que YoloV8 pueda encontrar y utilizar los datos.
  
  
• 00:15:00 En esta sección, el presentador explica la estructura de directorio necesaria para la segmentación de imágenes con el conjunto de datos personalizado Yolov8. Los usuarios deben tener dos directorios: uno llamado "tren", que contiene todos los datos de entrenamiento para el modelo de segmentación semántica, y el otro llamado "bola", que contiene imágenes que se utilizarán para validar el modelo. Dentro de estos directorios hay otros dos directorios, "imágenes" y "etiquetas", que tienen dos subdirectorios llamados "tren" y "pelota". El primero contiene todas las anotaciones generadas a partir de las máscaras de entrenamiento. El presentador configura la estructura en pycharm y procede a explicar cómo entrenar el modelo utilizando un modelo Yolov8 previamente entrenado por Ultralytics, incluida la implementación del código y la edición del archivo de configuración.
  
  
• 00:20:00 En esta sección, el ponente explica que el modelo de segmentación semántica está entrenado en Google Collab debido al acceso a una GPU gratuita, lo que hace que el proceso sea mucho más rápido. El orador recomienda cargar datos, incluidos directorios e imágenes, y el archivo config.yaml antes de comenzar el proceso. Además, el orador muestra y explica cómo ejecutar cada una de las celdas de la computadora portátil Jupiter y comparte la ubicación de sus datos en Google Drive, alentando al usuario a hacer lo mismo al cargar sus datos. Por último, el orador menciona la instalación de Ultralytics para que puedan usar YOLOv8 en la computadora portátil y enfatiza garantizar el uso de Google Collab con GPU mientras verifica el tipo de tiempo de ejecución.
  
  
• 00:25:00 En esta sección del tutorial, el hablante entrena el modelo durante 10 épocas y guarda los resultados en la carpeta del tren de segmento 2. El siguiente paso es analizar los resultados del entrenamiento para validar que todo funciona bien. La forma más sencilla de hacerlo es copiando todo el contenido en el directorio donde se guardan los resultados en Google Drive. Una vez que los resultados se descargan en una computadora local, el orador recomienda centrarse en analizar la función de pérdida, la pérdida de segmentación, la pérdida de entrenamiento y las gráficas de pérdida de validación para asegurarse de que la función de pérdida esté disminuyendo. Esta es una buena señal de que las cosas están funcionando bien, mientras que una función de pérdida creciente indica un problema grave.
  
  
• 00:30:00 En esta sección, el orador habla sobre el análisis de la función de pérdida y las métricas de validación para entrenar un buen modelo para el conjunto de datos personalizado de Yolov8. Es una buena señal si la pérdida de entrenamiento y validación está disminuyendo, lo que indica una tendencia a mejorar la calidad de la predicción. Sin embargo, el orador advierte que las anotaciones faltantes y otras fallas en los datos de entrenamiento pueden afectar la calidad de la predicción, lo que genera tendencias inesperadas en el gráfico de la función de pérdida. Por ello, el ponente aconseja no volverse loco analizando estos gráficos e incluir un análisis de las predicciones para evaluar el rendimiento global del modelo.
  
  
• 00:35:00 En esta sección, el disertante discute la importancia de analizar los resultados de validación y evaluación de un modelo entrenado en un conjunto de datos, que no es perfecto y tiene errores. Estos errores se pueden abordar utilizando las predicciones del modelo actual para entrenar uno nuevo y mejorado. El orador muestra el directorio donde se guardan los pesos del modelo, explicando que last.pt y best.pt representan el último y el mejor modelo durante el entrenamiento, respectivamente. Finalmente, el orador recomienda usar less.pt debido a que considera mucha más información que el modelo best.pt.
  
  
• 00:40:00 En esta sección del video tutorial sobre la segmentación de imágenes con el conjunto de datos personalizado de YOLOv8, el presentador demuestra cómo hacer predicciones usando un script de Python. Comienza importando el paquete YOLO de Ultralytics y define el modelo usando less.pt del directorio de resultados. Luego especifica la ruta de la imagen e importa CV2 para abrir y leer esta imagen. El presentador obtiene los resultados del modelo llamando al modelo en la imagen e itera a través de los resultados para obtener la máscara predicha. Cambia el tamaño de la máscara al tamaño de la imagen original y la guarda como salida.png. El presentador también muestra cómo superponer la máscara en la imagen original para asegurar una buena predicción.
  
  
• 00:45:00 En esta sección, el presentador demuestra el resultado del modelo de segmentación semántica que entrenaron con YOLOv8. Usando una imagen superpuesta y transparencia, muestran que aunque la máscara no es 100% perfecta, es un resultado muy bueno considerando los errores en los datos. Luego, el presentador resume todo el proceso, desde anotar los datos, entrenar el modelo, validarlo hasta hacer predicciones. Finalmente, alientan a los espectadores a suscribirse a su canal y ver otros videos que han publicado.

[MetaQuotes]

Detección de objetos Tensorflow en 5 horas con Python | Curso Completo con 3 Proyectos

Obtenga el código Código del curso de Python de detección de objetos de Tensorflow: https://github.com/nicknochnack/TFODCourse

Aplicación React de detección de objetos Tensorflow: https://github.com/nicknochnack/TFODApp

Detección de objetos Tensorflow para Raspberry Pi: https://github.com/nicknochnack/TFODRPi

Detección de objetos Tensorflow en 5 horas con Python | Curso Completo con 3 Proyectos

Parte 1

• 00:00:00 El instructor presenta el curso de detección de objetos que está destinado a llevar a los principiantes completos en la detección de objetos a un nivel competente como practicantes. El curso es completo y cubre la instalación y configuración de la API de detección de objetos de TensorFlow, la recopilación y el etiquetado de imágenes, la capacitación del modelo, la exportación del modelo de detección a diferentes formatos y la prueba de los modelos en varios casos de uso. Todo el curso se realiza con herramientas de código abierto, principalmente la detección de objetos de Python y TensorFlow, lo que facilita la reutilización del código para detectar varios objetos. El instructor también explica los beneficios de usar la API de detección de objetos de TensorFlow, que acelera el proceso de creación de modelos de detección de objetos debido a las diversas capacidades adicionales que ofrece.
  
  
• 00:05:00 El instructor explica la diferencia entre la programación tradicional y el aprendizaje automático, donde en lugar de definir reglas explícitas para detectar objetos, el aprendizaje automático usa datos y respuestas para entrenar un modelo de detección de objetos para aprender las reglas. El modelo puede detectar objetos en imágenes estáticas y transmisiones de video en tiempo real, y se puede exportar y convertir a diferentes formatos como tensorflow.js y tf lite usando congelación y conversión. El ajuste del rendimiento es crucial para mejorar la precisión del modelo, y el instructor cubre este tema en el paso seis. Finalmente, el instructor demuestra tres proyectos, incluido el uso de un microscopio USB para detectar defectos en piezas pequeñas, detectar objetos en un videojuego y contar la cantidad de objetos que pasan a través de una cámara web.
  
  
• 005:10:00 El instructor presenta los tres proyectos que se cubrirán en el tutorial, que implican entrenar un modelo de detección de objetos para identificar defectos en placas de circuito impreso, detectar gestos con las manos e integrar el modelo en una aplicación web, y realizar la detección de objetos en tiempo real utilizando una Raspberry Pi. El instructor proporciona tres conjuntos de código en Github para cada uno de los proyectos, que se utilizarán para construir los modelos paso a paso. El primer paso es clonar el código y crear un entorno virtual, que se explica como una habitación separada en una casa. Esta sección también incluye consejos útiles para seguir el tutorial, como revisar cada paso antes de continuar, tomar notas y pedir ayuda si es necesario a través del servidor de Discord provisto.
  
  
• 00:15:00 El instructor explica la importancia de usar un entorno virtual mientras se trabaja con modelos de detección de objetos de TensorFlow. Lo describe como la creación de una nueva habitación en una casa donde se instalan todas las dependencias de detección de objetos para garantizar que no entren en conflicto con las bibliotecas instaladas previamente. Luego, el instructor habla sobre las dependencias necesarias para trabajar con TensorFlow, incluidas las herramientas de compilación de Visual C++ y CUDA y CUDNN para la aceleración basada en GPU. Explica que estas bibliotecas son esenciales para un entrenamiento más rápido de los modelos de detección de objetos y muestra cómo descargarlos e instalarlos. En general, esta sección proporciona una base esencial necesaria para configurar un entorno de desarrollo para crear modelos de detección de objetos de TensorFlow.
  
  
• 00:20:00 El instructor analiza los requisitos necesarios para instalar la detección de objetos de TensorFlow, incluidas las versiones específicas de Python, el compilador GCC, Bazel, CUDA y cuDNN que se necesitan. El instructor enfatiza que hacer coincidir las versiones de TensorFlow, CUDA y cuDNN es esencial para utilizar las GPU durante el entrenamiento. Proporcionan enlaces a guías de instalación para Windows y Linux/macOS y aconsejan a los espectadores que verifiquen su versión de TensorFlow y obtengan las versiones CUDA y cuDNN adecuadas. Además, el instructor menciona que han creado una guía de errores para problemas comunes que ocurren durante la instalación o mientras se ejecuta el cuaderno de detección de objetos. La guía incluye soluciones a diferentes errores y se puede encontrar en el enlace del repositorio de GitHub provisto.
  
  
• 00:25:00 El instructor muestra cómo configurar un entorno virtual para la detección de objetos de TensorFlow mediante Python. Indica los pasos a seguir para crear el entorno, que consiste en clonar un repositorio con el código necesario y las dependencias, crear un entorno virtual utilizando el paquete venv de Python y activar el entorno. Crear un entorno virtual es similar a crear una nueva habitación en una casa, donde uno puede aislar bibliotecas y dependencias para trabajar en proyectos de detección de objetos de TensorFlow en un entorno aislado.
  
  
• 00:30:00 El creador del video analiza el proceso de creación de un entorno virtual para la detección de objetos TensorFlow (TFOD) a fin de mantener separados el código de capacitación, la aplicación y Raspberry Pi. El creador del video sigue los pasos para activar el entorno virtual, incluida la ejecución de un comando en una máquina con Windows para activar el entorno. Hay una demostración de cómo actualizar el instalador de pip y luego instalar TensorFlow. El beneficio de estas actualizaciones es la capacidad de ver instalaciones en tiempo real dentro de la carpeta de paquetes del sitio. Cabe señalar que, a veces, la instalación de TensorFlow requiere varios intentos, y el creador del video tiene un script de verificación para asegurarse de que todo esté instalado correctamente.
  
  
• 00:35:00 El ponente explica cómo instalar los paquetes necesarios y configurar un entorno virtual con Jupyter Notebook utilizando iPy Kernel. También brindan instrucciones para instalar Anaconda Python y Jupyter Notebooks para aquellos que son nuevos en esto. Luego, explican cómo instalar iPy Kernel y asociarlo con Jupyter Notebook para permitir una carga de trabajo de ciencia de datos más eficiente. Por último, el orador muestra cómo validar el entorno virtual y comenzar a recopilar y etiquetar imágenes como parte del próximo paso hacia la construcción de un modelo de detección de objetos de TensorFlow.
  
  
• 00:40:00 El instructor enfatiza la importancia de recolectar y etiquetar buenas imágenes al entrenar modelos de detección de objetos. Para demostrarlo, utiliza un cuaderno Jupyter para recopilar imágenes de una cámara web y la biblioteca LabelImg para etiquetar las imágenes. El instructor comparte las mejores prácticas para tener en cuenta al etiquetar, como mantener las etiquetas lo más ajustadas posible e incluir imágenes de objetos en diferentes ángulos y bajo diferentes condiciones de iluminación. Otra práctica recomendada importante es comenzar con 10 a 20 imágenes de cada clase, pero el instructor comienza con menos y muestra cómo agregar imágenes adicionales para volver a entrenar al modelo si el rendimiento no es óptimo. Finalmente, el instructor explica que proporcionarle al modelo una variedad de imágenes sin una pantalla verde detrás del objeto lo hará más generalizado y más capaz de detectar objetos.
  
  
• 00:45:00 El instructor guía a los espectadores a través del componente de recopilación de imágenes del tutorial de detección de objetos de TensorFlow. El tutorial comienza con la instalación de OpenCV, una popular biblioteca de visión por computadora que se utiliza para acceder a la cámara web y recopilar imágenes. El instructor enfatiza la importancia de asegurarse de que las dependencias se instalen en el entorno virtual para mantener el control y garantizar un funcionamiento fluido. Luego, el código importa las dependencias necesarias, incluidos el UUID, el sistema operativo y la hora, que se utilizarán para garantizar el cumplimiento de las diferentes rutas de archivo y capturar imágenes en diferentes ángulos. Luego, el tutorial define las diferentes etiquetas para recopilar y explica que las etiquetas se pueden cambiar en función de los objetos deseados para detectar. Las etiquetas se almacenan en una lista y el instructor explica que la cantidad de imágenes recopiladas para cada etiqueta se define mediante la variable "cantidad de imágenes".
  
  
• 00:50:00 El instructor analiza la configuración de la estructura de carpetas para la detección de objetos, la importancia de tener una buena cantidad de imágenes al comenzar y cómo capturar imágenes con una cámara web u otro dispositivo de captura. La estructura de carpetas se crea utilizando una ruta de archivo específica que debe seguirse a lo largo del tutorial. El código recorre todas las etiquetas, se conecta a la cámara web y captura imágenes para cada etiqueta. El instructor enfatiza la importancia de especificar correctamente el número de dispositivo de captura de video para la cámara web, ya que pueden surgir errores si este es incorrecto.
  
  
• 00:55:00 El instructor explica el código para recopilar imágenes para la detección de objetos. El código recorre las etiquetas y captura los fotogramas con la cámara web. Crea una nueva imagen y la coloca dentro de la carpeta de etiquetas respectiva con un nombre de identificador único. El comando cv2.iamwrite se usa para escribir la imagen en un archivo y mostrarla en la pantalla. El código también permite al usuario presionar la tecla q para escapar en cualquier punto y cierra todo cuando termina. El instructor enfatiza que es esencial capturar imágenes en diferentes posiciones para construir un modelo generalizado.

Parte 2

• 01:00:00 El disertante enfatiza la importancia de prototipar lo más rápido posible los proyectos de ciencia para establecer la factibilidad y posibilidad del proyecto. Para ilustrar, el orador da un ejemplo de detección de LED doblados, lo que requeriría un modelo hiperpreciso o un sensor como un microscopio. La creación rápida de prototipos con un modelo de red móvil y una cámara web puede mostrar un rendimiento deficiente, lo que indica la necesidad de una técnica o sensor diferente. La creación de prototipos rápidamente ayuda a establecer una línea de base para la mejora, y el orador procede a entrenar el modelo con las imágenes recopiladas para la detección de aprobación, mientras enfatiza la importancia de eliminar imágenes de baja calidad y capturar más imágenes de buena calidad para una mejor detección.
  
  
• 01:05:00 El instructor presenta el paquete Label Image que se utilizará para etiquetar las imágenes. Los usuarios pueden ir al repositorio de Github para verificar el paquete. Después de eso, el instructor muestra cómo instalar las dependencias requeridas, pi qt5 y lxml, y crea una nueva carpeta llamada tensorflow y etiqueta la imagen para guardar el paquete. Luego, el instructor demuestra cómo clonar el repositorio de Github e instalar el paquete de imágenes de etiquetas mediante la ejecución de comandos específicos. Finalmente, el instructor abre la aplicación de etiquetas de imágenes y se prepara para etiquetar las imágenes.
  
  
• 01:10:00 El instructor demuestra el proceso de etiquetado de imágenes para la detección de objetos mediante el software de etiquetado OpenCV. El proceso incluye abrir el directorio específico en el software y seleccionar las imágenes a etiquetar. El instructor aconseja ser lo más preciso posible con las etiquetas de detección y asegurarse de que los nombres de las etiquetas coincidan con los de las anotaciones y del paso de entrenamiento. Además, el instructor alienta a los espectadores a pensar en diferentes aplicaciones de detección de objetos y probarlas utilizando el mismo proceso de definición de etiquetas, recopilación de imágenes y etiquetado. También se enfatiza la importancia de asegurar que existan las anotaciones correspondientes para cada imagen.
  
  
• 01:15:00 El instructor explica cómo etiquetar una imagen creando un archivo de anotaciones. El archivo de anotaciones es un archivo xml que describe la ubicación del objeto en la imagen. El instructor muestra cómo etiquetar una imagen con varios objetos y explica cómo guardar las anotaciones correctamente. El proceso de etiquetado de imágenes se puede ampliar mediante la subcontratación o mediante el uso de herramientas más nuevas que automaticen el proceso de etiquetado utilizando modelos de detección de objetos ligeros.
  
  
• 01:20:00 El instructor en video muestra cómo etiquetar imágenes usando etiquetar imagen y cómo crear un prototipo para asegurarse de que está usando la técnica correcta antes de construir un modelo de detección de objetos enorme con miles de imágenes. Recomienda comenzar etiquetando de 10 a 25 imágenes para mantenerlo súper rápido y usar los sensores correctos para obtener los niveles correctos de datos. El instructor también explica la importancia de dividir las imágenes en una partición de entrenamiento y prueba para entrenar el modelo en un segmento de imágenes y probarlo en un conjunto de imágenes que nunca antes había visto. Crea dos carpetas nuevas llamadas entrenar y probar dentro de la carpeta de imágenes para almacenar las anotaciones e imágenes de entrenamiento y prueba.
  
  
• 01:25:00 Aprendemos cómo preparar los datos de imagen que recolectamos y etiquetamos para entrenar nuestro modelo de detección de objetos. Creamos dos carpetas, capacitación y prueba, para almacenar nuestras imágenes y anotaciones, asegurándonos de capturar tanto los archivos de imagen como los de anotación para cada clase. Luego explicamos cómo convertirlos en registros de TensorFlow para usarlos en el entrenamiento. También cubrimos algunas mejores prácticas para nombrar y organizar nuestros datos. Finalmente, presentamos las dependencias necesarias para entrenar un modelo de detección de objetos de TensorFlow y cómo evaluar nuestro modelo usando métricas de evaluación.
  
  
• 01:30:00 El orador analiza las métricas de evaluación que obtiene después de entrenar su modelo de detección de objetos. Estas métricas incluyen precisión y precisión media media (MAP), que calcula la proporción de detecciones correctas. Se calculan en función del número de verdaderos positivos, falsos positivos, verdaderos negativos y falsos negativos. El ponente explica que la precisión y la recuperación son muy importantes a la hora de evaluar el rendimiento del modelo. Además, el orador menciona que la elección del zoológico modelo TensorFlow afecta la precisión y la velocidad del modelo. Los diferentes modelos tienen diferentes arquitecturas que dan como resultado diferentes niveles de precisión y velocidad, y los profesionales deben elegir el modelo apropiado para su caso de uso.
  
  
• 01:35:00 La transcripción analiza las compensaciones entre la velocidad y la precisión del modelo al elegir una arquitectura de modelo para la detección de objetos de TensorFlow. El video presenta diferentes opciones de modelos y sus velocidades de cuadro correspondientes y puntajes de precisión promedio promedio. El presentador señala que ciertas arquitecturas pueden ser rápidas y muy precisas, mientras que otras pueden ser más lentas pero más precisas. También se mencionan los beneficios de usar la API del modelo de detección de actualizaciones de TensorFlow, como el uso de técnicas de procesamiento previo y posterior y el aumento de imágenes. La sección concluye con una discusión sobre cómo entrenar un modelo usando una instancia en la nube si lo desea.
  
  
• 01:40:00 El instructor explica la configuración del modelo de detección de objetos de TensorFlow, que implica configurar el nombre y la URL del modelo previamente entrenados, así como variables como el script de generación de registros tf y el nombre del mapa de etiquetas. También se muestra la estructura de carpetas del modelo, con el espacio de trabajo que contiene carpetas para anotaciones, imágenes, modelos y puntos de control. El siguiente paso es descargar los modelos de TensorFlow del zoológico de modelos de TensorFlow e instalar el paquete de detección de objetos de TensorFlow, que el instructor explica paso a paso para garantizar una instalación exitosa. El proceso implica clonar el repositorio de detección de objetos de TensorFlow e instalar las dependencias necesarias.
  
  
• 01:45:00 El presentador explica cómo clonar e instalar la API del modelo de detección de objetos de TensorFlow. La API del modelo se puede descargar desde el jardín de modelos de TensorFlow, que tiene mucha documentación y tutoriales de código abierto. Luego, el presentador demuestra cómo navegar a la carpeta de investigación, que contiene todos los archivos necesarios para usar la API del modelo de detección de objetos de TensorFlow. Después de clonar la carpeta de investigación, el presentador procede a explicar cómo instalar protoc y otros componentes necesarios para instalar correctamente la API del modelo de detección de objetos de TensorFlow. Finalmente, el presentador muestra cómo verificar la instalación mediante la ejecución de un script de verificación para verificar si la API de detección de objetos de TensorFlow se instaló correctamente.
  
  
• 01:50:00 El instructor recorre el proceso de verificación e instalación de Tensorflow para la detección de objetos. Explica que se usa un script de verificación para garantizar que Tensorflow esté instalado correctamente y que se puede ejecutar para verificar si hay errores. El script es un script estándar de detección de objetos de Tensorflow que indica si Tensorflow está instalado o no cuando se ejecuta. Si Tensorflow no está instalado correctamente, el instructor brinda orientación sobre cómo configurarlo, incluida la instalación de paquetes adicionales como matplotlib y yaml. El instructor le asegura al espectador que si encuentra errores, puede buscarlos en Google, ya que son comunes y fáciles de resolver. Finalmente, afirma que alcanzar con éxito el signo "bien" en la parte inferior del script de verificación significa que Tensorflow se instaló correctamente.
  
  
• 01:55:00 El video cubre el proceso de instalación de TensorFlow y los paquetes necesarios para la detección de objetos. El instructor muestra cómo instalar TensorFlow, Matplotlib, Protobuf, Pillow y Pymel. El instructor recomienda verificar el proceso de instalación, ya que puede ser diferente según su entorno. El video también repasa los pasos para instalar CUDA y CuDNN, que son necesarios si desea usar la GPU para el entrenamiento. El instructor explica cómo encontrar la versión correcta de CUDA y CuDNN y sigue el proceso de instalación. Finalmente, el instructor demuestra cómo importar la API de detección de objetos con éxito en el cuaderno reiniciando el kernel.

parte 3

• 02:00:00 El instructor recorre el proceso de descarga e instalación de Nvidia cuDNN, que se requiere si está entrenando en una GPU. Primero, debe registrarse para obtener una cuenta gratuita de desarrollador de Nvidia, luego seleccionar descargar cuDNN e iniciar sesión. Hay dos versiones disponibles y debe descargar la versión compatible con su versión de TensorFlow. El instructor explica cómo extraer el archivo comprimido y copiar los archivos cuDNN en sus respectivas carpetas dentro de la ubicación de instalación de CUDA. Después de copiar los archivos, el último paso es asegurarse de que la carpeta CUDA se agregue a su ruta en una máquina con Windows.
  
  
• 02:05:00 El instructor explica el proceso de instalación de TensorFlow y cómo probar si funciona correctamente o no. Luego, el video pasa al proceso de descarga de un modelo de detección de objetos previamente entrenado del zoológico modelo TensorFlow, que se usará para transferir el aprendizaje para detectar objetos personalizados. El instructor demuestra cómo descargar el modelo y explica los diferentes componentes de los archivos descargados. Finalmente, se crea un mapa de etiquetas para representar las diferentes etiquetas para la detección de objetos personalizados.
  
  
• 02:10:00 El instructor explica la creación de un mapa de etiquetas y la generación de registros tf. Subraya la importancia de un etiquetado adecuado, ya que el archivo del mapa de etiquetas se utilizará posteriormente durante todo el proceso de formación. El video guía a través de la generación de un tren y un registro de prueba y cómo actualizar los componentes de la ruta para el modelo, específicamente el punto de control de ajuste fino, la ruta del mapa de etiquetas y la ruta de entrada. Finalmente, destaca la relevancia del archivo de configuración de la canalización, que determina la arquitectura del modelo y debe personalizarse para modelos específicos.
  
  
• 02:15:00 El instructor explica cómo configurar el archivo de configuración para entrenar el modelo. El archivo de canalización se copia de la carpeta de modelos previamente entrenados y luego la configuración se realiza a través del código configurando todas las diferentes rutas de archivo junto con la cantidad de clases y configurando el punto de control de ajuste fino, la ruta del mapa de etiquetas, la ruta de entrada, etc. Una vez que se realiza la configuración, el modelo se puede entrenar ejecutando el script de entrenamiento del modelo con los argumentos necesarios, como la ruta del archivo pipeline.config, la configuración de la tubería y la cantidad de pasos de entrenamiento. Se sugiere ejecutar el comando en un símbolo del sistema separado fuera del cuaderno para ver el progreso del entrenamiento del modelo.
  
  
• 02:20:00 El instructor soluciona los errores que ocurren durante el proceso de entrenamiento de detección de objetos. Explica que la mayoría de los errores se resuelven instalando la biblioteca adecuada o buscando soluciones en línea. También señala que los usuarios deben asegurarse de haber instalado la versión correcta de la GPU TensorFlow si quieren aprovechar la GPU. Luego, el instructor guía a los espectadores a través del proceso de desinstalación y reinstalación de bibliotecas para resolver errores específicos, y enfatiza que este proceso puede llevar algún tiempo, pero es necesario para una ejecución exitosa del entrenamiento de detección de objetos. En última instancia, muestra a los espectadores cómo verificar que hayan instalado las bibliotecas correctas y cómo monitorear el progreso de la ejecución de entrenamiento.
  
  
• 02:25:00 El instructor analiza el proceso de capacitación del modelo y la evaluación de sus métricas de rendimiento. Una vez que se inicia el entrenamiento, las métricas de pérdida aparecen después de cada 100 pasos, lo que indica que el modelo se está entrenando correctamente. Se genera la salida del modelo de entrenamiento para 2000 pasos, lo que indica que el modelo se ha entrenado correctamente con una pérdida final de 0,188. Luego, el instructor explica cómo evaluar el modelo con la biblioteca de detección de objetos de TensorFlow y ejecutar el script de evaluación, que genera métricas de rendimiento para el modelo entrenado. La precisión promedio y las métricas de recuperación se pueden ver luego con TensorBoard, una herramienta de monitoreo interactivo para TensorFlow.
  
  
• 02:30:00 El instructor guía a los espectadores a través del uso de Tensorboard para ver y realizar un seguimiento de las métricas durante el entrenamiento y la evaluación. Al navegar a la carpeta de entrenamiento, pueden ver las métricas de pérdida a lo largo del tiempo y al ir a la carpeta eval, pueden ver las métricas de evaluación, como la precisión promedio promedio, la precisión y la recuperación. Los espectadores también pueden ver el rendimiento en tiempo real del modelo al ver las imágenes y si las categoriza correctamente, y aprenden cómo exportar el gráfico después de congelarlo.
  
  
• 02:35:00 El modelo entrenado se carga desde el punto de control y la detección de objetos se realiza en una imagen. El punto de control más reciente se puede encontrar en la carpeta del modelo personalizado, que contiene la canalización y todos los puntos de control. Una vez que se importa el último punto de control, se puede seleccionar una imagen y se puede realizar la detección de objetos usando la función de detección. La función de detección también se utiliza para realizar detecciones de objetos en tiempo real desde una cámara web. A pesar del entrenamiento de solo 2000 pasos con pocas imágenes, el modelo se desempeña bien en la detección de diferentes gestos con las manos.
  
  
• 02:40:00 El instructor demuestra el rendimiento del modelo de detección de objetos en diferentes gestos con las manos, como pulgares hacia arriba, pulgares hacia abajo, viva larga y manos dobles. El rendimiento del modelo varía según el gesto de la mano y la distancia de la cámara, pero se puede ajustar agregando más imágenes al conjunto de entrenamiento. Luego, la sección pasa a congelar y convertir el modelo creando un gráfico congelado y exportándolo a TensorFlow.js y TFLite. El modelo convertido se puede usar para una aplicación web o para un proyecto de Raspberry Pi. El resultado final del modelo personalizado es similar a los modelos entrenados previamente, con punto de control, activos de modelo guardados, variables y configuración de canalización.
  
  
• 02:45:00 El orador analiza la última conversión que debe realizarse, que es la conversión a tf light. Esto se hace en dos partes: primero, el gráfico se exporta a un gráfico tf lite y luego se ejecuta usando el convertidor tf lite para generar la salida exacta necesaria para aprovecharlo. El orador señala que este es el modelo de extremo a extremo y que congelaron el gráfico, lo exportaron a tfjs y tf lite, completando así el tutorial completo para trabajar con la API de detección de objetos de tensorflow. El orador también analiza el ajuste del rendimiento y señala tres cosas clave que se pueden hacer para mejorar el rendimiento del modelo: agregar más imágenes de una clase de bajo rendimiento al conjunto de datos de entrenamiento, entrenar el modelo durante más tiempo y cambiar la arquitectura del modelo.
  
  
• 02:50:00 El presentador demuestra cómo mejorar el rendimiento de las clases de bajo rendimiento en el modelo de detección de objetos agregando imágenes de entrenamiento más relevantes. En lugar de recopilar imágenes de cada clase, el presentador recopila más imágenes de pulgares hacia arriba y pulgares hacia abajo, que no funcionaron bien con diferentes manos. El presentador importa OpenCV y actualiza el mapa de etiquetas antes de recopilar imágenes de aprobación y aprobación solamente. Las imágenes recopiladas se almacenan dentro del espacio de trabajo de Tensorflow, donde el presentador las evalúa y elimina las de mala calidad. Finalmente, el presentador agrega algunas imágenes más de pulgares hacia abajo con una mano diferente para mejorar el rendimiento del modelo.
  
  
• 02:55:00 El instructor ejecuta un código para capturar más imágenes para los gestos de pulgar hacia arriba y hacia abajo. Después de capturar las imágenes, el instructor verifica la calidad de las imágenes y decide mantener todas las imágenes con el pulgar hacia arriba y elimina algunas de las imágenes con el pulgar hacia abajo que están fuera de la pantalla. Luego, el instructor abre la herramienta LabelImg y vuelve a etiquetar las nuevas imágenes, prestando atención a la distinción entre mayúsculas y minúsculas de los nombres de las etiquetas. El instructor menciona que este paso de etiquetar imágenes es prueba y error, y uno puede evaluar y ver qué hace que el modelo funcione mejor. El instructor sugiere buscar herramientas de etiquetado automático para mejorar la eficiencia, pero aconseja prestar atención a su rendimiento para evitar cualquier necesidad de ajustes manuales.

parte 4

• 03:00:00 En esta sección, el instructor demuestra cómo etiquetar imágenes rápidamente para mejorar el entrenamiento del modelo de detección de objetos de TensorFlow. Explica que es importante copiar las imágenes etiquetadas en las carpetas de entrenamiento y prueba para evaluar la precisión del modelo. A continuación, muestra cómo entrenar un modelo "afinado" cambiando el nombre del modelo personalizado en el cuaderno de entrenamiento y detección para crear una nueva carpeta. Luego analiza cómo copiar la configuración de canalización previamente entrenada en el nuevo modelo ajustado y realizar actualizaciones en la configuración de canalización. Finalmente, configura todas las rutas necesarias utilizando el código proporcionado para crear los nuevos archivos de registro tf necesarios para el entrenamiento.
  
  
• 03:05:00 En esta sección, el instructor actualiza la configuración de canalización que define todas las rutas del mapa de etiquetas para el entrenamiento mediante la configuración estándar. Actualizar la canalización es un paso esencial, ya que allana el camino para ejecutar el script de entrenamiento. El número de pasos de entrenamiento se actualiza desde la configuración anterior a 3000 y el comando se ejecuta para crear el modelo entrenado. Después de completar los pasos de capacitación, este modelo se evalúa y compara con el modelo anterior ejecutando el código en el paso 7. Las métricas de evaluación muestran que la precisión promedio aumentó de 0,7 a 0,834 y que la detección es más rápida y precisa. Al agregar más imágenes, etiquetas adicionales y diferentes posiciones, el instructor demuestra cómo mejorar el modelo y producir un mejor modelo de detección de objetos. Finalmente, se carga el nuevo modelo y se ejecuta el código para la detección en tiempo real, que detecta objetos de forma muy rápida y precisa.
  
  
• 03:10:00 En esta sección, el instructor analiza formas de mejorar el rendimiento del modelo de detección de objetos de Tensorflow cambiando la arquitectura del modelo. Para hacer esto, el usuario debe actualizar el enlace del modelo preentrenado que desea usar en el cuaderno de detección. Al copiar y pegar el nuevo enlace y nombre, el usuario puede descargar el nuevo modelo preentrenado en su carpeta de modelos preentrenados. Sin embargo, el instructor enfatiza que se logra un mejor desempeño al mejorar la calidad de la imagen, como usar diferentes estilos de imágenes, imágenes con diferentes ángulos y entrenar por períodos más largos. El instructor también muestra cómo entrenar un modelo en Google Colab al comprimir las imágenes y archivarlas antes de importarlas al cuaderno de entrenamiento y detección en Colab.
  
  
• 03:15:00 En esta sección, el instructor guía a los espectadores a través del proceso de carga de imágenes que se utilizarán en el programa de detección de objetos TensorFlow, así como la clonación del repositorio de modelos de TensorFlow y la instalación del software de detección de objetos TensorFlow. Se trae el modelo previamente entrenado y se crea el mapa de etiquetas. Luego, el instructor establece una configuración personalizada dentro de la carpeta models/my_ssd_mobnet antes de entrenar el modelo. Se advierte al espectador que la detección de objetos en tiempo real no se puede realizar con una cámara web usando Colab, pero se puede realizar con una imagen. A medida que el espectador avanza paso a paso a través del proceso, puede evaluar su modelo para ver la precisión promedio promedio y el recuerdo promedio.
  
  
• 03:20:00 En esta sección del video, el instructor demuestra cómo detectar objetos en una imagen usando el modelo entrenado. Se carga el último punto de control y se especifica el nombre de la imagen para ejecutar el script de detección. El instructor destaca que la imagen debe ser válida y estar ubicada en la carpeta de imágenes. Después de ejecutar la celda, el modelo de detección de objetos entrenado identifica el objeto en la imagen. El instructor explica además cómo comprimir y exportar los archivos y enfatiza la necesidad de instalar la API de detección de objetos cuando se ejecuta el código localmente. La sección concluye con una vista previa de los tres proyectos que se cubrirán a continuación, incluido el uso de un microscopio para la detección de objetos, la creación de una aplicación web TensorFlow.js y la detección de sentimientos de Raspberry Pi.
  
  
• 03:25:00 En esta sección, el instructor comienza explicando el primer proyecto, que involucra el uso de un microscopio USB para detectar defectos en pequeños LED. El microscopio se trata como cualquier otra cámara y la transmisión de video se obtiene mediante la biblioteca OpenCV. El instructor demuestra cómo posicionar y hacer zoom en el microscopio utilizando el código Python y muestra la transmisión de video. Luego, la transmisión de video se usa para recopilar imágenes de entrenamiento para la detección de objetos. El objetivo de este proyecto es entrenar un modelo para detectar defectos en los LED y clasificarlos como doblados o no doblados.
  
  
• 03:30:00 En esta sección del curso completo de Detección de objetos de TensorFlow con tres proyectos, el instructor muestra cómo usar OpenCV para capturar imágenes desde una cámara web o un microscopio. Repasa las mejores prácticas para liberar el dispositivo de captura y destruir cualquier ventana de OpenCV, incluida la ejecución de "cap.release" después de cerrar cualquier captura web cv2. Luego demuestra cómo ajustar la posición y el enfoque del microscopio para capturar imágenes de pines LED y cómo crear dos nuevas carpetas para almacenar imágenes de pines defectuosos y no defectuosos. Finalmente, prueba la transmisión de la cámara web para la captura de imágenes para asegurarse de que todo funcione como se espera.
  
  
• 03:35:00 En esta sección del video, el instructor demuestra cómo recopilar imágenes de un pin defectuoso y un pin no defectuoso para la detección de objetos. Colocan los pines y ajustan el tiempo de suspensión entre capturas de imágenes, luego usan la función de suspensión para pausar entre capturas. El instructor también explica cómo etiquetar las imágenes usando la línea de etiquetado y la ubicación de la carpeta. Animan a los espectadores a pedir aclaraciones o proporcionar comentarios en la sección de comentarios o en el servidor de Discord.
  
  
• 03:40:00 En esta sección del video, el instructor recorre el proceso de etiquetado de imágenes para entrenar un modelo de detección de objetos personalizado mediante TensorFlow. Usando un microscopio, el instructor captura imágenes de clavijas defectuosas y no defectuosas y las etiqueta en consecuencia. Luego copian las imágenes en carpetas de entrenamiento y prueba antes de configurar su proceso de entrenamiento. El instructor explica cómo creará una nueva carpeta para su modelo de detección de objetos personalizado y actualizará el mapa de etiquetas para incluir las nuevas etiquetas. El código base utilizado en esta sección es bastante general, lo que permite una gran cantidad de personalización, y el instructor brinda consejos sobre el ajuste del rendimiento.
  
  
• 03:45:00 En esta sección del tutorial, la atención se centra en la creación de registros de TensorFlow, que permiten el entrenamiento del modelo. Se analizan las celdas necesarias para descargar modelos previamente entrenados y crear mapas de etiquetas, pero la atención se centra en la creación de registros de TensorFlow que permitirán el entrenamiento del modelo. Una vez que se crean los registros de TensorFlow, el modelo se actualiza con las nuevas clases y se guarda la configuración actualizada. El modelo se entrena para 2000 pasos y el nuevo modelo se prueba para detectar pines defectuosos y no defectuosos. El cuaderno se perfila y se dirige al usuario hacia celdas específicas que permiten el desarrollo de este modelo.
  
  
• 03:50:00 En esta sección, el instructor actualiza la imagen para detectar un pin defectuoso y un pin no defectuoso. El sistema detecta con éxito ambos pines con alta confianza. Sin embargo, el instructor se da cuenta de que el sistema no funciona bien con el pin defectuoso en una posición específica, lo que destaca una compensación de afinación. El instructor muestra que el marco de detección tiene parámetros que se pueden modificar para determinar el nivel de precisión de detección. Al reducir el umbral de puntaje mínimo, el sistema puede detectar el pin defectuoso razonablemente bien, pero a costa de detectar muchas otras cosas como defectuosas. El instructor prueba el sistema con pines de diferentes colores, incluido uno en el que no se entrenó, y en ángulo, lo que muestra la solidez del sistema.
  
  
• 03:55:00 En esta sección, el instructor demuestra los resultados del primer proyecto mientras usa un microscopio como método de detección de objetos. Señala los pines detectados y cómo se clasifican como defectuosos o no defectuosos al cambiar los ángulos y las posiciones de los pines. Resume el proceso del primer proyecto, que consiste en capturar y etiquetar imágenes, configurar una carpeta de microscopio y entrenar el modelo. El próximo proyecto se enfoca en construir una aplicación web para detectar la dirección de un objeto. Esto implica combinar el código del curso de detección de objetos de TensorFlow con el repositorio Github de la aplicación de detección de objetos de TensorFlow. El objetivo es detectar el movimiento arriba-abajo-izquierda-derecha que pueda implementarse como un sitio web en el futuro.

Parte 5

• 04:00:00 El instructor explica cómo configurar y restablecer las etiquetas para la detección de objetos de Tensorflow. En lugar de definir etiquetas como pulgares hacia arriba o hacia abajo, o pines defectuosos y no defectuosos, demuestran cómo definir movimientos direccionales como izquierda, derecha, arriba y abajo. Luego muestran cómo crear carpetas para las diferentes direcciones y recopilar imágenes para usarlas en la capacitación. El instructor también explica cómo etiquetar las imágenes usando LabelImg, prestando atención a los casos de imágenes y sugiere ajustes de rendimiento en caso de resultados mediocres. Finalmente, pasan a demostrar cómo etiquetar imágenes para la dirección correcta.
  
  
• 04:05:00 El instructor demuestra cómo etiquetar imágenes para usarlas en el modelo de detección de objetos. Solo se utilizan cinco imágenes por objeto/clase, pero el usuario puede ajustar el número según lo desee. El instructor advierte que este es un proceso iterativo y que está bien experimentar con diferentes cantidades de imágenes. Una vez que se etiquetan las imágenes, se clasifican en carpetas de entrenamiento y prueba, con una división de 80/20 para cada imagen/clase. Cuando se configuran las carpetas, el instructor cambia el nombre de la carpeta y crea una nueva ruta de archivo llamada "direcciones". Finalmente, el instructor señala que el entorno virtual ya está configurado y no es necesario realizar ningún paso adicional.
  
  
• 04:10:00 El mapa de etiquetas se actualiza con nuevas etiquetas para "izquierda", "derecha", "arriba" y "abajo", y se asignan identificadores únicos a cada una. Luego, las anotaciones se ejecutan para actualizar el mapa de etiquetas y generar los archivos tfrecord de prueba y entrenamiento necesarios. Luego, el modelo se entrena mediante un comando para generar el script de entrenamiento y la pérdida se calcula en 0,299. El punto de control 3 se restaura para importar las dependencias para las detecciones en tiempo real y el umbral de puntaje mínimo se establece en 90. Finalmente, la cámara web se activa para generar detecciones en tiempo real para el modelo de detección de objetos.
  
  
• 04:15:00 El instructor muestra cómo evaluar el modelo y mejorar su precisión agregando más imágenes de las clases particulares que no están funcionando bien. Lo demuestra señalando
  en diferentes direcciones usando ambas manos y viendo cómo se comporta el modelo. Luego pasa a congelar el gráfico, exportarlo y convertirlo a tensorflow.js. También explica cómo cargar el modelo en IBM Cloud Object Store y seguir los pasos que están disponibles en el repositorio de github. Luego, el instructor clona el repositorio, abre un nuevo símbolo del sistema y muestra cómo navegar a las carpetas adecuadas.
  
  
• 04:20:00 El instructor explica paso a paso cómo preparar un entorno de desarrollo para usar la detección de objetos de TensorFlow para el reconocimiento de imágenes. El instructor primero muestra cómo navegar a las carpetas necesarias y clonar el repositorio de detección de objetos de TensorFlow. Luego, el instructor muestra cómo instalar Node.js y las dependencias del repositorio. Finalmente, el instructor demuestra cómo crear un nuevo depósito de almacenamiento de objetos en la nube en IBM Cloud y cómo nombrarlo. Este proceso es necesario para usar la interfaz de usuario basada en web en secciones posteriores del video.
  
  
• 04:25:00 El instructor continúa con el paso cinco del tutorial, que consiste en crear un depósito en IBM Cloud Object Storage y cargar los archivos model.json y .bin en él. A continuación, habilita una política de acceso público, lo que permite acceder al modelo desde cualquier ubicación, y muestra cómo obtener la URL del archivo model.json para su uso posterior en la aplicación. Luego recorre el proceso de habilitar el uso compartido de recursos de origen cruzado (CORS) mediante la ejecución de comandos CLI después de instalar la CLI de IBM Cloud Object Storage.
  
  
• 04:30:00 El video muestra cómo instalar la CLI de IBM Cloud y la CLI de IBM Cloud Object Storage a través de una interfaz de línea de comando, lo que permite compartir recursos entre orígenes (CORS), lo que permite que una aplicación web acceda a una URL de otro lugar El mandato también instala IBM Cloud Storage Client y lo configura con un archivo de configuración. El video muestra cómo sustituir el nombre del depósito de un usuario en un comando que coloca la política de causa en la carpeta raíz del depósito. Finalmente, el video explica que la política de causa está contenida dentro del archivo de configuración de la nube y es parte del repositorio clonado, lo que significa que no es necesaria la creación de archivos.
  
  
• 04:35:00 El instructor explica cómo actualizar los archivos necesarios para ejecutar la aplicación web TensorFlow.js. Los pasos incluyen configurar las credenciales de Google Cloud Storage, actualizar la URL del modelo en app.js, actualizar el mapa de etiquetas en utilities.js e iniciar la aplicación con npm start. El instructor también explica cómo depurar la aplicación si no funciona, incluido el cambio de la métrica de confianza y la verificación del orden de los objetos en la matriz de resultados de detección. En general, estos pasos permiten a los usuarios personalizar la aplicación web según su caso de uso específico y asegurarse de que funcione correctamente.
  
  
• 04:40:00 El video muestra cómo averiguar dónde están los objetos y cómo manipular la matriz de resultados. Al inspeccionar el código, el usuario puede identificar que la matriz de resultados contiene cinco valores, y cada matriz tiene diferentes clases que están disponibles para una aplicación en particular. El video guía aún más al usuario sobre cómo usar correctamente cada matriz de objetos, como el objeto tres, que son clases de cuadro sin posprocesamiento representadas por números muy bajos. Luego, el video muestra cómo cambiar la métrica de confianza y los valores de puntaje y ajustar el valor del cuadro, lo que el usuario puede hacer rápidamente cambiando los valores de la matriz de cuadros.
  
  
• 04:45:00 El video concluye el segundo proyecto y continúa con el tercer proyecto, que consiste en ejecutar modelos de detección de objetos en una Raspberry Pi. El orador señala que ejecutar modelos de detección de objetos en Raspberry Pi es diferente de los dos proyectos anteriores debido a la falta de una GPU y, por lo tanto, convertirán específicamente el modelo a un formato Tensorflow lite. Recopilarán imágenes de caras felices y tristes y entrenarán a su modelo utilizando el mismo proceso que antes. Sin embargo, usarán Raspberry Pi para este proyecto y usarán un escritorio remoto para las detecciones. El video llega a su fin al mencionar la posibilidad de ejecutar varios modelos diferentes en diferentes dispositivos y alienta a los espectadores a compartir sus ideas sobre este tema.
  
  
• 04:50:00 El instructor demuestra cómo recopilar y etiquetar imágenes para un detector de sentimientos que reconoce caras felices y tristes. El proceso consiste en eliminar imágenes existentes, crear caminos para nuevas imágenes, recopilar cinco imágenes de cada emoción, etiquetar las imágenes y guardar cada objeto. El instructor recuerda a los espectadores que la distinción entre mayúsculas y minúsculas es crucial en el etiquetado y que las pantallas verdes no son necesarias para este ejercicio. Además, el instructor señala que los usuarios siempre pueden volver al directorio de imágenes para actualizar una etiqueta de imagen.
  
  
• 04:55:00 El instructor muestra cómo organizar y mover las imágenes y anotaciones recopiladas a las carpetas de capacitación y prueba. Demuestran cómo crear un nuevo modelo personalizado y etiquetar las imágenes recopiladas como felices y tristes al actualizar el mapa de etiquetas. Luego crean registros tf y copian la configuración del modelo previamente entrenado en la carpeta del modelo personalizado. Después de actualizar la configuración, entrenan el modelo mediante el comando generado, que se ejecuta en el entorno virtual, y esperan a que finalice el proceso.

parte 6

• 05:00:00 El instructor habla sobre un error común que puede ocurrir durante la ejecución de entrenamiento del modelo de opinión cuando se trabaja en una máquina con GPU. El mensaje de error indica que la GPU está completamente consumida, provocando que el sistema lo pase mal. Para resolver este problema, los usuarios deben detener cualquier cosa que pueda usar la GPU en cualquier momento y luego iniciar la ejecución de entrenamiento nuevamente. Una vez que se completa la capacitación, los usuarios pueden importar el sistema operativo y estas rutas y verificar también el último punto de control. El instructor también demuestra el uso del modelo de sentimiento en tiempo real, que es un proceso rápido y fácil una vez que se configura el sistema.
  
  
• 05:05:00 El instructor explica los pasos necesarios para crear un modelo de detección de Raspberry Pi mediante la detección de objetos de TensorFlow. El primer paso es crear los archivos TfLite siguiendo el curso de detección de objetos de TensorFlow. A continuación, los usuarios deben clonar el repositorio de detección de Raspberry Pi, descargarlo a su PC o clonarlo desde Raspberry Pi. Una vez hecho esto, los usuarios deben instalar las dependencias requeridas, copiar su modelo convertido y ejecutarlo usando el modelo detect.tf lite existente. El instructor también demuestra cómo usar un escritorio remoto en Raspberry Pi usando xrdp, lo que facilita el proceso.
  
  
• 05:10:00 El instructor recorre el proceso de instalación de todas las dependencias necesarias para trabajar con la API de detección de objetos de TensorFlow en una Raspberry Pi. El instructor demuestra cómo instalar OpenCV Python, así como varias otras dependencias necesarias para que OpenCV funcione en Raspberry Pi. A continuación, el instructor instala el tiempo de ejecución de TensorFlow Lite, que es necesario para ejecutar modelos de TensorFlow Lite en Raspberry Pi. Una vez que todas las dependencias están instaladas, ejecutan un modelo de detección de objetos de muestra en la Raspberry Pi para mostrar cómo funciona. Finalmente, el instructor explica cómo agregar un modelo personalizado y etiquetas al sistema.
  
  
• 05:15:00 El instructor analiza la detección de objetos personalizados y cómo ajustar el umbral de detección para obtener mejores resultados. La detección de objetos personalizados incluye dos etiquetas; Feliz y triste. El instructor ajusta el orden de las etiquetas a feliz como el primer objeto y triste como el segundo objeto. Al ejecutar el modelo personalizado, no detecta ningún objeto y el instructor decide reducir el umbral de detección al 20 %. Después de volver a ejecutar el comando, el modelo detecta objetos; uno grande triste y un objeto feliz. El instructor destaca la necesidad de entrenar al modelo con más imágenes para obtener mejores resultados de rendimiento. El instructor realiza un ajuste de rendimiento adicional agregando más imágenes de las clases en ejecución y entrenando al modelo por más tiempo.
  
  
• 05:20:00 El ponente explica cómo mejoró el rendimiento de su modelo de análisis de sentimientos. En primer lugar, agregó imágenes adicionales de sí mismo en diferentes ángulos, lo que aumenta las posibilidades de que el modelo se generalice bien. En segundo lugar, entrenó a su modelo para 5600 pasos más, dándole un nuevo modelo con un punto de control de índice mayor. Luego fue y convirtió ese nuevo modelo en un gráfico tf-lite congelado y lo llevó a Raspberry Pi, que usó para detectar si estaba feliz o triste. El orador demuestra que el hecho de que la pantalla verde esté arriba o abajo no afectó el rendimiento de su modelo, y pudo detectar correctamente cuándo estaba feliz o triste. El orador enfatiza el poder del ajuste del rendimiento y cómo se puede utilizar para mejorar la precisión del modelo.
  
  
• 05:25:00 Este extracto final concluye el curso Detección de objetos de Tensorflow en 5 horas con Python, con el instructor recordando a los espectadores que se comuniquen en los comentarios o a través del canal de Discord si necesitan más ayuda. El curso es beneficioso para los espectadores que desean aprender sobre la detección de objetos y desean un conocimiento profundo de Tensorflow, ya que cubre tres proyectos dentro del propio curso.

[MetaQuotes]

Reconocimiento Automático de Matrículas usando Tensorflow y EasyOCR Curso Completo en 2 Horas | Pitón

Cuaderno final: https://github.com/nicknochnack/RealTimeAutomaticNumberPlateRecognition

Código de referencia: https://github.com/nicknochnack/TFODCourse

Reconocimiento Automático de Matrículas usando Tensorflow y EasyOCR Curso Completo en 2 Horas | Pitón

El video de YouTube titulado "Reconocimiento automático de matrículas usando Tensorflow y EasyOCR Curso completo en 2 horas | Python" proporciona una guía completa para construir un sistema de reconocimiento automático de matrículas (ANPR) preciso y eficiente usando Tensorflow y EasyOCR. El sistema ANPR utiliza un sistema de dos partes: TensorFlow se utiliza para detectar la región de interés de la matrícula, mientras que EasyOCR extrae el texto de la región detectada. El video cubre una variedad de temas, desde la configuración de entornos virtuales y la instalación de las dependencias necesarias, hasta la preparación de datos para el entrenamiento y la solución de errores que pueden ocurrir durante el entrenamiento. En general, los espectadores pueden obtener una comprensión detallada de cómo construir un sistema ANPR de nivel de producción con capacidades de detección de imágenes estándar o en tiempo real.

El tutorial de YouTube sobre el reconocimiento automático de matrículas (ANPR) con TensorFlow y EasyOCR explica cómo detectar matrículas con precisión mediante la detección de objetos y cómo extraer los números de matrícula mediante OCR. El instructor analiza cómo filtrar el texto según el tamaño y las coordenadas para extraer solo la información relevante de la placa. Demuestran cómo asignar recursos de GPU y limitar el consumo de memoria para TensorFlow, extraer puntajes de imágenes, clases y cuadros que pasan el umbral de detección y aplicar OCR usando EasyOCR. Además, el video explica cómo guardar los resultados de salida en un archivo CSV y en la ruta de la carpeta para los resultados de imagen y en tiempo real. El orador enfatiza que el código está disponible para los espectadores y los alienta a pedir ayuda y compartir sus comentarios.

• 00:00:00 es el sistema OCR o reconocimiento óptico de caracteres. Este paso implica el uso de una biblioteca llamada EasyOCR para extraer el texto del feed de matrículas detectado, lo que nos permite leer y analizar el texto de las matrículas en tiempo real o en imágenes estándar. Además, el curso también cubre la construcción de un sistema más avanzado que imita los sistemas AMPR preconstruidos de grado de producción al guardar y registrar las placas detectadas previamente y sus regiones de interés. En general, el curso ofrece una guía completa para construir un sistema de reconocimiento automático de matrículas preciso y eficiente utilizando Tensorflow y EasyOCR.
  
  
• 00:05:00 esta sección, el presentador explica el sistema de dos partes utilizado para el reconocimiento automático de matrículas. La primera parte usa el modelo de detección de objetos de TensorFlow para detectar la región de interés que es la matrícula. La segunda parte usa EasyOCR para extraer el texto de la región detectada. El presentador demuestra cómo instalar los componentes necesarios, incluidos TensorFlow y EasyOCR, y proporciona un enlace al repositorio de GitHub que contiene los archivos necesarios. El presentador explica cómo clonar el repositorio y muestra el contenido de la carpeta que se crea como resultado. La carpeta contiene un archivo de cuaderno que se utiliza para el entrenamiento y la detección de la matrícula.
  
  
• 00:10:00 En esta sección del video, el presentador sigue los pasos para configurar un entorno virtual e instalar las dependencias necesarias para ejecutar el Reconocimiento automático de matrículas (ANPR) usando TensorFlow y EasyOCR. El presentador primero clona el repositorio ANPR y crea un entorno virtual con Python. Luego activa el entorno virtual e instala dependencias importantes como ipi kernel y upgrades pip. A través de estos pasos, demuestra cómo asociar el entorno virtual a un cuaderno Jupyter para aprovechar toda la potencia de ANPR.
  
  
• 00:15:00 En esta sección, el instructor guía al espectador a través del proceso de asociación de su entorno virtual a su Jupyter Notebook utilizando el entorno "ampr sys" como ejemplo. El instructor señala que esto es importante porque, a menudo, las personas que trabajan con entornos virtuales instalarán todo en su entorno, pero cuando ingresan a su Jupyter Notebook, todavía dice que no está allí. Una vez que el entorno virtual está asociado con Jupyter Notebook, el instructor guía al espectador a través del proceso de instalación de la API de detección de objetos de TensorFlow y la configuración de la estructura de carpetas para poder realizar la detección de objetos con TensorFlow.
  
  
• 00:20:00 En esta sección, el instructor comienza explicando el concepto de transferencia de aprendizaje, mediante el cual un modelo de última generación ya existente se puede ajustar para un caso de uso específico, como la detección de matrículas. Luego, el instructor procede a descargar los modelos previamente entrenados del zoológico de modelos de TensorFlow e instala la API de detección de objetos de TensorFlow ejecutando varias celdas de código. La API y sus componentes, como la carpeta de detección de objetos, se clonan en el repositorio del jardín de modelos de TensorFlow y se inicia la instalación del modelo de detección de objetos de TensorFlow. La instalación implica varias dependencias y protocolos, el sistema de búfer de protocolo, y puede tardar algún tiempo en completarse.
  
  
• 00:25:00 En esta sección, el instructor explica cómo instalar TensorFlow y su versión GPU. Instalan TensorFlow 2.4.1 y TensorFlow GPU 2.4.1, que solo es compatible con GPU Nvidia. Muestran cómo verificar que la instalación se haya realizado correctamente mediante la ejecución de un script de verificación, que debería mostrar "Ok" al final. El instructor también demuestra cómo resolver cualquier error de "módulo no encontrado" que pueda surgir durante el proceso de instalación, como instalar las bibliotecas Matplotlib y Pillow usando pip. El script de verificación asegura que todas las dependencias necesarias estén instaladas antes de pasar a la siguiente sección.
  
  
• 00:30:00 En esta sección del video, el presentador recorre la instalación de varios módulos necesarios para construir un modelo de detección de objetos, específicamente para el reconocimiento de matrículas. Encuentran varios errores durante el proceso de instalación, pero explican cómo resolverlos. Una vez que se instalan todos los módulos necesarios, incluidos TensorFlow Object Detection y EasyOCR, el presentador pasa al siguiente paso, trabaja con datos e introduce un conjunto de datos de Kaggle que contiene imágenes de automóviles y anotaciones para matrículas. Demuestran cómo descargar y preparar el conjunto de datos para su uso en el modelo.
  
  
• 00:35:00 En esta sección, el instructor explica cómo descargar los datos necesarios para el reconocimiento automático de matrículas (ANPR) y organizarlos en conjuntos de entrenamiento y prueba para la detección de objetos. Los datos, que contienen anotaciones e imágenes correspondientes, se descargan de Kaggle y se descomprimen en la carpeta ANPR. Se crean dos carpetas nuevas dentro de la carpeta de imágenes, una para entrenamiento y otra para prueba, y las imágenes descargadas se copian en la carpeta de entrenamiento. Las anotaciones también se dividen en conjuntos de entrenamiento y prueba, y las anotaciones de entrenamiento se colocan en la carpeta del tren junto con sus imágenes correspondientes. El propósito de estos conjuntos separados es entrenar el modelo de detección de objetos en un conjunto de datos y probarlo en un conjunto independiente para evaluar su rendimiento.
  
  
• 00:40:00 En esta sección, el video analiza el proceso de preparación de los datos para entrenar un modelo de detección de matrículas. El presentador explica que descargaron imágenes de matrículas de Kaggle y copiaron las anotaciones correspondientes en dos nuevas carpetas, "entrenamiento" y "prueba", dentro de su espacio de trabajo de TensorFlow. El siguiente paso es entrenar el modelo de detección de objetos, lo que implica actualizar las etiquetas, crear registros tf, preparar la configuración y, finalmente, entrenar el modelo. El presentador usa un "mapa de etiqueta" para identificar la etiqueta que usará, "licencia", y luego crea un registro tf, que es el formato requerido por el modelo de detección de objetos. El proceso se describe como sencillo y se proporciona un script para generar el registro tf.
  
  
• 00:45:00 En esta sección, el video cubre cómo preparar los datos para el entrenamiento con TensorFlow y EasyOCR. La secuencia de comandos discutida aquí convierte los datos sin procesar, incluidas las imágenes y las anotaciones, en un formato de registro tf, pero debe actualizarse debido al formato ligeramente diferente de las anotaciones en el conjunto de datos de Kaggle. El video muestra cómo solucionar los errores que surgen debido a esta discrepancia, incluida la instalación de los módulos que faltan, el cambio del índice para recoger las métricas correctas del cuadro delimitador y la copia de la configuración del modelo preentrenado en la carpeta de entrenamiento.
  
  
• 00:50:00 En esta sección, el orador repasa los detalles de la canalización del modelo preentrenado, que contiene diferentes líneas de configuraciones que deben actualizarse antes de entrenar el modelo. El orador demuestra cómo copiar el archivo de configuración actualizado que garantiza que los parámetros estén actualizados y ejecutar el comando de entrenamiento para entrenar el modelo. También mencionan la importancia de ejecutar el comando de forma externa para ver el progreso correctamente y cómo activar un entorno virtual para ejecutar el comando. Finalmente, explican cómo solucionar un error estándar que puede ocurrir al instalar el modelo.
  
  
• 00:55:00 En esta sección del curso, el instructor soluciona los errores que pueden ocurrir durante el entrenamiento. Demuestra cómo resolver problemas específicos, como un error de valor relacionado con un cambio de tamaño de matriz y punto numpy, un error de módulo no encontrado para cv2, un error de módulo no encontrado para complementos de tensorflow y un error de módulo no encontrado para gin. El instructor explica que estos errores no son infrecuentes y que es fundamental instalar las bibliotecas necesarias para solucionarlos. Una vez que se entrena el modelo, el instructor muestra cómo leer las métricas de pérdida y cómo encontrar el punto de control del modelo entrenado más reciente.
  
  
• 01:00:00 En esta sección del videotutorial de Reconocimiento Automático de Matrículas usando Tensorflow y EasyOCR, el instructor explica cómo detectar matrículas a partir de imágenes o en tiempo real usando el mismo modelo. Al cambiar el nombre del archivo de imagen, el modelo puede detectar y clasificar con precisión diferentes tipos de placas. Se ha descubierto que este método funciona mucho mejor a través de la detección de objetos que aprovechar las técnicas tradicionales de visión por computadora, ya que los formatos de las placas pueden variar. El modelo también puede detectar placas a partir de una transmisión de video en vivo o al sostener un teléfono frente a la placa del automóvil. El instructor enfatiza que el método es eficiente y es un buen comienzo para construir un detector de matrículas, y el siguiente paso sería aplicar componentes de OCR para extraer datos significativos de la imagen.
  
  
• 01:05:00 En esta sección, el video tutorial explica cómo usar la biblioteca de código abierto EasyOCR para detectar y extraer texto de una imagen para identificar un número de matrícula. El tutorial señala que, si bien hay modelos de OCR más precisos disponibles, EasyOCR se usa cuando se ejecuta en PyTorch, lo que requiere un poco de espacio para que la GPU pueda ejecutarlo junto con TensorFlow sin consumir toda la memoria de la GPU. El tutorial muestra cómo asignar recursos de GPU y limitar el consumo de memoria para TensorFlow para permitir que EasyOCR funcione sin problemas.
  
  
• 01:10:00 En esta sección, el ponente explica cómo cargar las rutas de archivo y las etiquetas necesarias para el Reconocimiento automático de matrículas (ANPR) utilizando TensorFlow y EasyOCR, y cómo instalar EasyOCR y PyTorch con aceleración CUDA. Demuestran que después de cargar una imagen de ejemplo y realizar ANPR, los números de placa y los puntajes de detección se almacenan en una variable llamada "detecciones", que luego se usan para aplicar OCR usando EasyOCR. Se establece un umbral de detección en 0,7, lo que permite que solo se procesen más las detecciones con puntuaciones superiores a 0,7.
  
  
• 01:15:00 En esta sección, el instructor explica cómo extraer puntajes, clases y cuadros de imágenes que pasan el umbral de detección utilizando unas pocas líneas de código. Demuestran cómo recorrer cada valor en la matriz de puntuación de detección y solo devolver las puntuaciones que superan el umbral. También aplican filtros a los cuadros y clases para garantizar que tengan el tamaño y el formato correctos para la cámara web. Finalmente, toman el ancho y el alto de la imagen para recalcular las coordenadas del cuadro y aplican filtros en la imagen para determinar la región de interés.
  
  
• 01:20:00 En esta sección, el video muestra cómo extraer la región de interés de la imagen y aplicar el reconocimiento óptico de caracteres (OCR) para extraer los resultados de la placa. Primero, los parámetros de ancho y alto de la imagen se obtienen usando image.shape. Para extraer el ROI, recorra cada cuadro en la variable boxes, que representa las coordenadas de la detección, y filtre la región de interés. Finalmente, se aplica OCR al ROI mediante EasyOCR y los resultados se imprimen en la consola. El video guía al espectador a través del proceso de configuración del lector EasyOCR, pasando por los parámetros de idioma y analizando la imagen para extraer los resultados de la placa.
  
  
• 01:25:00 En esta sección, el presentador analiza cómo extraer efectivamente la placa impresa o el texto de la placa mediante OCR (reconocimiento óptico de caracteres). Muestran una imagen de ejemplo en la que hay texto adicional además del número de placa, lo que puede confundir al lector de OCR. Para resolver este problema, el presentador sugiere filtrar los resultados según el tamaño y las coordenadas. Demuestran cómo escribir una función para hacer este filtrado y aplicarlo a la imagen para obtener el texto apropiado. Los resultados muestran que el lector OCR puede extraer con precisión el número de placa, aunque todavía hay margen de mejora con el modelo OCR.
  
  
• 01:30:00 En esta sección, el orador presenta una nueva función llamada "texto de filtro". Esta función toma tres argumentos: la región, el resultado de OCR y el umbral de la región. La región representa la imagen, el resultado de OCR representa el texto extraído de EasyOCR y el umbral de la región es el umbral de tamaño para detectar las regiones de la matrícula. La función recorre los resultados de OCR, extrae la longitud y el ancho de cada uno, los multiplica y luego los compara con el umbral de la región. Si pasa este filtro, se considera texto y su región se almacena en una variable llamada "placa". El orador también explica algunas partes del código que calculan el tamaño de la región e ilustran cómo funciona el filtro.
  
  
• 01:35:00 En esta sección, el autor muestra cómo filtrar el texto en las imágenes de manera efectiva usando el motor OCR. El algoritmo filterText permitirá al usuario especificar un umbral para la región, que filtrará solo los bloques de texto que cumplan o excedan este umbral. Usan esta función para extraer los componentes que necesitan en lugar de recuperar todo de la placa. También han creado una función OCR_it que combina el filtro OCR y los componentes OCR, y se puede aplicar a cualquier imagen al pasar la imagen y las detecciones con los umbrales correspondientes.
  
  
• 01:40:00 En esta sección, el instructor prueba su método de reconocimiento óptico de caracteres (OCR) pasando una imagen a través de su función "ocr_it" con umbrales específicos de detección y región. El método es capaz de extraer con precisión la matrícula y su región en la imagen. Luego demuestran la aplicación del método OCR en tiempo real para detectar matrículas utilizando un bloque de prueba y excepción y un nuevo código que llama a la función OCR para cada detección válida. El instructor prueba la detección en tiempo real en su teléfono y muestra que detecta y extrae con precisión el texto de la matrícula, aunque los resultados no son perfectos y podrían necesitar algunos ajustes.
  
  
• 01:45:00 En esta sección del video, el instructor explica cómo guardar los resultados de salida del sistema OCR que han desarrollado. Crean una nueva función llamada "save_results" que toma el texto, la región, el nombre del archivo y la carpeta como parámetros de entrada. Luego usan la biblioteca uuid para generar un nombre de archivo único y la biblioteca csv para guardar los resultados de salida en un archivo csv. También utilizan la biblioteca cv2 para escribir la imagen en la carpeta seleccionada. Finalmente, envuelven el código y lo prueban.
  
  
• 01:50:00 En esta sección del video, el instructor demuestra cómo configurar un archivo CSV y una ruta de carpeta para escribir todos los resultados de imágenes o regiones. Crean una nueva carpeta llamada discovery_images, donde se escribirán todos los resultados de las imágenes. El instructor muestra cómo pasar el nombre del archivo CSV y la ruta de la carpeta, y luego prueba el código para guardar los resultados. Establecieron un método de guardado de resultados para escribir los resultados en la carpeta creada, que incluye el nombre de la imagen y la matrícula. Luego, el instructor demuestra cómo ejecutar el código en tiempo real para guardar los resultados mientras se realizan las detecciones. Finalmente, prueban el código, lo que da como resultado la salida precisa de las imágenes mientras se guardan los resultados en tiempo real.
  
  
• 01:55:00 En esta sección, el locutor informa a los espectadores que la función OCR construida y el algoritmo de filtrado aplicado en tiempo real está disponible para ellos. Alienta a los espectadores a pedir ayuda si enfrentan alguna dificultad y menciona que el código estará disponible en GitHub para que lo usen. Finalmente, agradece a los espectadores por sintonizar, les pide que le den me gusta, se suscriban y comenten y cierra la sesión.

[MetaQuotes]

Aprendizaje por refuerzo en 3 horas | Curso completo usando Python

Código: https://github.com/nicknochnack/ReinforcementLearningCourse

Aprendizaje por refuerzo en 3 horas | Curso completo usando Python

00:00:00 - 01:00:00 El curso en video "Aprendizaje por refuerzo en 3 horas" cubre una variedad de temas en el aprendizaje por refuerzo, incluida la implementación práctica y la reducción de la brecha entre la teoría y la práctica. El curso cubre todo, desde la configuración del entorno RL hasta la creación de entornos personalizados, con un enfoque en la capacitación de agentes de aprendizaje por refuerzo y su evaluación mediante diferentes algoritmos y arquitecturas. Se discuten las aplicaciones populares de RL, como la robótica y los juegos, así como las limitaciones de RL, como su suposición de que los entornos son markovianos y el potencial de un entrenamiento inestable. El curso utiliza Stable Baselines, una biblioteca RL de código abierto y OpenAI Gym para crear entornos simulados. El instructor explica los diferentes tipos de espacios utilizados para representar acciones y valores que los agentes pueden tomar en un entorno, así como diferentes algoritmos de RL como A2C y PPO. Se enfatiza la importancia de comprender el entorno antes de implementar los algoritmos, y se guía a los usuarios a través de la configuración de la plataforma informática para el aprendizaje por refuerzo, la elección de los algoritmos de RL apropiados y la capacitación y prueba del modelo.

01:00:00 - 02:00:00 Este video de YouTube ofrece un curso de tres horas sobre el aprendizaje por refuerzo con Python. El instructor explica los componentes básicos del aprendizaje por refuerzo, incluido el agente, el entorno, la acción y la recompensa. La sección analiza cómo definir un entorno, entrenar un modelo mediante el aprendizaje por refuerzo y ver los registros de entrenamiento mediante TensorBoard para monitorear el proceso de entrenamiento. El disertante también cubre otros temas, como guardar y recargar un modelo entrenado, probar y mejorar el rendimiento del modelo, definir una arquitectura de red para un actor personalizado y una función de valor en una red neuronal, y usar el aprendizaje por refuerzo para jugar el juego Breakout de Atari. Además, el curso incluye tres proyectos que los alumnos construirán utilizando técnicas de aprendizaje de refuerzo, incluido el juego Breakout en Atari, la construcción de un automóvil de carreras para conducción autónoma y la creación de entornos personalizados utilizando los espacios OpenAI Gym.

02:00:00 - 03:00:00 Este video de YouTube titulado "Aprendizaje por refuerzo en 3 horas | Curso completo usando Python" cubre varios temas relacionados con el aprendizaje por refuerzo. El instructor demuestra cómo entrenar a un agente de aprendizaje por refuerzo para los juegos de Atari y la conducción autónoma utilizando el entorno de un coche de carreras. También presentan varias dependencias de gimnasio OpenAI, ayudantes y líneas de base estables, así como diferentes tipos de espacios para el aprendizaje por refuerzo. Además, el video cubre cómo crear un entorno personalizado para el aprendizaje por refuerzo, definir el estado del entorno, sus espacios de observación y acción, probar y entrenar el modelo y guardar el modelo entrenado después del aprendizaje. El instructor también analiza la importancia de entrenar modelos durante períodos más largos para un mejor rendimiento y alienta a los espectadores a comunicarse si encuentran alguna dificultad.

• 00:00:00 En esta sección del video, el presentador presenta el curso de aprendizaje por refuerzo y describe los diferentes temas que se cubrirán a lo largo del curso. Él explica que el curso está diseñado para cerrar la brecha entre la teoría y la implementación práctica, y cubre todo, desde la configuración del entorno RL hasta la creación de entornos personalizados. El presentador brinda una descripción general de alto nivel del aprendizaje por refuerzo, sus aplicaciones y algunas de sus limitaciones. El curso brindará experiencia práctica en la capacitación de agentes de aprendizaje por refuerzo y las pruebas y evaluaciones utilizando diferentes algoritmos y arquitecturas, además de cubrir tres proyectos diferentes centrados en el entorno de ruptura, el entorno autónomo y los entornos personalizados.
  
  
• 00:05:00 En esta sección del video sobre "Aprendizaje por refuerzo en 3 horas", el instructor explica los conceptos fundamentales del aprendizaje por refuerzo. Un agente de aprendizaje por refuerzo aprende en función de las recompensas que obtiene del entorno al realizar diferentes acciones. El agente observa el entorno para maximizar sus recompensas con el tiempo tomando ciertas decisiones. El instructor también analiza algunas aplicaciones prácticas del aprendizaje por refuerzo, como la conducción autónoma, el comercio de valores y la búsqueda de arquitectura de redes neuronales.
  
  
• 00:10:00 En esta sección, el video analiza algunas de las aplicaciones populares del aprendizaje por refuerzo, incluida la robótica, donde se pueden usar entornos simulados para entrenar robots para realizar tareas específicas. El video también menciona los juegos como otra aplicación popular donde la función de recompensa puede diferir cada vez, lo que lo convierte en un entorno adecuado para el aprendizaje por refuerzo. También se analizan las limitaciones del aprendizaje por refuerzo, incluida la suposición de que el entorno es markoviano y el hecho de que el entrenamiento puede llevar mucho tiempo y ser inestable. Se analiza la configuración del modelo de aprendizaje por refuerzo, que incluye la instalación de la biblioteca de líneas base estables de OpenAI y el uso de sus útiles guías y documentación.
  
  
• 00:15:00 En esta sección, el instructor presenta el curso y describe los 10 pasos diferentes que se cubrirán. El primer paso es importar y cargar las dependencias necesarias, incluidas las líneas base estables, una biblioteca de código abierto para el aprendizaje por refuerzo. El instructor explica los diferentes algoritmos disponibles dentro de la biblioteca y los beneficios de usar PPO (optimización de política próxima). Las dependencias también incluyen OS, para la funcionalidad del sistema operativo, y gym, para construir y trabajar con entornos. En general, el proceso es sencillo y requiere solo unas pocas líneas de código para comenzar con líneas de base estables.
  
  
• 00:20:00 En esta sección, el instructor analiza las dependencias y los entornos necesarios para el aprendizaje por refuerzo. Introducen Stable Baselines, que permite un aprendizaje automático más rápido a través de la vectorización de entornos, y el envoltorio Dummy Vec Env. También explican cómo se puede usar OpenAI Gym para construir entornos simulados, lo que puede reducir costos y permitir una producción de modelos más rápida. Proporcionan ejemplos de entornos reales, como un robot, así como entornos simulados, como OpenAI Gym, que tiene mucha documentación y soporte.
  
  
• 00:25:00 En esta sección del video, el instructor analiza el estándar para crear entornos de aprendizaje por refuerzo, que es OpenAI Gym. Explica que OpenAI Gym proporciona entornos preconstruidos, incluidos aquellos basados en robots reales como Fetch Robot y Shadow Hand Robot. Explica además los diferentes tipos de espacios que admite OpenAI Gym, incluidos box, discreto, tupla, dict, multibinario y multidiscreto. Señala que estos espacios se utilizan para representar los diferentes tipos de valores o acciones que los agentes pueden realizar en el entorno. Luego, el instructor presenta el entorno de control clásico, específicamente el problema CartPole, como un ejemplo que usará para entrenar a un agente de aprendizaje por refuerzo. El objetivo es equilibrar una viga moviéndola hacia la izquierda o hacia la derecha mediante dos acciones.
  
  
• 00:30:00 En esta sección, el instructor explica cómo cargar y probar un entorno usando OpenAI Gym. Comienzan instanciando el entorno CartPole-v0 utilizando dos líneas de código. Luego, demuestran cómo probar el entorno recorriendo múltiples episodios y usando env.reset() para obtener el conjunto inicial de observaciones. Estas observaciones se pasarán luego a un agente de aprendizaje por refuerzo para determinar la mejor acción para maximizar la recompensa. El instructor señala la importancia de comprender el entorno antes de implementar cualquier algoritmo.
  
  
• 00:35:00 En esta sección, el instructor explica el código utilizado para muestrear un entorno en el aprendizaje por refuerzo. El código establece un número máximo de pasos para el entorno, configura un contador de puntuación y genera una acción aleatoria basada en el espacio de acción definido por el entorno. Las observaciones devueltas por el entorno después de cada acción van acompañadas de una recompensa y un valor que indica si el episodio se ha realizado. Los resultados se imprimen y el entorno se cierra después de la prueba. El instructor también explica el concepto de un espacio de observación y demuestra cómo se puede muestrear.
  
  
• 00:40:00 En esta sección, el instructor explica las dos partes del entorno, el espacio de acción y el espacio de observación, y cómo se representan en la documentación de OpenAI Gym. El espacio de observación consta de cuatro valores que representan la posición del carro, la velocidad, el ángulo del poste y las velocidades angulares del poste. Por otro lado, el espacio de acción tiene dos acciones posibles, cero o uno, donde cero empuja el carro hacia la izquierda y uno empuja el carro hacia la derecha. La sección también destaca los diferentes tipos de algoritmos en el aprendizaje por refuerzo, basados en modelos y sin modelos, y en qué se diferencian. El instructor se enfoca en el aprendizaje por refuerzo sin modelo y profundiza en los algoritmos A2C y PPO, que se utilizarán en la etapa de entrenamiento.
  
  
• 00:45:00 En esta sección del video, el instructor explica cómo elegir el algoritmo de aprendizaje por refuerzo adecuado según el espacio de acción del entorno que se utiliza. Continúa explicando los diferentes tipos de algoritmos disponibles en Stable Baselines, como A2C, DDPG, DQN, HER, PPO, SAC y TD3, y con qué espacios de acción funcionan mejor. El instructor también analiza las métricas de capacitación que se deben considerar durante la capacitación, como las métricas de evaluación, las métricas de tiempo, las métricas de pérdida y otras métricas. Les recuerda a los usuarios que las líneas de base estables se pueden instalar con o sin aceleración de GPU y proporciona instrucciones para instalar PyTorch si se desea aceleración de GPU.
  
  
• 00:50:00 En esta sección, el instructor explica cómo configurar la plataforma de cómputo para el aprendizaje por refuerzo, que es fundamental para aquellos que desean aprovechar la aceleración de la GPU. CUDA y cuDNN solo son compatibles con GPU NVIDIA, por lo que los usuarios deben asegurarse de tener una GPU NVIDIA para usar CUDA y aprovechar la aceleración de GPU. Por otro lado, las GPU AMD son compatibles con RockM, un paquete beta solo disponible en Linux. El instructor también enfatiza que el aprendizaje profundo tradicional puede mejorar más el rendimiento al usar una GPU que el aprendizaje por refuerzo. Finalmente, el instructor define la ruta del registro e instancia el algoritmo y el agente.
  
  
• 00:55:00 En esta sección, el instructor demuestra cómo envolver un entorno no vectorizado dentro de un entorno vectorizado ficticio usando una función lambda. Luego, definen el modelo, que es el agente que se entrenará, como PPO y pasan a través de la política, el entorno, el detallado y la ruta de registro de tensorboard como argumentos. El instructor continúa explicando los diversos hiperparámetros que se pueden pasar al algoritmo PPO. Finalmente, demuestran cómo entrenar el modelo usando la función model.learn y pasando por la cantidad de pasos de tiempo para entrenarlo, que en este ejemplo se establece en 20,000. Una vez que se entrena el modelo, el instructor lo prueba y verifica las métricas de entrenamiento.

Parte 2

• 01:00:00 En esta sección del video, el instructor muestra cómo guardar y volver a cargar un modelo entrenado. El modelo se guarda usando la función `model.save()` y se define una ruta para ubicar el modelo guardado. Luego, el instructor demuestra cómo eliminar el modelo guardado y recargarlo usando la función `ppo.load()`. El siguiente paso es probar el modelo entrenado para ver cómo funciona. El instructor explica que las métricas de implementación dependen del algoritmo utilizado para el entrenamiento y muestra que el algoritmo 'A2C' proporciona estas métricas durante el entrenamiento, mientras que el algoritmo 'PPO' requiere un comando explícito para generar estas métricas.
  
  
• 01:05:00 En esta sección, el video explica cómo usar el método de evaluación_política para probar el rendimiento del modelo y determinar si el modelo PPO se considera "resuelto" en este caso particular. El método de evaluación_política es una forma de probar qué tan bien se está desempeñando un modelo, y el modelo se considera resuelto si obtiene un puntaje promedio de 200 o más. El método pasa por el modelo, el entorno, cuántos episodios probar y si se requiere renderizado o no. La recompensa promedio y la desviación estándar en esa recompensa son los valores que obtiene de la política de evaluación, y el cierre del entorno se realiza mediante emv.close. Finalmente, el video destaca cómo implementar el modelo en una función encapsulada.
  
  
• 01:10:00 En esta sección, el instructor demuestra cómo usar las observaciones del entorno para predecir la mejor acción usando el agente, para maximizar las recompensas. El bloque de código muestra cómo realizar cambios clave para usar model.predict en lugar de env.actionspace.sample para realizar acciones usando el modelo. El instructor muestra que el agente realiza mejor que los pasos aleatorios y equilibra el poste. El código también muestra las observaciones pasadas a la función model.predict, con dos valores devueltos, la acción del modelo y el siguiente estado. El primer valor se usa aquí para determinar la mejor acción para el agente.
  
  
• 01:15:00 En esta sección, el instructor explica los componentes centrales del aprendizaje por refuerzo: el agente, el entorno, la acción y la recompensa. Demuestra cómo definir un entorno y entrenar un modelo utilizando el aprendizaje por refuerzo para acumular un valor de uno cada vez manteniendo el poste en posición vertical y sin caerse. El instructor también muestra cómo ver los registros de capacitación usando TensorBoard para monitorear el proceso de capacitación.
  
  
• 01:20:00 En esta sección del video, el instructor explica cómo usar TensorBoard en un cuaderno de Júpiter para ver las métricas de entrenamiento de un modelo de aprendizaje por refuerzo. Demuestra cómo ejecutar el comando TensorBoard usando un comando mágico y muestra cómo especificar la ruta del registro de entrenamiento. El instructor también muestra cómo ver las métricas de entrenamiento, como fotogramas por segundo, pérdida de entropía, tasa de aprendizaje y pérdida de gradiente de políticas, en TensorBoard. Él enfatiza que la recompensa promedio es la métrica más importante para monitorear al ajustar el rendimiento del modelo. Concluye invitando a la retroalimentación y los comentarios de los espectadores.
  
  
• 01:25:00 En esta sección, el video analiza dos métricas clave para determinar el rendimiento de un modelo de aprendizaje por refuerzo: las métricas de recompensa y la duración promedio del episodio. El video también proporciona tres estrategias para mejorar el rendimiento del modelo si no funciona bien, incluido el entrenamiento durante un período más largo, el ajuste de hiperparámetros y la exploración de diferentes algoritmos. Luego, la sección profundiza en las devoluciones de llamada, los algoritmos alternativos y las arquitecturas, y analiza específicamente cómo configurar una devolución de llamada para detener el entrenamiento una vez que se alcanza un umbral de recompensa y explorar diferentes arquitecturas y algoritmos de redes neuronales. El video también destaca la importancia de usar devoluciones de llamada para modelos grandes que requieren un tiempo de entrenamiento más prolongado.
  
  
• 01:30:00 En esta sección, el instructor explica cómo usar las devoluciones de llamada en el aprendizaje por refuerzo para una capacitación más flexible y eficiente. En el ejemplo se utilizan dos devoluciones de llamada: la devolución de llamada de parada y la devolución de llamada de evaluación. La devolución de llamada stop especifica la recompensa promedio después de la cual debe detenerse el entrenamiento, mientras que la devolución de llamada eval evalúa el mejor modelo nuevo y verifica si ha superado el umbral de recompensa. El instructor también demuestra cómo cambiar la política especificando una nueva arquitectura de red neuronal. En general, las devoluciones de llamada brindan un mayor control sobre los modelos de aprendizaje por refuerzo, lo que permite una capacitación más personalizada y efectiva.
  
  
• 01:35:00 En esta sección, el orador analiza el proceso de especificación de una arquitectura de red para un actor personalizado y una función de valor en una red neuronal. Esto se puede hacer simplemente cambiando el número de unidades y capas y pasándolo al modelo. El orador también enfatiza que los extractores de funciones personalizadas se pueden definir y muestra cómo usar un algoritmo alternativo como DQN en lugar de PPO, y destaca otros algoritmos disponibles en Stable Baselines. El orador concluye mostrando el modelo DQN entrenado.
  
  
• 01:40:00 En esta sección, el instructor analiza los proyectos que los alumnos construirán utilizando técnicas de aprendizaje por refuerzo. Comenzarán con Project One, que es el juego Breakout en Atari. Luego, también abordarán el Proyecto Dos, donde utilizarán el aprendizaje por refuerzo para construir un automóvil de carreras para simular la conducción autónoma. Por último, trabajarán en el Proyecto Tres, que consiste en crear entornos personalizados utilizando los espacios de OpenAI Gym. El instructor también explica cómo la importación de bibliotecas y dependencias necesarias para los proyectos es similar a las del curso principal, y solo necesitarán usar diferentes algoritmos según el proyecto.
  
  
• 01:45:00 En esta sección, el video instructor explica cómo configurar el entorno de Atari para el aprendizaje por refuerzo en Python. Debido a cambios recientes, los usuarios deben descargar archivos sin procesar de atarimania.com y extraerlos en una carpeta para poder usar el entorno. Después de instalar los paquetes y dependencias necesarios, los usuarios pueden probar el entorno utilizando las funciones "emv.reset" y "emv.action_space". El espacio de observación es una caja que representa una imagen con las dimensiones 210x160x3. El instructor también demuestra cómo probar un modelo dentro del entorno.
  
  
• 01:50:00 En esta sección, el instructor muestra el código para jugar Breakout usando acciones aleatorias y señala que entrenar al modelo puede llevar mucho tiempo. Para agilizar el entrenamiento, el instructor vectoriza el entorno y entrena cuatro entornos diferentes al mismo tiempo. El entorno utilizado es el entorno basado en imágenes, a diferencia de la versión RAM de Breakout, porque se utilizará la política de CNN. Se muestra el código para configurar el modelo, incluida la especificación de la ruta de registro y el algoritmo A2C con la política CNN.
  
  
• 01:55:00 En esta sección, el video instructor usa el aprendizaje por refuerzo para entrenar a un modelo para que juegue el juego de Atari "Breakout". El modelo utiliza una política de red neuronal convolucional (CNN), que es más rápida de entrenar que una política de perceptrón multicapa. El entorno se define mediante la función make_atari de OpenAI Gym y la vectorización se utiliza para acelerar el proceso de entrenamiento. El modelo se entrena para 100 000 pasos y, después de guardar y volver a cargar el modelo, se evalúa mediante el método de política de evaluación. El modelo final logra una recompensa de episodio promedio de 6,1 con una desviación estándar de 1,9, una mejora significativa con respecto a un agente aleatorio. El instructor también proporciona información sobre un modelo previamente entrenado que ha sido entrenado para 300 000 pasos y cómo cargarlo y probarlo.

parte 3

• 02:00:00 En esta sección, el instructor analiza cómo manejar los problemas de congelamiento cuando se trabaja con el entorno, específicamente Atari. Si el entorno se congela, la computadora portátil debe reiniciarse y el kernel debe reiniciarse después de guardar el modelo. Luego, el instructor demuestra cómo entrenar a un agente de aprendizaje de refuerzo para la ruptura, recorriendo el proceso de importar dependencias, instalar ROM de Atari, vectorizar el entorno para entrenar en cuatro entornos de Atari simultáneamente, entrenar al agente y finalmente evaluar y guardar el modelo. El instructor también muestra el impacto de entrenar el modelo por más tiempo y hace que los modelos entrenados estén disponibles en el repositorio de Github para que los alumnos los prueben por su cuenta.
  
  
• 02:05:00 En esta sección del video sobre el aprendizaje por refuerzo en tres horas, el instructor comienza mostrando los resultados del Proyecto 1, que implicó entrenar a un modelo para jugar un juego usando el aprendizaje por refuerzo. El modelo funcionó significativamente mejor que los modelos anteriores, con una recompensa media en 50 episodios de 22,22 y una desviación estándar de 9,1. Luego, el instructor presenta el Proyecto 2, que implica el uso del aprendizaje por refuerzo para la conducción autónoma utilizando el entorno de un automóvil de carreras. Para configurar el entorno, el instructor explica que se debe instalar swig y se deben instalar dos nuevas dependencias, box 2d y piglet. Luego, el instructor pasa por el proceso de probar el entorno e importar las dependencias necesarias.
  
  
• 02:10:00 En esta sección, el video analiza el espacio de observación y acción del entorno de carreras de autos para el aprendizaje por refuerzo. El espacio de observación es una imagen de 96 por 96 por 3 con valores entre 0 y 255, mientras que el espacio de acción está entre menos uno y uno para tres valores diferentes. La función de recompensa es 0,1 negativo para cada cuadro y más 1000 dividido por n para cada mosaico de pista visitado. El juego se considera resuelto cuando el agente puede obtener constantemente 900 o más puntos, lo que puede llevar algún tiempo lograr con entrenamiento. Luego, el video pasa a entrenar un modelo usando el algoritmo PPO y muestra cómo probar el entorno de carrera usando el modelo entrenado.
  
  
• 02:15:00 En esta sección, el instructor configura el entorno para el auto sin conductor usando OpenAI Gym y lo envuelve dentro de un contenedor Vectorize Environment ficticio. Luego, el agente y el modelo se especifican mediante el algoritmo PPO y el modelo se entrena para 100 000 pasos. El modelo guardado se carga y evalúa en el entorno y, a pesar de la falta de tracción del automóvil de alta potencia, no avanza, sino que gira y hace rosquillas. Finalmente, el entorno se cierra y el instructor carga un modelo entrenado para 438,000 pasos para probar.
  
  
• 02:20:00 En esta sección, el instructor carga un modelo de automóvil autónomo que fue entrenado para 438,000 pasos y lo prueba en la pista. Aunque es más lento, sigue la pista y obtiene una puntuación mucho más alta que el modelo anterior entrenado para 100.000 pasos. El instructor explica que entrenar agentes de aprendizaje por refuerzo durante un período de tiempo más largo puede producir modelos mucho mejores e, idealmente, este modelo debería haber sido entrenado para 1-2 millones de pasos para funcionar de manera óptima. Demuestra cómo probar el modelo usando un fragmento de código del tutorial principal, que muestra que, incluso cuando se entrena solo con imágenes, el modelo puede navegar con éxito por la pista. Finalmente, el instructor entrenó este modelo para dos millones de pasos adicionales, mejorando su rendimiento y alcanzando una recompensa estimada de alrededor de 700.
  
  
• 02:25:00 En esta sección, el instructor carga y ejecuta un modelo que funciona significativamente mejor que los modelos anteriores que entrenó, a pesar de que de vez en cuando da vueltas en las esquinas. Muestra el puntaje de evaluación del modelo, que alcanzó hasta 800 puntos, una mejora significativa con respecto a los modelos anteriores. Señala que este modelo se entrenó durante más tiempo y tenía una desviación estándar alta. Luego, el instructor presenta el último proyecto, que implica el uso de líneas base estables para el aprendizaje por refuerzo en entornos personalizados. Importa las dependencias necesarias y alienta a los espectadores a comunicarse si encuentran alguna dificultad.
  
  
• 02:30:00 En esta sección del video, el instructor repasa las diversas dependencias del gimnasio o las dependencias del gimnasio OpenAI, los ayudantes y las cosas de referencia estables que se usarán en el curso de aprendizaje de refuerzo. Importan gym, que es la importación estándar, clase de entorno gym de env, y los diferentes tipos de espacios, como discreto, box, dict, tuple, multi-binary, multi-discrete. El instructor explica cómo usar cada uno de estos espacios y cómo se pueden usar para diferentes propósitos. El instructor también repasa los diferentes ayudantes que se importaron, como numpy, random y os, y el material de referencia estable, que incluye ppo, common.vec_env, dummy_vec_nv y la función de evaluación_política.
  
  
• 02:35:00 En esta sección del video, el presentador analiza los diferentes tipos de espacios disponibles en OpenAI Gym para el aprendizaje reforzado. Estos espacios incluyen discreto, caja, tupla, dict, multibinario y multidiscreto. El presentador proporciona ejemplos y explicaciones para cada uno de estos espacios. Luego, el video continúa discutiendo la construcción de un entorno simulado para entrenar a un agente para regular la temperatura de una ducha. El objetivo final es alcanzar una temperatura entre 37 y 39 grados, pero el agente no lo sabe a priori y debe aprender a base de ensayo y error.
  
  
• 02:40:00 En esta sección, el instructor construye un armazón para un entorno de ducha implementando las cuatro funciones clave. Estas funciones son init, step, render y reset. La función init inicializa el entorno definiendo el espacio de acción, el espacio de observación y el estado inicial. La función de paso toma una acción y la aplica al entorno. La función de renderizado muestra el entorno. La función de restablecimiento restablece el entorno a su estado inicial. El instructor también establece una duración de episodio de 60 segundos para el entorno.
  
  
• 02:45:00 En esta sección, el instructor define la función de paso para el entorno de la ducha, que contiene seis bloques de código. El primer bloque aplica el impacto de la acción sobre el estado, con cero, uno y dos como las tres acciones posibles. El cero disminuye la temperatura en un grado, el uno deja la temperatura igual y el dos aumenta la temperatura en un grado. El segundo bloque reduce el tiempo de ducha en un segundo. El tercer bloque define la recompensa, con una recompensa de uno si la temperatura está entre 37 y 39 grados y -1 si está fuera de ese rango. El cuarto bloque comprueba si la ducha ha terminado y establece la finalización en verdadero si el tiempo de la ducha es menor o igual a cero. El quinto bloque crea un diccionario de información en blanco y el bloque final devuelve el estado, la recompensa, si la ducha ha terminado y el diccionario. La función de reinicio restablece la temperatura inicial a su valor predeterminado y restablece el tiempo de ducha a 60 segundos.
  
  
• 02:50:00 En esta sección, el instructor explica cómo crear un entorno personalizado para el aprendizaje por refuerzo usando Python. Demuestra cómo definir el estado del entorno y sus espacios de observación y acción. El instructor también muestra cómo probar y entrenar el modelo utilizando el entorno definido y cómo guardar el modelo entrenado después del aprendizaje. Menciona que los entornos de juego tardarán más en entrenarse en comparación con los entornos simples y anima a tener esto en cuenta para planificar proyectos y comprometerse con los clientes.
  
  
• 02:55:00 En esta sección, el instructor demuestra cómo probar y guardar el modelo entrenado. Usan el método 'evaluar política' para probar el rendimiento del modelo y luego guardan el modelo usando el método 'model.save'. Además, brindan un breve resumen del curso, que cubre una variedad de temas, desde configurar el entorno usando líneas de base estables hasta entrenar modelos con diferentes algoritmos, incluidos PPO, A2C y DQN. También discuten la creación de entornos personalizados y proyectos de construcción, como entrenar a un modelo para jugar Breakout o competir con un automóvil en una pista.
  
  
• 03:00:00 En esta sección, el instructor recomienda recursos adicionales para seguir aprendiendo, incluido el curso Reinforcement Learning de David Silva, un libro llamado Reinforcement Learning: An Introduction de Richard Sutton y Andrew Bartos, además de explorar el ajuste de hiperparámetros y la creación de entornos personalizados. e implementar soluciones de extremo a extremo, como construir un robot de barra de carro y entrenarlo en un entorno simulado antes de implementarlo en un entorno real utilizando una Raspberry Pi. El instructor alienta los comentarios y las preguntas de los espectadores y les agradece por sintonizar.

[MetaQuotes]

Clase 2 -- Álgebra Lineal Numérica -- Marvin Pförtner

Numéricos de ML 2 -- Álgebra Lineal Numérica -- Marvin Pförtner

El álgebra lineal numérica es fundamental para el aprendizaje automático, los procesos gaussianos y otros métodos de regresión no paramétricos. La conferencia cubre varios aspectos del álgebra lineal numérica, incluida la importancia de comprender la estructura de una matriz para una multiplicación más eficiente, la optimización de algoritmos de aprendizaje automático mediante la resolución de problemas de selección de hiperparámetros y el cálculo de matrices kernel, y la solución de un sistema lineal utilizando el descomposición LU, entre otros. La conferencia también enfatiza la importancia de implementar algoritmos correctamente, ya que el algoritmo utilizado para las operaciones matemáticas tiene un impacto significativo en el rendimiento, la estabilidad y el consumo de memoria.

En la segunda parte del video, Marvin Pförtner analiza la importancia del álgebra lineal numérica en los algoritmos de aprendizaje automático. Cubre varios temas, incluida la descomposición LU, la descomposición de Cholesky, el lema de inversión de matriz y el proceso de regresión gaussiana. Pförtner enfatiza la importancia de utilizar la estructura para hacer que los algoritmos sean más eficientes y destaca la importancia de la estabilidad numérica para resolver grandes sistemas de ecuaciones en el proceso de regresión gaussiana. También analiza técnicas como el aprendizaje activo y las aproximaciones de bajo rango para manejar grandes conjuntos de datos y las posibles limitaciones de memoria de las matrices del kernel. En general, el video muestra el papel crucial que juega el álgebra lineal numérica en muchos aspectos del aprendizaje automático.

• 00:00:00 En esta sección, un estudiante de doctorado analiza la importancia del álgebra lineal numérica en el aprendizaje automático y los procesos gaussianos. El álgebra lineal numérica es fundamental para el aprendizaje automático y es un conjunto de herramientas necesarias para implementar algoritmos. La conferencia cubre tareas fundamentales en álgebra lineal numérica importantes para el aprendizaje automático, la exploración de la estructura para hacer que los algoritmos de álgebra lineal numérica sean rápidos y confiables, y la implementación adecuada de la regresión del proceso gaussiano. La conferencia también cita ejemplos de aplicaciones del álgebra lineal numérica como la teoría básica de la probabilidad, modelos lineales generales, análisis de componentes principales y productos de matriz-vector que reducen la dimensionalidad.
  
  
• 00:05:00 En esta sección, el orador analiza el álgebra lineal numérica en el contexto del aprendizaje automático. Explica cómo los procesos gaussianos, un método de regresión no paramétrico en el aprendizaje automático, se basan en una medida de probabilidad previa, que es un proceso gaussiano que genera una matriz de Gram de kernel definida positiva y simétrica. La información generativa en esta matriz permite algoritmos eficientes y confiables. El orador también menciona cómo se aplican ecuaciones similares a una clase más grande de modelos, incluidos los métodos kernel y la regresión de Ridge. También analiza brevemente cómo se usa el álgebra lineal numérica para resolver ecuaciones diferenciales parciales lineales y en métodos de optimización para la optimización local de funciones de pérdida.
  
  
• 00:10:00 En esta sección, el orador analiza la importancia del álgebra lineal en el aprendizaje automático y proporciona ejemplos para ilustrar esta importancia. Las operaciones de álgebra lineal como la multiplicación de matrices vectoriales, las soluciones de sistemas lineales y las descomposiciones de matrices son fundamentales para muchos modelos de aprendizaje automático. Además, señala que muchos modelos de aprendizaje automático son en realidad ruidosos, ya que utilizan una estimación ruidosa de la matriz con la que pretenden resolver sistemas lineales. Finalmente, enfatiza que los determinantes logarítmicos son esenciales en el caso de densidad gaussiana y la regresión GP para obtener estimaciones posteriores máximas.
  
  
• 00:15:00 En esta sección, el orador enfatiza la importancia de la multiplicación eficiente de Matrix Vector en álgebra lineal numérica y aprendizaje automático. Dan un ejemplo de cómo incluso las tareas simples pueden volverse computacionalmente inviables si la expresión matemática no se transforma en un algoritmo correctamente. El ponente también destaca la importancia de identificar la estructura en Matrix para una multiplicación más eficiente. Concluyen afirmando que el algoritmo que implementa una operación matemática tiene un impacto significativo en el rendimiento, la estabilidad y el consumo de memoria.
  
  
• 00:20:00 En esta sección, el ponente enfatiza la importancia de comprender la estructura de una matriz para optimizar los algoritmos de aprendizaje automático. Él explica que si sabe que hay una estructura de rango inferior dentro de una matriz, entonces debe usar métodos especializados en matrices inferiores para factorizarla, en lugar de multiplicar la matriz completa. Él explica que la reducción es solo un tipo de estructura, y hay varias estructuras matriciales, como matrices dispersas y matrices kernel, que también dependen de entradas distintas de cero y dimensiones de entrada del regresor. El orador también habla sobre cómo almacenar matrices de kernel para ahorrar memoria.
  
  
• 00:25:00 En esta sección, el orador analiza cómo almacenar y evaluar matrices kernel para procesos gaussianos de manera eficiente. Si los puntos de datos exceden un cierto límite, el enfoque ingenuo de almacenarlos ya no es factible debido a problemas de memoria. Hay bibliotecas disponibles que escriben núcleos CUDA muy eficientes y usan GPU para calcular procesos gaussianos en una computadora portátil usando cientos de miles de puntos de datos. El ponente también habla de matrices con una forma funcional general, como los gráficos de diferencias automáticas, que requieren los mismos requisitos de tiempo y espacio. Por último, el ponente profundiza en un algoritmo concreto de aplicación de regresión bayesiana a procesos gaussianos, donde el núcleo de la medida gaussiana es la covarianza de la función desconocida. El orador presenta un gráfico de la medida posterior sobre la función junto con los datos observados y cómo funciona bien la cuantificación de la incertidumbre. Sin embargo, el problema surge cuando se calcula la inversa, que escala de manera bastante prohibitiva, lo que hace que el enfoque ingenuo de calcular una matriz de gramo de kernel a partir de n puntos de datos no sea factible para n grande.
  
  
• 00:30:00 En esta sección, el orador analiza la complejidad numérica de calcular matrices kernel en procesos gaussianos, que pueden volverse prohibitivamente costosos. Además, hay hiperparámetros que deben ajustarse para el kernel, como la escala de salida y la escala de longitud, a fin de optimizar el anterior para explicar el conjunto de datos observado. El orador describe un enfoque bayesiano para resolver este problema de selección de modelos calculando la probabilidad logarítmica marginal y minimizando una función de pérdida que consiste en un equilibrio entre el ajuste del modelo y la complejidad representada por el factor de normalización de la distribución gaussiana. El orador muestra ejemplos de subajuste y sobreajuste graves y explica cómo se puede encontrar el equilibrio entre estos dos términos para lograr el mejor rendimiento del modelo.
  
  
• 00:35:00 En esta sección, Marvin Pförtner analiza la solución de un sistema lineal. La solución requiere M más uno resuelve donde M es el número de puntos de datos en los que queremos evaluar nuestro regresor. El sistema es simétrico y definido positivo en el caso más general, pero puede haber estructuras adicionales para aprovechar, ya que el sistema suele ser enorme y, por lo general, no podemos resolver esto para conjuntos de datos muy grandes. Una descomposición matricial muy importante es la descomposición Lu. El algoritmo utilizado para resolver un sistema triangular inferior es la sustitución directa, que descompone la matriz en cuatro partes: escalar en la esquina inferior derecha, la columna de arriba es cero, un vector de fila a la izquierda y otra parte triangular llamada L menos li menos uno encima de él, que también es triangular inferior.
  
  
• 00:40:00 En esta sección, Marvin Pförtner analiza cómo resolver sistemas donde la matriz del sistema es triangular inferior, con dimensión n menos uno. Al dividir la última fila, el sistema se puede resolver usando un algoritmo simple. Luego se utilizan métodos recursivos para resolver un sistema para cualquier dimensión dada. Pförtner también explica cómo dividir la matriz en partes triangulares inferior y superior utilizando lo que él llama la descomposición de Lu, que es una definición recursiva que utiliza técnicas de divide y vencerás. Esta técnica es útil para invertir matrices y abaratar la resolución de sistemas lineales, siendo el proceso O(N^2) en lugar de O(N^3).
  
  
• 00:45:00 En esta sección, se explica el método de descomposición de Lu para resolver sistemas de ecuaciones lineales. Este método descompone una matriz en una matriz triangular inferior y una matriz triangular superior, lo que permite un cálculo más rápido de soluciones para sistemas lineales. El proceso implica establecer las entradas diagonales de la parte izquierda de la matriz triangular inferior en uno y usar un pivote parcial para garantizar la estabilidad y la robustez. A pesar de la eficiencia del método, se debe considerar el costo del cálculo, que es O(n^3).
  
  
• 00:50:00 En esta sección, Marvin Pförtner analiza el tiempo computacional de la descomposición UD y demuestra cómo implementarlo en su lugar. Explica que la mayor parte de cada paso de recurrencia es el cálculo del producto exterior y la resta, lo que da como resultado una suma de dos veces (n-1) al cuadrado. Usando una estrategia conocida como eliminación gaussiana, el algoritmo calcula eficientemente la matriz triangular superior. Pförtner muestra cómo realizar un cálculo de ejemplo con una matriz pequeña, demostrando que la parte no trivial de L está contenida en las tres entradas debajo de la diagonal, y la parte triangular superior contendrá las partes distintas de cero de U. Manteniendo todo en la memoria, Pförtner presenta una implementación que almacena inteligentemente L y U en la misma matriz.
  
  
• 00:55:00 En esta sección, el orador explica el proceso de descomposición LU en álgebra lineal numérica. Muestra cómo calcular el algoritmo paso a paso y cómo usarlo para resolver sistemas lineales. Una vez que tenemos la descomposición LU de una matriz, podemos aplicarla para resolver de manera eficiente múltiples sistemas lineales con múltiples lados derechos, con un costo de solo 2N al cuadrado para una sustitución hacia adelante y hacia atrás. La inversa de una matriz de permutación es solo su transpuesta, que es económica de calcular, lo que hace posible realizar soluciones K con la misma matriz del sistema en la regresión del proceso gaussiano.
  
  
• 01:00:00 En esta sección, el orador analiza cómo resolver de manera eficiente múltiples sistemas lineales con la misma matriz usando una descomposición LU, que es computacionalmente eficiente. Además, se presenta un método para calcular el determinante logarítmico con una descomposición LU, que permite una representación eficiente de un sistema lineal y realizar varias tareas de álgebra lineal con él. El orador enfatiza la importancia de utilizar la estructura para hacer que los algoritmos sean más eficientes y señala que la descomposición de Cholesky es una versión especializada de la descomposición LU que aprovecha la naturaleza simétrica y definida positiva de la matriz de gramo del núcleo.
  
  
• 01:05:00 En esta sección, el orador analiza el cálculo de la media posterior y la covarianza en procesos gaussianos. Para obtener la media posterior, se necesita resolver un sistema por sustitución hacia adelante y otro por sustitución hacia atrás. El orador señala que con la estructura de los factores de Cholesky de la matriz de covarianza, se puede obtener una buena aproximación descendente a la matriz. Además, habla sobre el problema de la posibilidad de no poder encajar la gran matriz del núcleo en la memoria y presenta dos enfoques para resolver este problema; usando estructura en los núcleos empleados o usando aproximaciones dispersas.
  
  
• 01:10:00 En esta sección, el orador analiza cómo invertir matrices de manera eficiente en algoritmos de aprendizaje automático. Utiliza un conjunto de datos generado a partir de una función sinusoidal como ejemplo y muestra que al conocer la estructura generativa del conjunto de datos, uno puede elegir núcleos que reflejen ese conocimiento y sean computacionalmente eficientes. El lema de inversión de matrices es una herramienta que se puede usar para invertir matrices de manera eficiente al perturbarlas con una pequeña cantidad de subespacios. Al usar este lema, uno puede calcular expresiones de manera muy eficiente y ni siquiera necesita formar la matriz completa en la memoria. El orador enfatiza que existen muchos enfoques diferentes para usar la estructura en los algoritmos de aprendizaje automático.
  
  
• 01:15:00 En esta sección, el disertante analiza los métodos numéricos de álgebra lineal utilizados en las inferencias gaussianas y la optimización de hiperparámetros en el aprendizaje automático. Un método para escalar la regresión GP (proceso gaussiano) a grandes conjuntos de datos es la inversión aproximada, que implica la construcción iterativa de aproximaciones de bajo rango a la matriz del sistema representada en la matriz kernel. El disertante demuestra este método utilizando el algoritmo de Cholesky como ejemplo y muestra cómo el aproximador de bajo rango de la matriz se puede obtener sobre la marcha sin calcular toda la factorización de Cholesky. La calidad de la aproximación depende de la matriz del kernel y del orden en que se procesan los puntos de datos. En general, esta sección destaca la importancia del álgebra lineal numérica en varios aspectos del aprendizaje automático.
  
  
• 01:20:00 En esta sección, Marvin Pförtner analiza cómo elegir el orden de los puntos de datos en los que Cholesky los trata para aproximarse a la matriz del núcleo. Explica que premultiplicar la Matriz de gramo con la Matriz de permutación, también conocida como pivotización completa o descomposición de Cholesky pivotada, puede conducir a una aproximación más baja con menos iteraciones. La idea es observar el predictor de los puntos de datos después de una iteración de Todeschini y luego usar la información recopilada para seleccionar el punto de datos para observar en la siguiente iteración. Esta técnica se considera un problema de aprendizaje activo y puede generar una forma inteligente de procesar filas y columnas simultáneamente y, por lo tanto, explorar la estructura generativa de Matrix en línea.
  
  
• 01:25:00 En esta sección, el disertante analiza la descomposición en valores singulares (SVD) y cómo resuelve un problema de optimización para obtener los mejores factores para una aproximación matricial. Sin embargo, truncar un SVD podría ser arbitrariamente malo, por lo que se utiliza un enfoque heurístico para aproximar el SVD y calcular una descomposición propia. También existe la necesidad de una raíz cuadrada de matriz, que se puede lograr a través de la descomposición de Cholesky. Es importante tener en cuenta la estructura al implementar algoritmos de álgebra lineal numérica en la práctica, ya que esto puede acelerar significativamente el proceso.
  
  
• 01:30:00 En esta sección, Marvin Pförtner analiza cómo la estructura del álgebra lineal numérica afecta la regresión del proceso gaussiano. La regresión del proceso gaussiano es computacionalmente intensiva y requiere resolver grandes sistemas de ecuaciones, lo que se puede hacer usando técnicas de álgebra lineal numérica. El ponente destaca la importancia de la estabilidad numérica en la resolución de estos sistemas de ecuaciones para no perder precisión en los resultados finales.

[MetaQuotes]

Detección de lenguaje de señas usando RECONOCIMIENTO DE ACCIÓN con Python | Modelo de aprendizaje profundo LSTM

Código: https://github.com/nicknochnack/ActionDetectionforSignLanguage

Detección de lenguaje de señas usando RECONOCIMIENTO DE ACCIÓN con Python | Modelo de aprendizaje profundo LSTM

En este video de YouTube titulado "Detección de lenguaje de señas usando RECONOCIMIENTO DE ACCIÓN con Python | Modelo de aprendizaje profundo de LSTM", el presentador explica cómo crear un flujo de detección de lenguaje de señas en tiempo real usando detección de acción y modelos clave. El presentador usa OpenCV y MediaPipe Holistic para extraer puntos clave de las manos, la cara y el cuerpo, y luego TensorFlow y Keras para construir un modelo LSTM que predice la acción que se muestra en una secuencia de fotogramas. El presentador pasa por el proceso de acceder y extraer puntos clave de la cámara web, configura un bucle para acceder a la cámara web y facilita la detección del lenguaje de señas al aplicar los puntos de referencia al último cuadro capturado de la cámara web. También demuestran cómo modificar el código para manejar los puntos clave que faltan y agregar el manejo de errores al modelo de pose y la detección de puntos de referencia faciales. Finalmente, el presentador explica la función de extracción de puntos clave para la detección de lenguaje de señas mediante el reconocimiento de acciones con Python.

El video brinda una explicación detallada de cómo crear un modelo de detección de lenguaje de señas mediante el reconocimiento de acciones con Python. Para recopilar los datos, el presentador crea carpetas para cada acción y secuencia y modifica el bucle MediaPipe para recopilar 30 valores de puntos clave por video para cada acción. Los datos se procesan previamente mediante la creación de etiquetas y funciones para el modelo de aprendizaje profundo de LSTM, y el modelo se entrena con TensorFlow y Keras. El modelo entrenado se evalúa utilizando una matriz de confusión de etiquetas múltiples y una función de puntaje de precisión. Finalmente, la detección en tiempo real se establece mediante la creación de nuevas variables para la detección, la concatenación de fotogramas y la aplicación de lógica de predicción, con una variable de umbral implementada para generar resultados por encima de una determinada métrica de confianza.

El tutorial en video muestra cómo usar Python y un modelo de aprendizaje profundo de LSTM para la detección del lenguaje de señas mediante el reconocimiento de acciones. El orador recorrió la lógica de predicción y explicó el código, haciéndolo fácil de entender. También mostraron a los espectadores cómo ajustar el código usando el método de agregar, aumentando el umbral de detección y agregando visualización de probabilidad para que la detección sea visualmente atractiva. El orador también abordó cómo verificar si el resultado está por encima del umbral, cómo manipular las probabilidades y cómo ampliar y modificar el proyecto agregando acciones o visualizaciones adicionales. Finalmente, el ponente presentó la lógica adicional del modelo, que minimiza las detecciones falsas y mejora la precisión del modelo, junto con una invitación a apoyar el video y el canal.

• 00:00:00 En esta sección del video, el creador explica su objetivo de producir un flujo de detección de lenguaje de señas en tiempo real usando detección de acción y modelos clave. Usarán MediaPipe Holistic para extraer puntos clave de las manos, la cara y el cuerpo, y luego usarán TensorFlow y Keras para construir un modelo LSTM que predice la acción que se demuestra en una secuencia de fotogramas. El proceso incluye recopilar datos sobre puntos clave, entrenar una red neuronal, evaluar la precisión y probar el modelo en tiempo real usando OpenCV y una cámara web. El creador describe 11 pasos para lograr este proceso y comienza instalando e importando dependencias.
  
  
• 00:05:00 En esta sección, el presentador analiza las diferentes dependencias que se usarán en el proyecto, incluidas OpenCV, MediaPipe, scikit-learn, NumPy, Matplotlib y TensorFlow. Después de importar estas dependencias, el presentador pasa por el proceso de acceder y extraer puntos clave de la cámara web mediante OpenCV y MediaPipe Holistic. Luego, el presentador configura un bucle para acceder a la cámara web y mostrar varios cuadros en la pantalla, lo que permite probar el proyecto en tiempo real. Este bucle se utilizará varias veces a lo largo del proyecto, incluso al extraer fotogramas y probar el proyecto. Todo el código utilizado en el proyecto estará disponible en Github, incluidos los pesos finales entrenados.
  
  
• 00:10:00 En esta sección del video, el presentador explica cómo acceder a la cámara web usando OpenCV y comenzar a recorrer todos los cuadros. El presentador usa la función de "captura de video" para leer la transmisión de la cámara web e inicia un bucle que leerá, mostrará y esperará a que se presione una tecla para salir del bucle. El presentador también explica cómo romper el ciclo con gracia y cómo solucionar problemas con el número de dispositivo si la cámara web no aparece. Finalmente, el presentador presenta MediaPipe Holistic y MediaPipe Drawing Utilities, dos módulos de Python que se utilizan para descargar y aprovechar el modelo holístico para la detección de poses y dibujar los puntos de referencia de las poses en una imagen.
  
  
• 00:15:00 En esta sección de la transcripción, el hablante configura una función para facilitar la detección del lenguaje de señas. La función toma una imagen y un modelo holístico de canalización de medios y pasa por una serie de pasos, incluida la conversión de color de BGR a RGB, la detección y la conversión de la imagen nuevamente a BGR, antes de devolver la imagen y los resultados al bucle para representación. Los pasos se realizan de forma simétrica para garantizar que la imagen esté configurada como no grabable antes de la detección y vuelva a ser grabable después. El orador también explica la función cvtColor utilizada para convertir el color de la imagen y muestra cómo llamar a la función de detección de canalización de medios en el bucle.
  
  
• 00:20:00 En esta sección, el presentador explica cómo acceder al modelo de MediaPipe usando una declaración "with" y establece la confianza inicial y de seguimiento. También muestran cómo acceder y visualizar los diferentes tipos de puntos de referencia: cara, mano izquierda y derecha, y puntos de referencia de pose. Luego, el presentador demuestra cómo usar MediaPipe Holistic para detectar puntos de referencia y muestra los resultados en el marco. Finalmente, muestran cómo representar los puntos de referencia en la pantalla escribiendo una función.
  
  
• 00:25:00 En esta sección, YouTuber configura una nueva función llamada "draw_landmarks" que representará datos de puntos de referencia en una imagen para permitir la visualización de los diferentes puntos de referencia detectados por los modelos de canalización de medios utilizados en el proyecto. La función utiliza la función auxiliar "mp.drawing" proporcionada por media pipe para dibujar los puntos de referencia, y también requiere la imagen y los datos de puntos de referencia como entradas. La función también permite la especificación de mapas de conexión y opciones de formato. Luego, el YouTuber procede a demostrar cómo usar la función "plot.imshow" de matplotlib para mostrar el último cuadro capturado de la cámara web.
  
  
• 00:30:00 En esta sección, el locutor corrige el color de la imagen y aplica los puntos de referencia a la imagen pasándolos a través de la función "dibujar puntos de referencia". Se accede a los resultados del modelo de detección de tubería de medios como el último cuadro y los resultados de ejecutar el ciclo. Los métodos "mp_drawing.draw_landmarks" se aplican al fotograma actual para representar todas las conexiones de manos, poses y rostros. Luego, el orador aplica la función "dibujar puntos de referencia" al bucle en tiempo real y, antes de renderizar, aplica el formato utilizando las "especificaciones de dibujo de puntos de referencia" y "especificaciones de dibujo de conexiones" para dibujar los puntos y las conexiones respectivamente. Finalmente, el orador crea una nueva función llamada "dibujar puntos de referencia de estilo" para personalizar la función "dibujar puntos de referencia" si lo desea.
  
  
• 00:35:00 En esta sección, el orador actualiza el formato para la función dibujar puntos de referencia, agregando dos parámetros adicionales para la función mp_drawing.drawing_spec: color y radio del círculo. Demuestran los cambios para el punto de referencia de la cara y explican que el primer parámetro colorea el punto de referencia y el segundo parámetro colorea la conexión. Luego, el orador copia los cambios en la función para cada uno de los modelos de pose y mano, dando a cada modelo colores únicos. Los cambios son puramente estéticos y no afectarán el rendimiento, pero demuestran los diferentes modelos en acción.
  
  
• 00:40:00 En esta sección, el tutorial en video explica cómo extraer valores de puntos clave de la variable de resultados del modelo holístico de MediaPipe de manera flexible concatenándolos en una matriz numpy y manejando errores. El tutorial explica cómo extraer valores para un punto de referencia y actualizarlo para todos los puntos de referencia mediante un bucle y una lista de comprensión. La matriz final con todos los puntos de referencia se aplana para tener todos los valores en una matriz en lugar de varios conjuntos de puntos de referencia.
  
  
• 00:45:00 En esta sección, el presentador explica cómo modificar el código para manejar cuando no hay puntos clave debido a que la mano está fuera del cuadro. Comienzan mostrando que los puntos de referencia de la izquierda tienen tres valores cada uno y hay 21 puntos de referencia para un total de 63 valores necesarios. Luego aplican una declaración if que reemplaza los valores faltantes con una matriz numpy en blanco. Esta misma modificación se aplica luego a los puntos de referencia de la derecha, que también tienen 63 valores. El código extrae los diferentes puntos clave al concatenar los valores x, y y z en una gran matriz y luego aplanarlos en el formato adecuado para usar en el modelo LSTM.
  
  
• 00:50:00 En esta sección, el orador analiza cómo agregar el manejo de errores al modelo de pose y la detección de puntos de referencia faciales, y crea una función llamada "extract_key_points" para extraer los puntos clave necesarios para la detección de puntos de referencia y la detección de acciones. La función utiliza matrices numpy y recorre los resultados para extraer los valores x, y y z para cada punto de referencia y luego los aplana en una matriz. El orador también menciona que el código estará disponible en la descripción del video e invita a los espectadores a hacer preguntas en los comentarios.
  
  
• 00:55:00 En esta sección del video, el orador explica la función de extracción de puntos clave para la detección del lenguaje de señas mediante el reconocimiento de acciones con Python. La función extrae los puntos clave para la pose, la cara, la mano izquierda y la mano derecha y los concatena en una matriz numpy aplanada. Estos puntos clave forman los valores del marco utilizados para la detección del lenguaje de señas mediante la detección de la acción humana. El orador también configura variables para la ruta de datos exportados y las acciones que se detectarán (hola, gracias y te amo) utilizando 30 marcos de datos para cada acción.

• 01:00:00 En esta sección del video, el presentador explica el proceso de recopilación de datos para detectar el lenguaje de señas mediante el reconocimiento de acciones con Python. Explican que para cada una de las tres acciones que quieren detectar, recopilarán 30 videos de datos, con cada video de 30 cuadros de duración. Esto equivale a una buena cantidad de datos, pero el presentador asegura a los espectadores que lo harán paso a paso. Continúan creando carpetas para cada acción y secuencia de acción, en las que los 30 puntos clave de cada fotograma de cada secuencia se almacenarán como una matriz numérica. El presentador también menciona que en el paso 11, mostrarán a los espectadores cómo concatenar palabras para formar oraciones.
  
  
• 01:05:00 En esta sección, el instructor muestra cómo recopilar datos para el modelo de reconocimiento de lenguaje de señas. Comienza creando carpetas para las tres clases diferentes de signos (hola, gracias y te amo) y sus correspondientes carpetas de secuencias individuales. Luego, modifica el bucle de canalización de medios para recorrer cada acción, video y cuadro para recopilar los datos. Para asegurarse de que los cuadros no se recopilan demasiado rápido, agrega un descanso entre cada video usando una declaración lógica. Al hacer esto, el modelo recopilará 30 valores de puntos clave por video, creando efectivamente un conjunto apilado de tres acciones, cada una con 30 videos por acción y 30 cuadros por video.
  
  
• 01:10:00 En esta sección, el creador del video brinda una explicación de la lógica de recopilación en un script de Python que usa OpenCV y modelos de aprendizaje profundo para detectar gestos de lenguaje de señas en el video. La lógica implica mostrar texto en la pantalla y tomar un descanso cada segundo cuadro. El creador del video también demuestra el uso de np.save para guardar los cuadros como matrices numpy, que se almacenan en una carpeta mp_data. Luego proporcionan el bloque de código final para la extracción de puntos clave y el guardado de los fotogramas en las carpetas correctas.
  
  
• 01:15:00 En esta sección de la transcripción, el orador explica la lógica aplicada para recorrer sus acciones y secuencias (videos), aplicar la detección de canalización de medios, dibujar puntos de referencia con estilo y extraer diferentes puntos clave para guardarlos en carpetas específicas. Usarán tres acciones (hola, gracias y te quiero) y recopilarán 30 fotogramas por acción durante 30 secuencias. Antes de ejecutar este código, verifican dos veces si hay errores y ajustan el ancho de línea para asegurarse de que la fuente no esté oculta. Una vez que se ejecuta el código, la ventana emergente dice "Colección inicial", tienen dos segundos para ponerse en posición para realizar la acción y tienen 30 fotogramas para hacerlo. El código debe poder hacer un bucle y recopilar datos indefinidamente.
  
  
• 01:20:00 En esta sección del video, el presentador demuestra cómo recopilar datos del lenguaje de señas usando las bibliotecas MediaPipe y OpenCV en Python. El presentador sugiere capturar varios ángulos de los signos de las manos para un mejor desempeño del modelo y también menciona que tener 30 secuencias de 30 fotogramas cada una tiende a funcionar bien. Los puntos clave recopilados por MediaPipe se utilizan en lugar de la imagen para hacer que el modelo sea más resistente en varios escenarios. El presentador también explica que los datos recopilados se almacenan como matrices numpy para uso futuro.
  
  
• 01:25:00 En esta sección, el video se enfoca en el procesamiento previo de los datos y la creación de etiquetas y características para el modelo de aprendizaje profundo de LSTM. El video comienza importando dependencias y luego creando un mapa de etiquetas, que es básicamente un diccionario que representa cada una de las diferentes acciones. A continuación, los datos se leen y se juntan para estructurarlos en una gran matriz con 90 matrices, cada una de las cuales contiene 30 cuadros con 1662 valores que representan los puntos clave. Se crean dos matrices en blanco, secuencias y etiquetas, donde las secuencias representan los datos de características y las etiquetas representan los datos de las etiquetas. Luego, el código recorre cada una de las acciones y secuencias, creando una matriz en blanco para que las ventanas representen todos los diferentes marcos para esa secuencia en particular. Finalmente, numpy.load se usa para cargar cada cuadro.
  
  
• 01:30:00 En esta sección, el orador pasa por el proceso de preprocesamiento de los datos almacenándolos en una matriz numpy y convirtiendo las etiquetas en una representación codificada en caliente usando la función "to_categorical". Luego usan la función "train_test_split" para dividir los datos en conjuntos de entrenamiento y prueba. El conjunto de entrenamiento consta de 85 secuencias y el conjunto de prueba tiene cinco secuencias. El orador también importa las dependencias necesarias, incluido el modelo secuencial, la capa LSTM y la capa densa, mientras se preparan para entrenar una red neuronal LSTM usando TensorFlow y Keras.
  
  
• 01:35:00 En esta sección, el orador analiza las dependencias necesarias para construir una red neuronal, incluidas secuencial, lstm, densa y tensorboard. Explican que secuencial facilita agregar capas al modelo, y lstm se usa para el análisis temporal y la detección de acciones. El orador también demuestra cómo configurar devoluciones de llamada de tensorboard para monitorear el progreso del entrenamiento. Luego proceden a construir la arquitectura de la red neuronal, que incluye agregar tres conjuntos de capas lstm y especificar las funciones de activación y la forma de entrada. Finalmente, mencionan la importancia de no devolver secuencias a la capa densa y recomiendan más recursos de aprendizaje.
  
  
• 01:40:00 En esta sección del video, el presentador repasa los diferentes tipos de capas agregadas al modelo LSTM, y especifica que las siguientes tres capas son capas densas. Cada capa densa utiliza 64 y 32 unidades densas o neuronas totalmente conectadas con valores de activación de ReLU. La capa final es la capa de acciones, que extrae los valores devueltos como tres unidades de red neuronal usando el valor de activación de softmax. El modelo predice una acción como "Hola", y esta salida se pasa a través de 30 fotogramas más 1662 puntos clave y se procesa previamente para extraer las acciones. El presentador explica cómo llegaron a usar MediaPipe y la capa LSTM hablando de la investigación y el desarrollo que realizaron. Finalmente, el modelo se compila usando entropía cruzada categórica como función de pérdida, y se ajusta y entrena con tren x y tren y para el número especificado de épocas.
  
  
• 01:45:00 En esta sección, el video demuestra el proceso de entrenamiento de un modelo de aprendizaje profundo LSTM para la detección del lenguaje de señas mediante el reconocimiento de acciones con Python. El modelo usa el modelo de MediaPipe Holistic, que no requiere un generador de datos ya que los datos pueden caber en la memoria. El video muestra cómo configurar el proceso de entrenamiento con TensorBoard y cómo monitorear la precisión y pérdida del modelo durante el entrenamiento en TensorBoard. El video también incluye cómo detener el proceso de entrenamiento una vez que se ha logrado un nivel razonable de precisión y cómo inspeccionar la estructura del modelo usando la función model.summary.
  
  
• 01:50:00 En esta sección, el hablante entrena un modelo y hace predicciones usando el modelo guardado. El modelo utiliza la técnica de aprendizaje profundo LSTM para identificar las acciones del lenguaje de señas. El modelo predice la mayor probabilidad de acción detectada con una función softmax. El valor previsto se compara con el valor real para evaluar el rendimiento del modelo. El hablante guarda el modelo entrenado como action.h5 y lo vuelve a cargar con una función de compilación y carga. Al importar métricas de sklearn, el orador evalúa el rendimiento de la matriz de confusión de etiquetas múltiples del modelo.
  
  
• 01:55:00 En esta sección del video, el presentador explica cómo evaluar el desempeño del modelo entrenado usando una matriz de confusión de etiquetas múltiples y una función de puntaje de precisión. La matriz de confusión representa los verdaderos positivos y verdaderos negativos, y cuanto mayor sea el número de estos valores en la esquina superior izquierda e inferior derecha, mejor se desempeñará el modelo. La función de puntuación de precisión da el porcentaje de predicciones correctas del modelo. Luego, el modelo entrenado se evalúa utilizando los datos de prueba y el bucle se restablece para la detección en tiempo real, lo que implica la creación de nuevas variables para la detección, la concatenación de fotogramas y la aplicación de la lógica de predicción. También se implementa una variable de umbral para generar resultados por encima de una determinada métrica de confianza.
  
  
• 02:00:00 En esta sección, el ponente explica su lógica de predicción para la detección del lenguaje de señas mediante el reconocimiento de acciones con Python y el modelo de aprendizaje profundo LSTM. Comienzan extrayendo puntos clave y añadiéndolos a una secuencia de 30 fotogramas. Si la longitud de la secuencia es igual a 30, ejecutan la predicción llamando a model.predict con las dimensiones expandidas de la secuencia. Luego imprimen la clase predicha usando np.argmax y las acciones definidas anteriormente. El hablante también inserta puntos clave al comienzo de la secuencia para ordenar la lógica y procede a agregar lógica de visualización al código.
  
  
• 02:05:00 En esta sección, el orador desglosa el código que explica cómo el programa verifica si el resultado está por encima del umbral extrayendo el resultado de la puntuación más alta usando "mp.argmax" y pasando por "res". La lógica del programa es verificar que la última palabra coincida con la predicción actual. Si lo hace, entonces el programa no se agregará a la longitud de la oración. Si no coincide, el programa agregará la acción detectada actual a nuestra matriz de oraciones. La longitud de la oración solo debe incluir hasta cinco palabras para que el programa no intente generar una matriz gigante. Finalmente, el programa pondrá texto y un rectángulo en la imagen para mostrar la oración.
  
  
• 02:10:00 En esta sección, el video demuestra cómo usar Python y un modelo de aprendizaje profundo de LSTM para detectar el lenguaje de señas mediante el reconocimiento de acciones. El tutorial recorre el ajuste del código para usar el método de adición y el aumento del umbral de detección para una mayor precisión. El video también muestra cómo representar las probabilidades con una función rápida para crear una visualización de probabilidad, lo que hace que la salida de detección se vea visualmente convincente. En general, el tutorial brinda un excelente ejemplo del uso de modelos de aprendizaje profundo para detectar el lenguaje de señas con Python, lo que lo convierte en un excelente recurso para cualquiera que busque crear proyectos similares.
  
  
• 02:15:00 En esta sección del video, el presentador demuestra una función de visualización de probabilidad que nos permite ver las diferentes acciones y cómo se calculan sus probabilidades en tiempo real. La función usa cv2.rectangle para colocar un rectángulo dinámico en el marco de salida y luego lo coloca y lo llena según la acción en la que estamos trabajando actualmente, que luego usa el método de texto cv2.put para generar los valores de texto. El presentador muestra cómo esta función puede incorporarse al ciclo para visualizarla en tiempo real, y podemos ver que está detectando y reconociendo diferentes acciones como hola, gracias y te amo en función de los valores de probabilidad. El presentador destaca que hay muchas aplicaciones para esta función y demuestra cómo se puede usar el código para detectar y reconocer diferentes acciones en varios escenarios.
  
  
• 02:20:00 En esta sección del video, el presentador resume el proceso de su proyecto de detección de lenguaje de señas. Configuraron carpetas para la recopilación, recopilaron puntos clave, preprocesaron los datos, construyeron una red neuronal LSTM, hicieron predicciones y la probaron en tiempo real. Pudieron hacer que las detecciones se ejecutaran de manera efectiva en tiempo real, incluida la visualización de probabilidad. Proporcionan una demostración de cómo arreglaron el código para tomar los fotogramas correctos y agregarlos a la secuencia moviendo dos puntos y agregando un negativo. También agregaron una línea para agregar sus predicciones a una nueva matriz de predicción para garantizar una mayor estabilidad al predecir acciones. Finalmente, ofrecen que los usuarios pueden ampliar y modificar el proyecto agregando acciones, colores y/o visualizaciones adicionales según lo consideren conveniente.
  
  
• 02:25:00 En esta sección, el orador demuestra cómo el modelo de detección de acciones se ha vuelto más estable y resistente al implementar una lógica adicional. El modelo ahora puede minimizar las detecciones falsas y mantener la detección durante períodos más largos, mejorando su precisión. El orador también menciona que los pesos entrenados para el modelo estarán disponibles en el repositorio de GitHub para que los usuarios los aprovechen. El video concluye con una invitación para darle me gusta al video y suscribirse al canal.