Entrenamiento de nuestro modelo de clasificación optimizado

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

George Wang Lee Zevallos Durand

student•

Antes de correr el entrenamiento ponganse cómodos y abran Netflix porque tarda alrededor de 1 hora entrenar el modelo.

Andrés Felipe Sierra Sanchez

student•

Grande, me echo un par de partidas del Warzone

Joel Orellana

student•

asi me di cuenta jajaja

Henry Mendiburu Díaz

student•

steps_per_epoch = (number_of_samples_in_train_data / batch_size) en qué afecta este parámetro?, da lo mismo dejar el valor por defecto?

Alarcon7a

student•

Para nuestro caso que usamos data augmentation, indica cuantos batches generara por cada epoca, por default usara la ecucacion que utilizamos en el curso, pero como generamos infintos batches es mejor definirlo previamente.

esto nos menciona keras aca https://www.tensorflow.org/api_docs/python/tf/keras/Model _ Integer or None. Total number of steps (batches of samples) before declaring one epoch finished and starting the next epoch. When training with input tensors such as TensorFlow data tensors, the default None is equal to the number of samples in your dataset divided by the batch size, or 1 if that cannot be determined. If x is a tf.data dataset, and 'steps_per_epoch' is None, the epoch will run until the input dataset is exhausted. When passing an infinitely repeating dataset, you must specify the steps_per_epoch argument. If steps_per_epoch=-1 the training will run indefinitely with an infinitely repeating dataset. This argument is not supported with array inputs. When using tf.distribute.experimental.ParameterServerStrategy: steps_per_epoch=None is not supported. _

Gabriel Ichcanziho Pérez Landa

student•

Como nota interesante, una vez que has terminado el entrenamiento y se ha generado tu best model nada te prohibe, abrirlo y seguirlo entrenando un par de iteraciones más.

Adjunto mi código para que se den una idea:

 # Checkpoint Callback
    checkpoint_cb = ModelCheckpoint("models/best_model.h5", verbose=1, save_best_only=True, monitor="val_acc")

    if not exists("models/best_model.h5"):
        print("Entrenando por primera vez")
        print("*" * 64)
        print("Creando arquitectura")
        md = architecture(base_filtros=32, w_regularized=1e-4, shape=x_train[0].shape, num_classes=num_clases)
        print("*" * 64)
        print("Empezando a entrenar")
        md.compile(optimizer=Adam(), loss="categorical_crossentropy", metrics=["acc"])
        history = md.fit(datagen.flow(x_train, y_train, batch_size=128),
                         callbacks=[checkpoint_cb],
                         steps_per_epoch=x_train.shape[0] // 128,
                         epochs=50,
                         verbose=2,
                         validation_data=(x_valid, y_valid))
        plot_results(history, "acc", "resultado_tuneado.png")

    else:
        print("Abriendo modelo y continuando entrenamiento")
        md = load_model("models/best_model.h5")
        history = md.fit(datagen.flow(x_train, y_train, batch_size=128),
                         callbacks=[checkpoint_cb],
                         steps_per_epoch=x_train.shape[0] // 128,
                         epochs=20,
                         verbose=2,
                         validation_data=(x_valid, y_valid))

        plot_results(history, "acc", "resultado_tuneado_2.png")

!Resultados

Diego Sepúlveda

student•

Profesor, pregunta, me encantaría probar diferentes configuraciones, pero tener que esperar 15 minutos para ver el resultado es algo que reduce la cantidad de veces que uno pueda probar. Existe alguna recomendación para ello? Cómo se hace esto en vía profesional / práctica? Tengo en mi cabeza muchas configuraciones que podría probar, pero este modelo de ahora demoró 30 minutos por eso lo digo.

Cristian Tinipuclla

student•

Puedes utilizar early stopping como vimos en la clase de callbacks, con un patience de 3 por ejemplo, cosa que si en 3 épocas seguidas no hay una mejora del accuracy, el entrenamiento para.

early = tf.keras.callbacks.EarlyStopping(monitor='accuracy',patience=3)

Y de ahí lo llamas en el model.fit(), dale una chequeada a esa clase 😊

Robert Yesid Barrios Acendra

student•

Me perdí, ¿En qué lugar del proceso sucede que a las nuevas imágenes generadas por data augmentation se les etiqueta?

Alarcon7a

student•

Toman la etiqueta de la carpeta

Alarcon7a

student•

toma los labels del folder

Nicolas Cordoba

student•

con el datagen, la idea es hacer data augmentation, pero de que forma puedo decidir, la cantidad de imagenes diferentes que quiero que use? quisiera implementar esto con un dataset mucho mas pequeño de 350 imagenes

Hebert Elias Palmera Buelvas

student•

para el data augmentation he trabajado previamente con una libreria que se llama augmentor. Con ImageDataGenerator, como se cuantas imagenes nuevas estoy generando por cada imagen original del dataset?

Noe Adrián Acuña Prado

student•

esto nos menciona keras aca _ Integer or None. Total number of steps (batches of samples) before declaring one epoch finished and starting the next epoch. When training with input tensors such as TensorFlow data tensors, the default None is equal to the number of samples in your dataset divided by the batch size, or 1 if that cannot be determined. If x is a tf.data dataset, and 'steps_per_epoch' is None, the epoch will run until the input dataset is exhausted. When passing an infinitely repeating dataset, you must specify the steps_per_epoch argument. If steps_per_epoch=-1 the training will run indefinitely with an infinitely repeating dataset. This argument is not supported with array inputs. When using tf.distribute.experimental.ParameterServerStrategy: steps_per_epoch=None is not supported. _

Andrés Felipe Sierra Sanchez

student•

Con graficas amd se puede?

Luis GR

student•

Claro!, depende de la capacidad de memoria VRAM de tu gráfica AMD, debes consultarla utilizando "Información del siistema" o en el administrador de tareas., normalmente las gráficas AMD corren bien, pero preferiblemente se utiizan Gráficas NVIDEA Geforce o superior

Diego Molina

student•

Hola, una consulta Luego de entrenar el modelo, según lo visto en la clase, obtuve un accuracy de 83,4%. Luego, al generar el model2=model y cargar en model2 los mejores pesos ("mi mejor modelo"), al evaluar con model2.evaluate(x_test,y_test) me dan los siguientes resultados: [2078033.875, 0.28049999475479126] ¿Qué estaría ocurrendo?

rogelio cortez

student•

El número de lotes que se crearán en datagen.flow() depende del tamaño del conjunto de datos, el tamaño del lote especificado y el número de pasos por época. Si no se establece un steps_per_epoch explícitamente, Keras continuará generando lotes hasta que se agoten todos los datos. Es importante definir steps_per_epoch o proporcionar un tamaño de datos que se ajuste a tu modelo para controlar este comportamiento.

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.

Jhon Freddy Tavera Blandon

student•

Epoch 1/20
384/391 ━━━━━━━━━━━━━━━━━━━━ 0s 99ms/step - accuracy: 0.1996 - loss: 2.1047
391/391 ━━━━━━━━━━━━━━━━━━━━ 46s 105ms/step - accuracy: 0.2010 - loss: 2.1013 - val_accuracy: 0.3720 - val_loss: 1.6851
Epoch 2/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.3685 - loss: 1.6976 - val_accuracy: 0.4526 - val_loss: 1.5051
Epoch 3/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.4288 - loss: 1.5673 - val_accuracy: 0.4945 - val_loss: 1.4209
Epoch 4/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 37s 93ms/step - accuracy: 0.4615 - loss: 1.4908 - val_accuracy: 0.5006 - val_loss: 1.3773
Epoch 5/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.4906 - loss: 1.4152 - val_accuracy: 0.5245 - val_loss: 1.3175
Epoch 6/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 92ms/step - accuracy: 0.5102 - loss: 1.3676 - val_accuracy: 0.5637 - val_loss: 1.2155
Epoch 7/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.5174 - loss: 1.3467 - val_accuracy: 0.5705 - val_loss: 1.1890
Epoch 8/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.5394 - loss: 1.2960 - val_accuracy: 0.5858 - val_loss: 1.1732
Epoch 9/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 37s 92ms/step - accuracy: 0.5484 - loss: 1.2656 - val_accuracy: 0.5985 - val_loss: 1.1295
Epoch 10/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.5630 - loss: 1.2347 - val_accuracy: 0.5931 - val_loss: 1.1346
Epoch 11/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.5690 - loss: 1.2147 - val_accuracy: 0.6115 - val_loss: 1.0975
Epoch 12/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 90ms/step - accuracy: 0.5773 - loss: 1.1939 - val_accuracy: 0.6341 - val_loss: 1.0285
Epoch 13/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 90ms/step - accuracy: 0.5855 - loss: 1.1819 - val_accuracy: 0.6211 - val_loss: 1.0559
Epoch 14/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.5829 - loss: 1.1710 - val_accuracy: 0.6284 - val_loss: 1.0315
Epoch 15/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.5975 - loss: 1.1436 - val_accuracy: 0.6196 - val_loss: 1.0725
Epoch 16/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 90ms/step - accuracy: 0.6034 - loss: 1.1338 - val_accuracy: 0.6098 - val_loss: 1.1229
Epoch 17/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 37s 93ms/step - accuracy: 0.6082 - loss: 1.1112 - val_accuracy: 0.6426 - val_loss: 1.0291
Epoch 18/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.6121 - loss: 1.1037 - val_accuracy: 0.6594 - val_loss: 0.9613
Epoch 19/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.6172 - loss: 1.0911 - val_accuracy: 0.6101 - val_loss: 1.1146
Epoch 20/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 90ms/step - accuracy: 0.6174 - loss: 1.0960 - val_accuracy: 0.6443 - val_loss: 0.9951

313/313 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.6421 - loss: 1.0004
[0.9950822591781616, 0.6442999839782715]

 # Checkpoint Callback
    checkpoint_cb = ModelCheckpoint("models/best_model.h5", verbose=1, save_best_only=True, monitor="val_acc")

    if not exists("models/best_model.h5"):
        print("Entrenando por primera vez")
        print("*" * 64)
        print("Creando arquitectura")
        md = architecture(base_filtros=32, w_regularized=1e-4, shape=x_train[0].shape, num_classes=num_clases)
        print("*" * 64)
        print("Empezando a entrenar")
        md.compile(optimizer=Adam(), loss="categorical_crossentropy", metrics=["acc"])
        history = md.fit(datagen.flow(x_train, y_train, batch_size=128),
                         callbacks=[checkpoint_cb],
                         steps_per_epoch=x_train.shape[0] // 128,
                         epochs=50,
                         verbose=2,
                         validation_data=(x_valid, y_valid))
        plot_results(history, "acc", "resultado_tuneado.png")

    else:
        print("Abriendo modelo y continuando entrenamiento")
        md = load_model("models/best_model.h5")
        history = md.fit(datagen.flow(x_train, y_train, batch_size=128),
                         callbacks=[checkpoint_cb],
                         steps_per_epoch=x_train.shape[0] // 128,
                         epochs=20,
                         verbose=2,
                         validation_data=(x_valid, y_valid))

        plot_results(history, "acc", "resultado_tuneado_2.png") 

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)

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()

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]

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)

\# 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]}')

Epoch 1/20
384/391 ━━━━━━━━━━━━━━━━━━━━ 0s 99ms/step - accuracy: 0.1996 - loss: 2.1047
391/391 ━━━━━━━━━━━━━━━━━━━━ 46s 105ms/step - accuracy: 0.2010 - loss: 2.1013 - val_accuracy: 0.3720 - val_loss: 1.6851
Epoch 2/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.3685 - loss: 1.6976 - val_accuracy: 0.4526 - val_loss: 1.5051
Epoch 3/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.4288 - loss: 1.5673 - val_accuracy: 0.4945 - val_loss: 1.4209
Epoch 4/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 37s 93ms/step - accuracy: 0.4615 - loss: 1.4908 - val_accuracy: 0.5006 - val_loss: 1.3773
Epoch 5/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.4906 - loss: 1.4152 - val_accuracy: 0.5245 - val_loss: 1.3175
Epoch 6/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 92ms/step - accuracy: 0.5102 - loss: 1.3676 - val_accuracy: 0.5637 - val_loss: 1.2155
Epoch 7/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.5174 - loss: 1.3467 - val_accuracy: 0.5705 - val_loss: 1.1890
Epoch 8/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.5394 - loss: 1.2960 - val_accuracy: 0.5858 - val_loss: 1.1732
Epoch 9/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 37s 92ms/step - accuracy: 0.5484 - loss: 1.2656 - val_accuracy: 0.5985 - val_loss: 1.1295
Epoch 10/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.5630 - loss: 1.2347 - val_accuracy: 0.5931 - val_loss: 1.1346
Epoch 11/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.5690 - loss: 1.2147 - val_accuracy: 0.6115 - val_loss: 1.0975
Epoch 12/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 90ms/step - accuracy: 0.5773 - loss: 1.1939 - val_accuracy: 0.6341 - val_loss: 1.0285
Epoch 13/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 90ms/step - accuracy: 0.5855 - loss: 1.1819 - val_accuracy: 0.6211 - val_loss: 1.0559
Epoch 14/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.5829 - loss: 1.1710 - val_accuracy: 0.6284 - val_loss: 1.0315
Epoch 15/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.5975 - loss: 1.1436 - val_accuracy: 0.6196 - val_loss: 1.0725
Epoch 16/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 90ms/step - accuracy: 0.6034 - loss: 1.1338 - val_accuracy: 0.6098 - val_loss: 1.1229
Epoch 17/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 37s 93ms/step - accuracy: 0.6082 - loss: 1.1112 - val_accuracy: 0.6426 - val_loss: 1.0291
Epoch 18/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.6121 - loss: 1.1037 - val_accuracy: 0.6594 - val_loss: 0.9613
Epoch 19/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.6172 - loss: 1.0911 - val_accuracy: 0.6101 - val_loss: 1.1146
Epoch 20/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 90ms/step - accuracy: 0.6174 - loss: 1.0960 - val_accuracy: 0.6443 - val_loss: 0.9951

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

Entrenamiento de nuestro modelo de clasificación optimizado

Resolviendo una competencia de Kaggle

Clasificando entre perros y gatos

Entrenamiento del modelo de clasificación de perros y gatos

Resumen y siguientes pasos

Siguientes pasos con redes neuronales convolucionales

Comparte tu proyecto de clasificación con redes convolucionales y certifícate