Comprender la visión computarizada

1

¿Por qué aprender computer vision?

2

¿Qué es la visión computarizada?

3

Tipos de visión computarizada

4

Introducción a object detection: clasificación + localización

5

Aprende a identificar problemas

Dimensionamiento de proyecto de visión computarizada

6

Cómo definir los tiempos de tu proyecto

7

Cómo costear tu proyecto

8

Cómo identificar los roles necesarios en el proyecto

9

Producto mínimo viable en computer vision

Obtención y procesamiento de los datos

10

Obtención de datos para tu proyecto

11

Limpieza de la base de datos

12

Distribución de datos en entrenamiento y testeo

13

Etiquetado de los datos de test

14

Etiquetado de los datos de train

15

Transforma tu base de datos a TFRecord

16

Transformar CSV a TFRecord

Entrena, testea y optimiza tus modelos

17

Librerías a importar durante fase de entrenamiento

18

Fase de entrenamiento del modelo

19

Balanceo de imágenes y data augmentation

20

Entrena, evalua y optimiza con TensorBoard

21

Validación de modelo en un entorno de ejecución

22

Re-entrenamiento del modelo para obtener mejores resultados

23

Seguimiento de centroides con OpenCV

24

Configuración de los centroides con OpenCV

25

Algoritmo de dirección y conteo con OpenCV

26

Crea un ciclo de entrenamiento de tu modelo: MLOps

Producto con visión computarizada en producción

27

Prepara tu entorno en Google Cloud Platform

28

Carga y preprocesamiento de modelos

29

Postprocesamiento de modelos

30

Despliega y consume tu modelo en producción

31

Bonus: aprende a apagar las máquinas de GCP para evitar sobrecostos

Siguientes pasos en inteligencia artificial

32

Siguientes pasos en inteligencia artificial

33

Comparte tu proyecto de detección de vehículos en carretera y certifícate

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Aprovecha el precio especial y haz tu profesión a prueba de IA

Antes: $249

Currency
$209
Suscríbete

Termina en:

0 Días
3 Hrs
51 Min
47 Seg

Fase de entrenamiento del modelo

18/33
Recursos

Instalar la librería de object Detection en Google Colab:

import os
%cd /content
!git clone --quiet https://github.com/tensorflow/models.git
%cd /content/models/
#!git checkout 58d19c67e1d30d905dd5c6e5092348658fed80af
!apt-get update && apt-get install -y -qq protobuf-compiler python-pil python-lxml python-tk
!pip install -q Cython contextlib2 pillow lxml matplotlib
!pip install -q pycocotools
%cd /content/models/research
!protoc object_detection/protos/*.proto --python_out=.
os.environ['PYTHONPATH'] += ':/content/models/research/:/content/models/research/slim/'
!python object_detection/builders/model_builder_test.py

Descargar los modelos pre-entrenados en este caso SSD + MobileNetV2

!wget --no-check-certificate http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_mobilenet_v2_fpnlite_320x320_coco17_tpu-8.tar.gz \
-O /content/ssd_mobilenet_v2_fpnlite_320x320_coco17_tpu-8.tar.gz

Aportes 2

Preguntas 3

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Código para descargar los modelos pre-entrenados en este caso SSD + MobileNetV2

!wget --no-check-certificate http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_mobilenet_v2_fpnlite_320x320_coco17_tpu-8.tar.gz \
-O /content/ssd_mobilenet_v2_fpnlite_320x320_coco17_tpu-8.tar.gz
La fase de entrenamiento del modelo es el proceso en el cual el modelo de machine learning aprende a reconocer patrones en los datos para realizar predicciones o clasificaciones. En TensorFlow, el proceso generalmente incluye la carga de datos, la definición del modelo, la configuración de parámetros de entrenamiento, y el ajuste del modelo con los datos de entrenamiento. Aquí te explico cada paso. \### 1. \*\*Preparación de los datos\*\* Supongamos que ya tienes un conjunto de datos en formato \*\*TFRecord\*\*. Carguemos y preparemos los datos para el entrenamiento. ```python import tensorflow as tf \# Función para leer y parsear el archivo TFRecord def parse\_tfrecord\_fn(example): feature\_description = { 'image': tf.io.FixedLenFeature(\[], tf.string), 'label': tf.io.FixedLenFeature(\[], tf.int64), } parsed\_example = tf.io.parse\_single\_example(example, feature\_description) image = tf.io.decode\_jpeg(parsed\_example\['image'], channels=3) # Decodificar JPEG image = tf.image.resize(image, \[128, 128]) # Redimensionar image = tf.cast(image, tf.float32) / 255.0 # Normalizar label = parsed\_example\['label'] return image, label \# Cargar el dataset desde el archivo TFRecord train\_dataset = tf.data.TFRecordDataset('train\_data.tfrecord') train\_dataset = train\_dataset.map(parse\_tfrecord\_fn) train\_dataset = train\_dataset.shuffle(buffer\_size=1000).batch(32).prefetch(tf.data.AUTOTUNE) ``` \### 2. \*\*Definir el modelo\*\* Puedes definir un modelo usando la API `tf.keras.Sequential` o la API funcional de Keras. Aquí tienes un ejemplo de modelo simple de clasificación para imágenes. ```python from tensorflow.keras import layers, models model = models.Sequential(\[ layers.Conv2D(32, (3, 3), activation='relu', input\_shape=(128, 128, 3)), layers.MaxPooling2D((2, 2)), layers.Conv2D(64, (3, 3), activation='relu'), layers.MaxPooling2D((2, 2)), layers.Conv2D(64, (3, 3), activation='relu'), layers.Flatten(), layers.Dense(64, activation='relu'), layers.Dense(10, activation='softmax') # Asumiendo 10 clases ]) ``` \### 3. \*\*Compilar el modelo\*\* La compilación del modelo define el optimizador, la función de pérdida, y las métricas a utilizar durante el entrenamiento. ```python model.compile(optimizer='adam', loss='sparse\_categorical\_crossentropy', metrics=\['accuracy']) ``` \### 4. \*\*Entrenar el modelo\*\* Ahora puedes entrenar el modelo usando el método `fit` de Keras, indicando los datos de entrenamiento y el número de épocas. ```python \# Entrenar el modelo history = model.fit(train\_dataset, epochs=10) ``` Aquí `history` guardará un registro de la pérdida y la precisión en cada época, que puede ayudarte a analizar el rendimiento del modelo. \### 5. \*\*Evaluación del modelo\*\* Después del entrenamiento, evalúa el rendimiento del modelo en el conjunto de datos de prueba. ```python \# Cargar datos de prueba (TFRecord) test\_dataset = tf.data.TFRecordDataset('test\_data.tfrecord') test\_dataset = test\_dataset.map(parse\_tfrecord\_fn).batch(32) \# Evaluar el modelo test\_loss, test\_accuracy = model.evaluate(test\_dataset) print(f"Precisión en datos de prueba: {test\_accuracy:.2f}") ``` \### 6. \*\*Ajustes adicionales y visualización del entrenamiento\*\* Puedes visualizar el progreso del entrenamiento usando la información de `history`. Esto es útil para identificar problemas como el sobreajuste. ```python import matplotlib.pyplot as plt \# Graficar pérdida y precisión plt.plot(history.history\['accuracy'], label='Precisión de entrenamiento') plt.plot(history.history\['loss'], label='Pérdida de entrenamiento') plt.xlabel('Épocas') plt.ylabel('Precisión / Pérdida') plt.legend() plt.show() ``` \### Resumen 1\. \*\*Preparación de datos\*\*: Se preprocesan y cargan los datos desde TFRecord. 2\. \*\*Definición del modelo\*\*: Se configura una red neuronal que ajusta los datos de entrada. 3\. \*\*Compilación\*\*: Se eligen el optimizador, la función de pérdida, y las métricas. 4\. \*\*Entrenamiento\*\*: Se entrena el modelo con los datos de entrenamiento. 5\. \*\*Evaluación\*\*: Se mide el rendimiento en los datos de prueba. Esta estructura es común en proyectos de machine learning, especialmente en visión computarizada, y te permite ajustar el modelo gradualmente hasta obtener el rendimiento deseado.