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

Balanceo de imágenes y data augmentation

19/33
Recursos

Aportes 8

Preguntas 6

Ordenar por:

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

cuando configuramos el archivo pipline.config

tuve que importar numpy antes de importar tensorfow me daba un problema de versionado con numpy
import numpy as np
import tensorflow as tf
hay sigues normal el script

No se si no entendi bien el codigo, pero a lo que vi no hicimos ningun data augmentation, solo editamos el pipeline pero no tocamos la parte de data augmentation, el titulo quedaria mejor como “configuracion de pipeline”

Hola. Escribo esto en Marzo de 2024. No me es posible avanzar con el curso debido al versionamiento de las librerías. Solicito su ayuda con una solución actualizada que sirva. También sería excelente que actualizaran el curso.

el profesor hizo una configuración general del pipeline, se entiendo que por tiempo no se puede profundizar en cada uno de los parámetros de este chichero.

Les recomiendo que revisen con una lupa cada una de sus configuraciones ya que la cantidad de opciones es muy amplia

El **Data Augmentation** es una técnica que permite aumentar artificialmente el tamaño del conjunto de datos generando versiones modificadas de las imágenes originales. Esto es útil tanto para equilibrar las clases como para mejorar la generalización del modelo. Algunas de las transformaciones más comunes incluyen: **Rotación**: Rotar la imagen en un rango de grados (por ejemplo, entre -40 y +40 grados). **Volteo (Flip)**: Invertir la imagen horizontal o verticalmente. **Escalado**: Cambiar el tamaño de la imagen sin modificar su proporción original. **Desplazamiento (Shift)**: Desplazar la imagen hacia arriba, abajo, izquierda o derecha. **Ruido**: Agregar ruido aleatorio para hacer que las imágenes sean más diversas. **Ajuste de brillo o contraste**: Modificar los niveles de brillo o contraste para simular diferentes condiciones de iluminación. **Recorte aleatorio (Random cropping)**: Recortar aleatoriamente una parte de la imagen. Estas transformaciones no cambian el contenido esencial de la imagen, pero permiten que el modelo vea múltiples variaciones de una misma imagen durante el entrenamiento, lo que lo hace más robusto.
El balanceo de clases y la \*\*data augmentation\*\* son pasos importantes en el procesamiento de datos para modelos de visión computarizada, especialmente cuando trabajamos con conjuntos de datos desequilibrados o insuficientes. Aquí te explico ambos conceptos y cómo implementarlos en TensorFlow. \### 1. \*\*Balanceo de Imágenes\*\* El balanceo de clases es esencial cuando las clases en un conjunto de datos están desproporcionadas, es decir, cuando algunas clases tienen muchas más imágenes que otras. Esto puede llevar a que el modelo esté sesgado hacia las clases mayoritarias. \#### Métodos comunes para el balanceo: \- \*\*Oversampling\*\*: Se replican las imágenes de las clases minoritarias hasta equilibrar la proporción. \- \*\*Undersampling\*\*: Se reduce el número de imágenes de las clases mayoritarias. \- \*\*Data Augmentation\*\*: Generación de nuevas imágenes mediante transformaciones. En TensorFlow, puedes combinar `tf.data.Dataset` con técnicas de data augmentation para balancear el conjunto de datos. \### 2. \*\*Data Augmentation\*\* La \*\*data augmentation\*\* aumenta la diversidad de datos mediante transformaciones aleatorias, ayudando a mejorar la generalización del modelo. Algunas transformaciones comunes incluyen: \- Rotación \- Volteo horizontal o vertical \- Zoom y recorte \- Ajuste de brillo y contraste \- Desplazamientos horizontales o verticales \### Implementación de Balanceo y Data Augmentation en TensorFlow \#### Paso 1: Definir las transformaciones de data augmentation Usaremos las capas de `tf.keras.layers` para definir transformaciones de data augmentation que se aplicarán a cada imagen durante el entrenamiento. ```python from tensorflow.keras import layers data\_augmentation = tf.keras.Sequential(\[ layers.RandomFlip("horizontal\_and\_vertical"), # Volteo horizontal y vertical layers.RandomRotation(0.2), # Rotación layers.RandomZoom(0.1), # Zoom layers.RandomContrast(0.2), # Contraste ]) ``` \#### Paso 2: Aplicar data augmentation y balanceo al conjunto de datos Suponiendo que tienes tu conjunto de datos cargado en formato TFRecord, puedes aplicar `data\_augmentation` y balancear las clases mediante oversampling. ```python import tensorflow as tf \# Función de preprocesamiento y augmentación def preprocess\_and\_augment(image, label): image = tf.image.resize(image, \[128, 128]) # Ajuste de tamaño image = tf.cast(image, tf.float32) / 255.0 # Normalización image = data\_augmentation(image) # Aplicación de augmentación return image, label \# Cargar el conjunto de datos train\_dataset = tf.data.TFRecordDataset('train\_data.tfrecord') train\_dataset = train\_dataset.map(parse\_tfrecord\_fn) \# Balanceo mediante oversampling def balance\_dataset(dataset, minority\_class\_size, batch\_size=32): minority\_class = dataset.filter(lambda image, label: label == 1) majority\_class = dataset.filter(lambda image, label: label == 0) \# Oversampling de la clase minoritaria minority\_class = minority\_class.repeat(int(minority\_class\_size / len(minority\_class))) \# Mezclar y combinar ambas clases balanced\_dataset = majority\_class.concatenate(minority\_class) balanced\_dataset = balanced\_dataset.shuffle(buffer\_size=1000).batch(batch\_size).prefetch(tf.data.AUTOTUNE) return balanced\_dataset \# Aplicar preprocess y augmentación train\_dataset = train\_dataset.map(preprocess\_and\_augment) train\_dataset = balance\_dataset(train\_dataset, minority\_class\_size=1000) ``` \#### Paso 3: Entrenamiento con dataset balanceado y aumentado Usa el conjunto de datos balanceado y aumentado en el modelo para el entrenamiento. ```python \# Definición del modelo (Ejemplo) model = tf.keras.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 ]) \# Compilación y entrenamiento model.compile(optimizer='adam', loss='sparse\_categorical\_crossentropy', metrics=\['accuracy']) model.fit(train\_dataset, epochs=10) ``` \### Explicación del código 1\. \*\*Definición de data augmentation\*\*: Creamos una secuencia de capas de augmentación con `tf.keras.layers`. 2\. \*\*Balanceo del dataset\*\*: Usamos oversampling de la clase minoritaria repitiéndola hasta equilibrar las clases. 3\. \*\*Preprocesamiento y augmentación\*\*: Ajustamos el tamaño, normalizamos, y aplicamos augmentación a cada imagen del conjunto. 4\. \*\*Entrenamiento\*\*: Entrenamos el modelo con el dataset balanceado y aumentado. Esta combinación de data augmentation y balanceo mejora la capacidad del modelo para generalizar y reducir el sesgo hacia clases más representadas.
Buenas. Para los que tengan problemas con el versionado de las librerías. Para la fecha que elaboro el proyecto (Junio 2024) **me funcionó usar las versiones más reciente de todas las librerías.** ```python import os import pandas as pd import json import pickle import zipfile import shutil !pip install avro-python3 !pip install !pip install tf_slim !pip install tf-models-official !pip install lvis !pip install tensorflow_io !pip install keras !pip install opencv-python-headless ```
De este codigo: pipeline\_config = pipeline\_pb2.TrainEvalPipelineConfig with tf.io.gfile.GFile(target\_config, "r") as f: proto\_str = f.read() text\_format.Merge(proto\_str, pipeline\_config) Tengo el siguiente error: AttributeError: 'google.protobuf.pyext.\_message.FieldProperty' object has no attribute 'SetInParent'