Entrenando nuestra primera red convolucional

Hola¡
Les traigo un método alternativo para desarrollar esta red neuronal, con este método no usarán categorical_crossentropy ni
from tensorflow.keras.utils import to_categorical, ni tampoco “softmax” en la ultima capa Dense, en cambio solo usarán SparseCategoricalCrossEntropy. El codigo es el siguiente:

yo probe con 10, 25 y 50, y estos fueron mis resultados:

10 [0.28235912322998047, 0.9017999768257141]
25 [0.36978527903556824, 0.8761000037193298]
50 [0.43726015090942383, 0.8583999872207642]

¡Claro! Vamos a crear un ejemplo de entrenamiento de una red neuronal convolucional (CNN) utilizando TensorFlow y el conjunto de datos Fashion MNIST. Este conjunto de datos contiene imágenes de ropa en 10 categorías diferentes. Te proporcionaré el código y una explicación detallada del proceso. \### Ejemplo de Código Aquí tienes un ejemplo de cómo construir y entrenar una CNN en TensorFlow: ```python import tensorflow as tf from tensorflow.keras.datasets import fashion\_mnist from tensorflow.keras.layers import Conv2D, MaxPooling2D, Dropout, Flatten, Dense, Input from tensorflow.keras.models import Sequential from tensorflow.keras.utils import to\_categorical import matplotlib.pyplot as plt \# Cargar el conjunto de datos (train\_images, train\_labels), (test\_images, test\_labels) = fashion\_mnist.load\_data() \# Preprocesar las imágenes train\_images = train\_images.reshape((60000, 28, 28, 1)).astype('float32') / 255.0 # Normalizar y redimensionar test\_images = test\_images.reshape((10000, 28, 28, 1)).astype('float32') / 255.0 # Normalizar y redimensionar \# Convertir etiquetas a formato categórico train\_labels = to\_categorical(train\_labels, num\_classes=10) test\_labels = to\_categorical(test\_labels, num\_classes=10) \# Definir el modelo model = Sequential() model.add(Input(shape=(28, 28, 1))) # Capa de entrada model.add(Conv2D(filters=64, kernel\_size=(3, 3), padding='same', activation='relu')) model.add(MaxPooling2D(pool\_size=(2, 2))) model.add(Dropout(0.3)) model.add(Conv2D(filters=32, kernel\_size=(3, 3), padding='same', activation='relu')) model.add(MaxPooling2D(pool\_size=(2, 2))) model.add(Dropout(0.3)) model.add(Flatten()) model.add(Dense(256, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(10, activation='softmax')) \# Compilar el modelo model.compile(optimizer='adam', loss='categorical\_crossentropy', metrics=\['accuracy']) \# Entrenar el modelo history = model.fit(train\_images, train\_labels, epochs=10, batch\_size=64, validation\_split=0.2) \# Evaluar el modelo test\_loss, test\_accuracy = model.evaluate(test\_images, test\_labels) print(f'Test accuracy: {test\_accuracy:.4f}') \# Graficar la pérdida y precisión durante el entrenamiento plt.plot(history.history\['accuracy'], label='Precisión de entrenamiento') plt.plot(history.history\['val\_accuracy'], label='Precisión de validación') plt.title('Precisión del modelo') plt.ylabel('Precisión') plt.xlabel('Épocas') plt.legend() plt.show() ``` \### Explicación del Código 1\. \*\*Carga de Datos\*\*: \- Utilizamos `fashion\_mnist.load\_data()` para cargar el conjunto de datos. Contiene imágenes de ropa, divididas en un conjunto de entrenamiento (60,000 imágenes) y un conjunto de prueba (10,000 imágenes). 2\. \*\*Preprocesamiento\*\*: \- Redimensionamos las imágenes a un formato adecuado para la red convolucional (28x28x1), ya que son imágenes en escala de grises. \- Normalizamos los valores de los píxeles dividiendo por 255.0 para que estén en el rango \[0, 1]. \- Convertimos las etiquetas en formato categórico utilizando `to\_categorical()`, para que el modelo pueda interpretar las clases de manera adecuada. 3\. \*\*Definición del Modelo\*\*: \- Usamos `Sequential()` para construir el modelo de manera lineal. \- \*\*Capas Convolucionales\*\* (`Conv2D`): \- La primera capa convolucional tiene 64 filtros de tamaño 3x3 y usa la activación ReLU. \- La segunda capa tiene 32 filtros, también de tamaño 3x3. \- \*\*Max Pooling\*\* (`MaxPooling2D`): Se utiliza para reducir las dimensiones de la imagen, preservando características importantes. \- \*\*Dropout\*\*: Se agrega para prevenir el sobreajuste al desactivar un porcentaje de las neuronas durante el entrenamiento. \- \*\*Capa densa\*\* (`Dense`): Se utiliza para la clasificación final. La última capa tiene 10 neuronas (una por cada categoría) con activación softmax. 4\. \*\*Compilación del Modelo\*\*: \- Usamos el optimizador Adam y la función de pérdida de entropía cruzada categórica. La métrica de precisión se utiliza para evaluar el rendimiento. 5\. \*\*Entrenamiento\*\*: \- Entrenamos el modelo durante 10 épocas con un tamaño de lote de 64. Usamos una fracción del conjunto de entrenamiento (20%) para validación. 6\. \*\*Evaluación\*\*: \- Evaluamos el modelo en el conjunto de prueba y mostramos la precisión. 7\. \*\*Visualización\*\*: \- Graficamos la precisión de entrenamiento y validación a lo largo de las épocas para observar el rendimiento del modelo. \### Conclusión Este código proporciona un punto de partida para trabajar con redes neuronales convolucionales en tareas de clasificación de imágenes. Puedes experimentar con diferentes arquitecturas, parámetros y técnicas de regularización para mejorar el rendimiento del modelo en el conjunto de datos de Fashion MNIST.

Llega un punto en donde el modelo no llega a aprender mas, si no que se queda estancado en solo un porcentaje de mejora esto puede dar como que el modelo es una tarea muy simple, pero ahora tonta el reto de verdad, ver si realmente etiqueta cada imagen.


Mis Resultados

Epoch 1/10
938/938 ━━━━━━━━━━━━━━━━━━━━ 5s 4ms/step - accuracy: 0.9922 - loss: 0.0249
Epoch 2/10
938/938 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9943 - loss: 0.0185
Epoch 3/10
938/938 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9952 - loss: 0.0148
Epoch 4/10
938/938 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9963 - loss: 0.0115
Epoch 5/10
938/938 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9974 - loss: 0.0088
Epoch 6/10
938/938 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9973 - loss: 0.0080
Epoch 7/10
938/938 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9981 - loss: 0.0058
Epoch 8/10
938/938 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9984 - loss: 0.0047
Epoch 9/10
938/938 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9985 - loss: 0.0056
Epoch 10/10
938/938 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9991 - loss: 0.0030
<keras.src.callbacks.history.History at 0x7f65a80e5ea0>

[0.04491740092635155, 0.9926000237464905]

😽😽

Sin validation split, resultado de evaluación:
[0.2683935761451721, 0.9047999978065491]

Con validation split=0.2, resultado de evaluación:
[0.24510954320430756, 0.9143000245094]

Esto confirma por qué tan importante es usar data de validación en el entrenamiento de nuestro modelo (como ya se vió en el curso de Fundamentos de Redes neuronales) 😄