Proyecto Práctico con Redes Neuronales

 

Proyectos Prácticos con Redes Neuronales: Clasificación de Imágenes con Python y Keras

Para ilustrar cómo implementar una red neuronal que clasifique imágenes, utilizaremos Python y Keras, una de las bibliotecas de deep learning más populares y accesibles. Este ejemplo se centrará en el uso de una Red Neuronal Convolucional (CNN), ideal para tareas de visión por computadora como la clasificación de imágenes.

Paso 1: Preparación del Entorno

Antes de comenzar, asegúrate de tener instaladas las librerías necesarias: `tensorflow` (que incluye Keras) y `numpy`. Puedes instalarlas usando pip:

```bash

pip install tensorflow numpy

```

Paso 2: Cargar el Conjunto de Datos

Utilizaremos el conjunto de datos CIFAR-10, que consiste en 60,000 imágenes en color de 32x32 píxeles, divididas en 10 clases (con 6,000 imágenes por clase). Keras facilita la carga de este conjunto de datos directamente:

```python

from keras.datasets import cifar10

# Cargar el conjunto de datos CIFAR-10

(x_train, y_train), (x_test, y_test) = cifar10.load_data()

```

Paso 3: Preprocesamiento de los Datos

Las imágenes deben ser normalizadas y las etiquetas codificadas en one-hot para el entrenamiento:

```python

from keras.utils import to_categorical

# Normalizar los datos de imagen

x_train = x_train.astype('float32') / 255.0

x_test = x_test.astype('float32') / 255.0

# Codificar las etiquetas en formato one-hot

y_train = to_categorical(y_train, 10)

y_test = to_categorical(y_test, 10)

```

Paso 4: Construir el Modelo

Definiremos una CNN simple utilizando la API funcional de Keras:

```python

from keras.models import Sequential

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

model = Sequential([

    Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)),

    MaxPooling2D((2, 2)),

    Conv2D(64, (3, 3), activation='relu'),

    MaxPooling2D((2, 2)),

    Conv2D(64, (3, 3), activation='relu'),

    Flatten(),

    Dense(64, activation='relu'),

    Dense(10, activation='softmax')

])

model.summary()

```

Paso 5: Compilar el Modelo

Ahora, compilamos el modelo, especificando el optimizador, la función de pérdida y las métricas para el seguimiento:

```python

model.compile(optimizer='adam',

              loss='categorical_crossentropy',

              metrics=['accuracy'])

```

Paso 6: Entrenar el Modelo

Entrenaremos el modelo con los datos de entrenamiento, usando una fracción de estos como validación:

```python

history = model.fit(x_train, y_train, epochs=10, validation_split=0.2, batch_size=64)

```

Paso 7: Evaluación del Modelo

Finalmente, evaluamos el modelo con los datos de prueba para ver cómo generaliza:

```python

test_loss, test_acc = model.evaluate(x_test, y_test)

print(f"Test Accuracy: {test_acc*100:.2f}%")

```

Explicación del Código

1. Carga del Conjunto de Datos: Directamente desde Keras, simplificando el proceso de obtención de datos.

2. Preprocesamiento: Normalizamos las imágenes para que sus valores estén en el rango [0, 1] y codificamos las etiquetas en formato one-hot, una práctica estándar para la clasificación.

3. Construcción del Modelo: Se crea una CNN simple que incluye capas convolucionales (`Conv2D`) para la extracción de características, capas de agrupación (`MaxPooling2D`) para reducir la dimensionalidad, y capas densas (`Dense`) para la clasificación.

4. Compilación: Se prepara el modelo para el entrenamiento especificando el optimizador (`adam`), la función de pérdida (`categorical_crossentropy` para clasificación multiclase) y la métrica de evaluación (`accuracy`).

5. Entrenamiento: El modelo se entrena con los datos, ajustándose para minimizar la función de pérdida.

6. Evaluación: Se mide el rendimiento del modelo en un conjunto de datos no visto para evaluar su generalización.

Este ejemplo básico ilustra cómo implementar y entrenar una CNN para clasificar imágenes utilizando Keras, proporcionando una base sólida para explorar arquitecturas más complejas y aplicaciones avanzadas de visión por computadora.