Clasificación con redes neuronales convolucionales

El y train debería ser de la siguiente forma:

(y_train,y_valid)=y_train[5000:], y_train[:5000]

lo del minuto 9:55 debería quedar con y_train, no xon x_train:

(y_train, y_valid) = y_train[5000:], y_train[:5000]

Yo he tenido el siguiente error tratando de descargar los datos de cifar10:

Exception: URL fetch failure on https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz: None -- [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: certificate has expired (_ssl.c:1123)

Lo solucione añadiendo las dos siguientes líneas antes de la carga de datos:

import ssl
ssl._create_default_https_context = ssl._create_unverified_context

(X_train, y_train), (X_test, y_test) = cifar10.load_data()`

Por si a alguien le sirve.

adicional a la correccion que hacen sobre el y_train una buena practica es cambiar el nombre del x_train en ese punto

(x_training, x_valid) = x_train[5000:], x_train[:5000]
(y_training, y_valid) = y_train[5000:], y_train[:5000]
<code> 

Recuerden que cuando tengan que importar varias cosas pueden usar esta sintaxis

from tensorflow.keras.layers import  (Conv2D,MaxPooling2D,
Flatten, Dense, Dropout, Activation)

```js ##Forma de importar ahora import tensorflow as tf import keras from keras.api.utils import to_categorical from keras import layers, Sequential, regularizers from tf_keras.datasets import cifar10 from tf_keras.layers import Conv2D, Dropout, MaxPooling2D, Flatten, Dense, Activation ```

Las CNN son extremadamente eficaces para la clasificación de imágenes debido a su capacidad para aprender características jerárquicas de las imágenes. En este ejemplo, se construyó y entrenó un modelo CNN utilizando el dataset MNIST, mostrando cómo la red puede clasificar dígitos escritos a mano.

\### Clasificación con Redes Neuronales Convolucionales (CNN) La \*\*clasificación de imágenes\*\* mediante \*\*Redes Neuronales Convolucionales (CNN)\*\* es una de las aplicaciones más comunes en el campo de la visión por computadora. Las CNN son especialmente eficaces porque capturan patrones y características espaciales de las imágenes mediante la convolución, lo que las hace ideales para tareas como el reconocimiento de objetos, clasificación de imágenes, y más. \#### ¿Qué es la Clasificación de Imágenes? En la clasificación de imágenes, el objetivo es asignar una etiqueta a una imagen de acuerdo con las características visuales que presenta. Por ejemplo, en el conjunto de datos de \*\*MNIST\*\*, la tarea consiste en clasificar imágenes de dígitos escritos a mano en categorías de 0 a 9. \### ¿Cómo funcionan las CNN en la Clasificación de Imágenes? Las CNN utilizan varias capas, como convolucionales, de activación y de pooling, para extraer características relevantes de las imágenes de entrada. La información procesada pasa luego por capas completamente conectadas (fully connected), que funcionan como un clasificador y generan la probabilidad de que la imagen pertenezca a una determinada clase. \### Arquitectura de una CNN para Clasificación \- \*\*Entrada (Input Layer):\*\* Imagen en formato de píxeles, con dimensiones típicas como 28x28 píxeles en el caso del dataset MNIST. \- \*\*Capas Convolucionales (Conv Layer):\*\* Aplican filtros que detectan características locales, como bordes y patrones. \- \*\*Capas de Pooling (Max Pooling Layer):\*\* Reducen las dimensiones espaciales de los mapas de características, preservando la información más relevante. \- \*\*Capas Completamente Conectadas (Dense Layer):\*\* Conectan todas las neuronas de la capa anterior y producen una salida. \- \*\*Capa de Salida (Output Layer):\*\* Utiliza la activación \*\*softmax\*\* para producir una distribución de probabilidades sobre las clases posibles. \### Ejemplo Práctico de Clasificación de Imágenes con CNN usando TensorFlow y Keras Vamos a construir una CNN básica para clasificar imágenes del conjunto de datos \*\*MNIST\*\* (dígitos escritos a mano). \#### Paso 1: Importar las librerías necesarias ```python import tensorflow as tf from tensorflow.keras import layers, models from tensorflow.keras.datasets import mnist import matplotlib.pyplot as plt \# Cargar el conjunto de datos MNIST (train\_images, train\_labels), (test\_images, test\_labels) = mnist.load\_data() \# Redimensionar y normalizar los datos train\_images = train\_images.reshape((60000, 28, 28, 1)).astype('float32') / 255 test\_images = test\_images.reshape((10000, 28, 28, 1)).astype('float32') / 255 ``` \- Las imágenes de entrada se redimensionan a 28x28 píxeles y se les añade una dimensión de canal (1 en este caso porque es en escala de grises). \- Se normalizan dividiendo entre 255 para que los valores estén en el rango \[0, 1]. \#### Paso 2: Construir el modelo CNN ```python \# Definir el modelo model = models.Sequential() \# Primera capa convolucional model.add(layers.Conv2D(32, (3, 3), activation='relu', input\_shape=(28, 28, 1))) model.add(layers.MaxPooling2D((2, 2))) \# Segunda capa convolucional model.add(layers.Conv2D(64, (3, 3), activation='relu')) model.add(layers.MaxPooling2D((2, 2))) \# Tercera capa convolucional model.add(layers.Conv2D(64, (3, 3), activation='relu')) \# Aplanar las características y conectarlas a una capa densa model.add(layers.Flatten()) model.add(layers.Dense(64, activation='relu')) \# Capa de salida con 10 neuronas (10 clases) y softmax model.add(layers.Dense(10, activation='softmax')) \# Resumen del modelo model.summary() ``` \### Explicación del Modelo 1\. \*\*Primera Capa Convolucional:\*\* \- Aplica 32 filtros de 3x3 sobre la imagen de entrada. La activación `ReLU` introduce no linealidad, y la entrada es de tamaño 28x28x1. 2\. \*\*MaxPooling2D:\*\* \- Reduce la dimensionalidad espacial de la imagen con un tamaño de ventana 2x2, lo que genera una reducción del tamaño a la mitad. 3\. \*\*Segunda y Tercera Capa Convolucional:\*\* \- Detectan características más complejas al aplicar más filtros, 64 en este caso, con convoluciones de 3x3. 4\. \*\*Capa de Flatten:\*\* \- Aplana los datos de la red para pasarlos a la capa completamente conectada. 5\. \*\*Capas Densas:\*\* \- Primera capa completamente conectada con 64 neuronas, seguida de la capa de salida con 10 neuronas, donde cada neurona representa una clase. 6\. \*\*Capa de salida:\*\* \- Utiliza la activación \*\*softmax\*\* para obtener una distribución de probabilidades sobre las 10 posibles clases (dígitos del 0 al 9). \#### Paso 3: Compilar el modelo ```python \# Compilar el modelo model.compile(optimizer='adam', loss='sparse\_categorical\_crossentropy', metrics=\['accuracy']) ``` \- El optimizador \*\*Adam\*\* se utiliza para minimizar la función de pérdida. \- La función de pérdida es \*\*sparse\_categorical\_crossentropy\*\*, que se usa para clasificación de múltiples clases. \#### Paso 4: Entrenar el modelo ```python \# Entrenar el modelo history = model.fit(train\_images, train\_labels, epochs=5, validation\_data=(test\_images, test\_labels)) ``` Este código entrena el modelo CNN con los datos de entrenamiento durante 5 épocas y evalúa su rendimiento en los datos de validación (el conjunto de prueba). \#### Paso 5: Evaluar el modelo ```python \# Evaluar el modelo en el conjunto de prueba test\_loss, test\_acc = model.evaluate(test\_images, test\_labels) print(f'Precisión en el conjunto de prueba: {test\_acc:.4f}') ``` \- Al final, se evalúa la precisión del modelo en el conjunto de datos de prueba. \#### Paso 6: Visualización de las métricas de entrenamiento Podemos visualizar la precisión y la pérdida durante el entrenamiento: ```python \# Graficar la precisión del entrenamiento y la validación plt.plot(history.history\['accuracy'], label='Precisión de entrenamiento') plt.plot(history.history\['val\_accuracy'], label='Precisión de validación') plt.xlabel('Época') plt.ylabel('Precisión') plt.legend() plt.show() \# Graficar la pérdida del entrenamiento y la validación plt.plot(history.history\['loss'], label='Pérdida de entrenamiento') plt.plot(history.history\['val\_loss'], label='Pérdida de validación') plt.xlabel('Época') plt.ylabel('Pérdida') plt.legend() plt.show() ``` \### Explicación General 1\. \*\*Entrenamiento:\*\* El modelo CNN se entrena ajustando los pesos en las capas convolucionales y completamente conectadas para minimizar la pérdida (sparse\_categorical\_crossentropy). La red ajusta los filtros para aprender a detectar características específicas como bordes o formas en las imágenes de entrada. 2\. \*\*Clasificación:\*\* Después del entrenamiento, el modelo predice la clase más probable para una imagen de entrada basándose en las características aprendidas. 3\. \*\*Precisión:\*\* A medida que se entrena el modelo, esperamos que tanto la precisión en el conjunto de entrenamiento como en el conjunto de validación aumenten. \### Conclusión Las CNN son extremadamente eficaces para la clasificación de imágenes debido a su capacidad para aprender características jerárquicas de las imágenes. En este ejemplo, se construyó y entrenó un modelo CNN utilizando el dataset MNIST, mostrando cómo la red puede clasificar dígitos escritos a mano.

La clasificación con redes neuronales convolucionales

Es una aplicación común en el campo de la visión por computadora. Las CNNs son particularmente eficientes para tareas de clasificación de imágenes debido a su capacidad para aprender y extraer características relevantes de las imágenes de entrada de manera jerárquica.