Red neuronal para Iris

Aquí tienes un ejemplo de cómo construir y entrenar una red neuronal con Keras para clasificar el dataset Iris. Este dataset contiene 150 muestras de flores de iris con 4 características (longitud y ancho de sépalo y pétalo) y 3 clases (tipos de iris: Setosa, Versicolor y Virginica).

1. Cargar librerías y el dataset Iris

import numpy as np
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelBinarizer

2. Cargar y preparar los datos

# Cargar dataset Iris
data = load_iris()
X = data.data  # Características (longitud y ancho de sépalo y pétalo)
y = data.target  # Clases (Setosa, Versicolor, Virginica)

# Convertir etiquetas a formato One-Hot Encoding
y = LabelBinarizer().fit_transform(y)

# Dividir los datos en conjuntos de entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

3. Crear el modelo de la red neuronal

Usaremos una red con dos capas ocultas de 10 y 8 neuronas respectivamente, y una capa de salida de 3 neuronas con activación softmax para la clasificación en tres categorías.

# Crear el modelo secuencial
model = Sequential()
model.add(Dense(10, input_shape=(4,), activation='relu'))  # Primera capa oculta
model.add(Dense(8, activation='relu'))                     # Segunda capa oculta
model.add(Dense(3, activation='softmax'))                  # Capa de salida

4. Compilar el modelo

Aquí se utiliza la función de pérdida categorical_crossentropy para clasificación multiclase y el optimizador adam para una optimización eficiente.

# Compilar el modelo
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

5. Entrenar el modelo

Ajustamos el modelo con 50 épocas y un tamaño de batch de 5. Puedes ajustar estos parámetros según tus necesidades.

# Entrenar el modelo
history = model.fit(X_train, y_train, epochs=50, batch_size=5, validation_data=(X_test, y_test))

6. Evaluar el modelo

Evaluamos el modelo para verificar su precisión en el conjunto de prueba.

# Evaluar el modelo
loss, accuracy = model.evaluate(X_test, y_test)
print(f'Pérdida en el conjunto de prueba: {loss:.4f}')
print(f'Precisión en el conjunto de prueba: {accuracy:.4f}')

7. Realizar predicciones

Para realizar predicciones en datos nuevos o en el conjunto de prueba:

# Predecir etiquetas para el conjunto de prueba
predictions = model.predict(X_test)
predicted_classes = np.argmax(predictions, axis=1)
true_classes = np.argmax(y_test, axis=1)

# Mostrar las predicciones y las etiquetas reales
print("Predicciones:", predicted_classes)
print("Etiquetas reales:", true_classes)

Explicación de las capas y parámetros

• Capa densa (Dense): Cada capa completamente conectada tiene un número de neuronas y una función de activación. En este caso usamos relu para las capas ocultas y softmax en la capa de salida para obtener una probabilidad para cada clase.
• Optimizer adam: Un optimizador que combina el descenso de gradiente adaptativo para obtener un rendimiento rápido y estable.
• Loss categorical_crossentropy: Una función de pérdida para tareas de clasificación multiclase.

Este código entrenará la red para clasificar las muestras de Iris en una de las tres clases con buenos resultados en términos de precisión.

Código completo

import numpy as np
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelBinarizer
import matplotlib.pyplot as plt
import seaborn as sns
# Cargar dataset Iris
data = load_iris()
X = data.data  # Características (longitud y ancho de sépalo y pétalo)
y = data.target  # Clases (Setosa, Versicolor, Virginica)

# Convertir etiquetas a formato One-Hot Encoding
y = LabelBinarizer().fit_transform(y)

# Dividir los datos en conjuntos de entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Crear el modelo secuencial
model = Sequential()
model.add(Dense(10, input_shape=(4,), activation='relu'))  # Primera capa oculta
model.add(Dense(8, activation='relu'))                     # Segunda capa oculta
model.add(Dense(3, activation='softmax'))                  # Capa de salida
# Compilar el modelo
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
# Entrenar el modelo
history = model.fit(X_train, y_train, epochs=50, batch_size=5, validation_data=(X_test, y_test))
# Evaluar el modelo
loss, accuracy = model.evaluate(X_test, y_test)
print(f'Pérdida en el conjunto de prueba: {loss:.4f}')
print(f'Precisión en el conjunto de prueba: {accuracy:.4f}')
# Predecir etiquetas para el conjunto de prueba
predictions = model.predict(X_test)
predicted_classes = np.argmax(predictions, axis=1)
true_classes = np.argmax(y_test, axis=1)

# Mostrar las predicciones y las etiquetas reales
print("Predicciones:", predicted_classes)
print("Etiquetas reales:", true_classes)
diferencias = np.where(predicted_classes != true_classes)[0]

print("Posiciones con diferencias:", diferencias)

# Crear un DataFrame con los resultados para graficar
import pandas as pd
result_df = pd.DataFrame({
    'Sepal Length': X_test[:, 0],
    'Sepal Width': X_test[:, 1],
    'True Label': true_classes,
    'Predicted Label': predicted_classes
})

# Configuración de colores para las clases
colors = ['red', 'blue', 'green']
labels = data.target_names

# Gráfica de dispersión de las etiquetas verdaderas
plt.figure(figsize=(12, 6))

plt.subplot(1, 2, 1)
sns.scatterplot(
    x='Sepal Length', y='Sepal Width',
    hue='True Label', style='True Label',
    palette=colors, data=result_df, legend='full'
)
plt.title("Etiquetas Verdaderas")
plt.xlabel("Sepal Length")
plt.ylabel("Sepal Width")
plt.legend(labels, title="Clase")

# Gráfica de dispersión de las predicciones
plt.subplot(1, 2, 2)
sns.scatterplot(
    x='Sepal Length', y='Sepal Width',
    hue='Predicted Label', style='Predicted Label',
    palette=colors, data=result_df, legend='full'
)
plt.title("Etiquetas Predichas")
plt.xlabel("Sepal Length")
plt.ylabel("Sepal Width")
plt.legend(labels, title="Clase")

plt.tight_layout()
plt.show()