Datasets generators

Curso Profesional de Redes Neuronales con TensorFlow

Contenido del curso

Cómo utilizar TensorFlow 2.0 con Python

Manejo y preprocesamiento de datos para redes neuronales

Optimización de precisión de modelos

Almacenamiento y carga de modelos

Fundamentos de aprendizaje por transferencia

Resultados de entrenamiento

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0018:36

Datasets generators

Curso Profesional de Redes Neuronales con TensorFlow

Clase 8 de 28

Clase 8 / 28

Recursos

Cuando trabajes con datasets encontrarás bases de datos ya generadas y listas para consumo, pero eventualmente te toparás con la necesidad de crear tus propios datos, por lo que deberás encontrar una manera de cargarlos.

En el momento que cargas datos a memoria, lo haces directamente a la memoria RAM del sistema, por lo que si cargas un dataset pesado de golpe, es probable que termines colapsando tu entorno de trabajo por saturación de recursos.

Para evitar este problema, se crean los generadores, una estructura de datos que generará datos solo si es recorrida, optimizando memoria.

Descargando el dataset de lenguaje de señas

Descargaremos el repositorio desde GCP.

!wget --no-check-certificate https://storage.googleapis.com/platzi-tf2/sign-language-img.zip \
    -O /tmp/sign-language-img.zip

Descomprimiremos el archivo, para esto usaremos los módulos de os y zipfile.

import os
import zipfile

local_zip = "/tmp/sign-language-img.zip"
zip_ref = zipfile.ZipFile(local_zip, "r")
zip_ref.extractall("/tmp/sign-language-img")
zip_ref.close()

La estructura del dataset constará en 2 directorios principales: Test y Train, donde para cada clase (letra en señas) tendremos un directorio con sus respectivos ejemplos.

sign-language-image/
├── Test/
│   └── A-Z/
│       └── examples.jpg
└── Train/
    └── A-Z/
        └── examples.jpg

Cargando el dataset con Keras dataset generator

Para llevar a cabo el proceso de carga, haremos uso de varias librerías como TensorFlow, matplotlib y numpy.

import numpy as np
%matplotlib inline
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import string
import tensorflow as tf
from tensorflow.keras.preprocessing.image import ImageDataGenerator

Cargaremos las rutas donde se encuentran nuestros dataset.

train_dir = "/tmp/sign-language-img/Train"
test_dir = "/tmp/sign-language-img/Test"

Generaremos los data generators, para esta ocasión reescalaremos los datos al rango de 0 a 1 para mejorar la convergencia del modelo, además, dividiremos el 20% de los datos de prueba a validación para monitorear el rendimiento del modelo en vivo.

train_datagen = ImageDataGenerator(rescale = 1/255)
test_datagen = ImageDataGenerator(rescale = 1/255, validation_split = 0.2)

Para cargar las imágenes, haremos uso del método flow_from_directory del generador, determinaremos el directorio fuente, el tamaño que tendrán las imágenes (el generador las redimensionará de ser necesario), los lotes de procesamiento, el tipo de clases, el tipo de escala de colores y el subset al que pertenecen.

train_generator = train_datagen.flow_from_directory(
    train_dir,
    target_size = (28,28),
    batch_size = 128,
    class_mode = "categorical",
    color_mode = "grayscale",
    subset = "training"
)

Para los subsets de validación y prueba será el mismo proceso, donde cambiarán los nombres de las variables y las fuentes.

validation_generator = test_datagen.flow_from_directory(
    test_dir,
    target_size = (28,28),
    batch_size = 128,
    class_mode = "categorical",
    color_mode = "grayscale",
    subset = "validation"
)

test_generator = train_datagen.flow_from_directory(
    test_dir,
    target_size = (28,28),
    batch_size = 128,
    class_mode = "categorical",
    color_mode = "grayscale",
)

Para generar las clases haremos una pequeña list comprehension recorriendo los caracteres ASCII omitiendo las letras J y Z.

classes = [char for char in string.ascii_uppercase if char != "J" if char != "Z"]

Para graficar imágenes crearemos la función plotImages que recibirá un array de imágenes y las mostrará en pantalla en grupos de 5.

def plotImages(images_arr):
  fig, axes = plt.subplots(1, 5, figsize = (10, 10))
  axes = axes.flatten()
  for img, ax in zip(images_arr, axes):
    ax.imshow(img[:,:,0])
    ax.axis("off")
  plt.tight_layout()
  plt.show()

Para hacer uso de esta función generaremos un conjunto de imágenes, esto nos retornará un array de imágenes que daremos como parámetro.

sample_training_images, _ = next(train_generator)
plotImages(sample_training_images[:5])

Con esto hemos cargado imágenes en memoria sin necesidad de saturar la memoria del sistema, cada vez que requieras iterar sobre tu dataset el generador solo generará las imágenes necesarias.

Contribución creada por Sebastián Franco Gómez.

Jesús Alberto Romero Hernández

Hace 5 meses

Usé la extensión o add Google Colab de VSCode en paralelo con gemini assist. No usé Jupiter Notebooks sino Jupiter Interactive lo cual me parece mejor:

# %% [markdown]
## Importación de Bibliotecas
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import os
import tensorflow as tf
import zipfile
from PIL import Image
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from io import BytesIO


# %% [markdown]
## Carga del Dataset

# Esto te dirá exactamente dónde está parado Python en este seg
# %% [markdown]
## Carga del Dataset

base_path = "/home/jesusr/Proyectos_Deep_Learning/Curso_Prof_de_Red_Neuro_con_TensorFlow"
data_dir = os.path.join(base_path, "data", "brain_tumors")
local = os.path.join(data_dir, "databasesLoadData.zip")
extract_dir = os.path.join(data_dir, "dataset_extraido")

# CRÍTICO: Primero creamos la carpeta, de lo contrario wget no tendrá dónde guardar
os.makedirs(data_dir, exist_ok=True)

if os.path.isdir(data_dir):
    print(f"Directorio confirmado en: {data_dir}")

    # Corregido: La URL debe ir entre comillas
    url = "https://www.kaggle.com/api/v1/datasets/download/masoudnickparvar/brain-tumor-mri-dataset"
    
    # Descarga
    print("Iniciando descarga...")
    !wget --no-check-certificate "{url}" -O "{local}"
        
    ## 5. Extracción
    if os.path.exists(local):
        print(f"¡Éxito! Archivo descargado en: {local}")
        
        # Lógica de extracción que faltaba
        with zipfile.ZipFile(local, 'r') as zip_ref:
            zip_ref.extractall(extract_dir)
        print(f"Dataset extraído en: {extract_dir}")
    else:
        print("ERROR: wget no pudo guardar el archivo. Verifica tu conexión o el enlace.")
else:
    print(f"ERROR: No se pudo crear el directorio {data_dir}.")
        
# %% [markdown]
## Train y Test
train="/home/jesusr/Proyectos_Deep_Learning/Curso_Prof_de_Red_Neuro_con_TensorFlow/data/brain_tumors/dataset_extraido/Training"
test="/home/jesusr/Proyectos_Deep_Learning/Curso_Prof_de_Red_Neuro_con_TensorFlow/data/brain_tumors/dataset_extraido/Testing"


# Definimos los parámetros comunes
IMG_SIZE = (224, 224)
BATCH_SIZE = 32

# Cargamos el set de ENTRENAMIENTO (80%)
# Cargamos el set de ENTRENAMIENTO (80% de la carpeta Training)
train_ds = tf.keras.utils.image_dataset_from_directory(
    extract_dir + '/Training',
    validation_split=0.2,
    class_names=['glioma', 'meningioma', 'notumor', 'pituitary'],
    subset="training",
    seed=42,
    image_size=IMG_SIZE, 
    batch_size=BATCH_SIZE
)

# Cargamos el set de VALIDACIÓN (20% de la carpeta Training)
val_ds = tf.keras.utils.image_dataset_from_directory(
    extract_dir + '/Training',
    validation_split=0.2,
    class_names=['glioma', 'meningioma', 'notumor', 'pituitary'],
    subset="validation",
    seed=42,
    image_size=IMG_SIZE,
    batch_size=BATCH_SIZE
)

# Cargamos el set de TEST (Carpeta Testing completa)
test_ds = tf.keras.utils.image_dataset_from_directory(
    extract_dir + '/Testing',
    class_names=['glioma', 'meningioma', 'notumor', 'pituitary'],
    
    shuffle=False,      # ¡Importante! Mantiene el orden para la evaluación final
    image_size=IMG_SIZE,
    batch_size=BATCH_SIZE
    # Nota: No usamos 'subset' ni 'validation_split' aquí
)
# %% [markdown]
# Visualización de 5 imágenes

plt.figure(figsize=(10, 10))
for images, labels in train_ds.take(1): # Tomamos un batch del dataset de entrenamiento
    for i in range(5): # Iteramos sobre las primeras 5 imágenes del batch
        ax = plt.subplot(1, 5, i + 1)
        plt.imshow(images[i].numpy().astype("uint8")) # Mostramos la imagen
        plt.title(train_ds.class_names[labels[i]]) # Establecemos el título con el nombre de la clase
        plt.axis("off") # Ocultamos los ejes
plt.show()

Comentarios (35)35 comentarios

Jose Luis Junior Perez Gil

Hace 5 años

Luis Fernando Islas Rodríguez

Adonai Vera

Profesor

Raul Perez-Alejo Neyra

Hace 4 años

Rafael Rivera

Eber Laurente Lliuyacc

Jason Sepulveda

Hace un año

Renato Agustín Lagos Albornoz

Víctor Trigo

Christian Ricardo Conchari Cabrera

Juan Acevedo

Gabriel Díaz Andrade

Diego Fernando Ortiz Gamboa

rogelio cortez

Hace 2 años

Jhonalbert Aponte

Platzi Team

Hace 3 años

Nicolas Cordoba

Cómo utilizar TensorFlow 2.0 con Python

Redes Neuronales y TensorFlow: Crea Modelos de IA desde Cero

Programación con TensorFlow 2 y Python: Fundamentos y Aplicaciones

Manejo y preprocesamiento de datos para redes neuronales

Carga y Procesamiento de Bases de Datos en Inteligencia Artificial

Carga de Bases de Datos JSON desde GCP en Google Colab

Codificación Base64 y Gestión de Imágenes en Google Colab

Preprocesamiento y limpieza de datos

Keras datasets

Datasets generators

Aprende a buscar bases de datos para deep learning

Cómo distribuir los datos

Crear la red neural, definir capas, compilar, entrenar, evaluar y predicciones

Optimización de precisión de modelos

Métodos de regularización: overfitting y underfitting

Recomendaciones prácticas para ajustar un modelo

Métricas para medir la eficiencia de un modelo: callback

Monitoreo del entrenamiento en tiempo real: early stopping y patience

KerasTuner: construyendo el modelo

KerasTuner: buscando la mejor configuración para tu modelo

Almacenamiento y carga de modelos

Almacenamiento y carga de modelos: pesos y arquitectura

Criterios para almacenar los modelos

Fundamentos de aprendizaje por transferencia

Introducción al aprendizaje por transferencia

Cuándo utilizar aprendizaje por transferencia

Carga de sistemas pre-entrenados en Keras

API funcional de Keras

Uso sistemas pre-entrenados de TensorFlow Hub

Resultados de entrenamiento

Introducción a variables relevantes del TensorBoard

Análisis y publicación de resultados del entrenamiento

Introducción al despliegue de modelos en producción

Siguientes pasos con deep learning

Datasets generators