Entrenamiento de nuestro modelo de clasificación optimizado

Clase 21 de 25 • Curso de Redes Neuronales Convolucionales con Python y Keras

Contenido del curso

Redes convolucionales y su importancia

Mi primera red neuronal convolucional

Manejo de imágenes

Fundamentos de redes neuronales convolucionales

Resolviendo un problema de clasificación

Optimización de red neuronal convolucional

Resolviendo una competencia de Kaggle

Resumen y siguientes pasos

Tomar examen

Mario Alexander Vargas Celis

student•

Para entrenar un modelo de clasificación optimizado con redes neuronales convolucionales (CNN), se pueden aplicar varias estrategias de optimización, como el uso de técnicas de **regularización**, **data augmentation**, y **callbacks** como **EarlyStopping** y **ModelCheckpoint** para controlar el entrenamiento y mejorar el rendimiento del modelo.

A continuación, te guiaré a través de un ejemplo paso a paso para entrenar un modelo optimizado utilizando el conjunto de datos **Fashion MNIST**.

### Paso 1: Cargar y preprocesar los datos

Vamos a usar el conjunto de datos **Fashion MNIST**, que contiene imágenes de 28x28 píxeles en escala de grises de diferentes artículos de ropa.


import tensorflow as tf

from tensorflow.keras.datasets import fashion\_mnist

from tensorflow.keras.utils import to\_categorical



\# Cargar los datos

(x\_train, y\_train), (x\_test, y\_test) = fashion\_mnist.load\_data()



\# Redimensionar las imágenes para que tengan una dimensión de canal

x\_train = x\_train.reshape(-1, 28, 28, 1)

x\_test = x\_test.reshape(-1, 28, 28, 1)



\# Normalizar los valores de los píxeles entre 0 y 1

x\_train = x\_train.astype('float32') / 255

x\_test = x\_test.astype('float32') / 255



\# Convertir las etiquetas a formato one-hot

y\_train = to\_categorical(y\_train, 10)

y\_test = to\_categorical(y\_test, 10)

### Paso 2: Crear el modelo CNN

Este es el modelo básico con capas de convolución, activación, max pooling, y regularización mediante **Dropout** y **Batch Normalization**.


from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout, BatchNormalization



\# Definir el modelo

model = Sequential()



\# Primera capa de convolución

model.add(Conv2D(32, (3, 3), padding='same', activation='relu', input\_shape=(28, 28, 1)))

model.add(BatchNormalization())

model.add(MaxPooling2D(pool\_size=(2, 2)))

model.add(Dropout(0.25))



\# Segunda capa de convolución

model.add(Conv2D(64, (3, 3), padding='same', activation='relu'))

model.add(BatchNormalization())

model.add(MaxPooling2D(pool\_size=(2, 2)))

model.add(Dropout(0.25))



\# Aplanar y capas completamente conectadas

model.add(Flatten())

model.add(Dense(128, activation='relu'))

model.add(Dropout(0.5))



\# Capa de salida

model.add(Dense(10, activation='softmax'))



\# Resumen del modelo

model.summary()

### Paso 3: Compilar el modelo

Elegimos un optimizador adecuado y configuramos una función de pérdida y métricas de evaluación.


model.compile(optimizer='adam',&#x20;

&#x20;             loss='categorical\_crossentropy',&#x20;

&#x20;             metrics=\['accuracy'])

### Paso 4: Callbacks (EarlyStopping y ModelCheckpoint)

Utilizaremos **EarlyStopping** para detener el entrenamiento si el rendimiento en los datos de validación deja de mejorar, y **ModelCheckpoint** para guardar el mejor modelo.


from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint



\# Guardar el mejor modelo

checkpoint = ModelCheckpoint('mejor\_modelo.h5', monitor='val\_accuracy', save\_best\_only=True, verbose=1)



\# Detener el entrenamiento si no mejora la precisión de validación

early\_stopping = EarlyStopping(monitor='val\_accuracy', patience=5, verbose=1)



\# Lista de callbacks

callbacks = \[checkpoint, early\_stopping]

### Paso 5: Entrenamiento con Data Augmentation

El **Data Augmentation** genera nuevas imágenes a partir de las existentes mediante transformaciones aleatorias, lo que mejora la capacidad de generalización del modelo.


from tensorflow.keras.preprocessing.image import ImageDataGenerator



\# Crear un generador de datos con augmentación

datagen = ImageDataGenerator(rotation\_range=20,&#x20;

&#x20;                            width\_shift\_range=0.2,&#x20;

&#x20;                            height\_shift\_range=0.2,&#x20;

&#x20;                            horizontal\_flip=True)



\# Ajustar el generador a los datos de entrenamiento

datagen.fit(x\_train)



\# Entrenar el modelo

history = model.fit(datagen.flow(x\_train, y\_train, batch\_size=32),&#x20;

&#x20;                   epochs=50,&#x20;

&#x20;                   validation\_data=(x\_test, y\_test),&#x20;

&#x20;                   callbacks=callbacks)

### Paso 6: Evaluar el modelo

Finalmente, evaluamos el rendimiento del mejor modelo guardado en el conjunto de datos de prueba.


\# Cargar el mejor modelo guardado

mejor\_modelo = tf.keras.models.load\_model('mejor\_modelo.h5')



\# Evaluar el modelo en los datos de prueba

score = mejor\_modelo.evaluate(x\_test, y\_test, verbose=0)

print(f'Pérdida en test: {score\[0]}')

print(f'Precisión en test: {score\[1]}')

### Explicación de los Componentes Clave:

1. **Batch Normalization**: Acelera el entrenamiento y mejora la estabilidad al normalizar las entradas a cada capa.

2. **Dropout**: Reduce el sobreajuste al apagar aleatoriamente neuronas durante el entrenamiento.

3. **EarlyStopping**: Detiene el entrenamiento si el modelo deja de mejorar después de un número fijo de épocas.

4. **ModelCheckpoint**: Guarda el modelo con mejor rendimiento durante el entrenamiento.

5. **Data Augmentation**: Mejora la capacidad del modelo para generalizar al modificar las imágenes de entrenamiento.

Con este enfoque, tienes un modelo optimizado para la clasificación de imágenes, que debería generalizar mejor en datos no vistos y tener un entrenamiento más eficiente.

Entrenamiento de nuestro modelo de clasificación optimizado

Redes convolucionales y su importancia

La importancia del computer vision

¿Qué herramientas usaremos para redes neuronales convolucionales?

¿Qué son las redes convolucionales?

Mi primera red neuronal convolucional

Creando nuestra primera red convolucional

Entrenando nuestra primera red convolucional

Manejo de imágenes

Consejos para el manejo de imágenes

Manejo de imágenes con Python

Fundamentos de redes neuronales convolucionales

Kernel en redes neuronales

El kernel en acción

Padding y Strides

Capa de pooling

Arquitectura de redes convolucionales

Resolviendo un problema de clasificación

Clasificación con redes neuronales convolucionales

Creación de red convolucional para clasificación

Entrenamiento de un modelo de clasificación con redes convolucionales

Optimización de red neuronal convolucional

Data augmentation

Aplicando data augmentation

Callbacks: early stopping y checkpoints

Batch normalization

Optimización de modelo de clasificación