Clasificación con redes neuronales convolucionales
Clase 13 de 25 • Curso de Redes Neuronales Convolucionales con Python y Keras
Contenido del curso
FELIX DAVID CORDOVA GARCIA
student•
hace 4 años
FELIX DAVID CORDOVA GARCIA
Diaz Mauricio
Alarcon7a
Adriano Corral Marco
Diaz Mauricio
Ángel Samuel Suesca Ríos
Helberth Alberto Calderón Duran
Carlos Isael Ramírez González
Eduardo Rosentreter
Diego Sepúlveda
Nicolas Cordoba
Cristian Tinipuclla
Iván Roberto Rivas Celeita
Mario Alexander Vargas Celis
Mario Alexander Vargas Celis
Jhon Freddy Tavera Blandon
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]
asi es, gracias por tu aporte
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.
Gracias por el dato
Recuerden que cuando tengan que importar varias cosas pueden usar esta sintaxis
from tensorflow.keras.layers import (Conv2D,MaxPooling2D, Flatten, Dense, Dropout, Activation)
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>
Lo mismo pense, el nombre que le pongo a esa variable es partial_X_train
Tengo una pregunta, ¿Cuál es la aplicación Real de reducir la escala de [0,255] a una escala de [0,1]? ¿Acaso ayuda a prevenir errores? ¿Agilizar el entrenamiento? Como tal, que ventaja tiene.
Es esa la pregunta.
No se si respondo bien la pregunta, pero recuerda el curso pasado donde habían datos de las casas de boston donde tenias por cada dato un arreglo de varios parámetros, por ejemplo un parámetro era 0.5 y otro era 300. Entonces si le entregas a la maquina eso tal cual pensará que el 300 tendrá mas valor que un 0,5 y no es así. Y en ese caso normalizamos con la media y desviacion estandar, tuvimos que hacer eso por que los valores no los conociamos, unos estaban en 0 y 1 otros 300 y otro 5000 creo.. pero acá sabemos que el max es 255. Por eso me parece que hacemos eso, y creo que no es ventaja de hacer algo asi, si no hacemos algo asi va a salir cualquier cosa creo yo. No es una ventaja como poner mas capas, o hacer dropout o cualquiera de la optimizaciones, es basicamente para que la cuestion derechamente funcione jaja
Según el recurso en el que se habla del dataset cifar10, los datos de train son 50k y al quitar los ultimos 5k en la parte de validación deberían quedar 45k. Lo difo porque en el vídeo de la clase de ven 40k
Claro! 😅, esto es porque el profe está utilizando x_train tanto para x_valid (le asigna 5000 datos) como para y_valid (le asigna otros 5000 datos). Esto está mal ya que a y_valid se le debería asignar los datos de y_train, por lo cual nuestros otros compañeros han aportado con la correción ☝️🤭.
##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
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
\# 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
\# 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
\# 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
\# 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:
\# 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.