Ejemplos de redes con keras

Clasificación binaria:

import numpy as np
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.losses import BinaryCrossentropy
from tensorflow.keras.metrics import BinaryAccuracy

# Generar datos de ejemplo
X, y = make_classification(n_samples=1000, n_features=20, n_classes=2, random_state=42)

# Dividir en 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
model = Sequential([
    Dense(64, activation='relu', input_shape=(X_train.shape[1],)),
    Dense(32, activation='relu'),
    Dense(1, activation='sigmoid')  # Salida para clasificación binaria
])

# Compilar el modelo
model.compile(optimizer=Adam(),
              loss=BinaryCrossentropy(),
              metrics=[BinaryAccuracy()])

# Entrenar el modelo
history = model.fit(X_train, y_train, epochs=20, batch_size=32, validation_split=0.2, verbose=1)

# Evaluar el modelo en el conjunto de prueba
loss, accuracy = model.evaluate(X_test, y_test, verbose=0)
print(f"Precisión del modelo en el conjunto de prueba: {accuracy:.2f}")

# También podemos ver el historial de entrenamiento (opcional)
import matplotlib.pyplot as plt

plt.plot(history.history['binary_accuracy'], label='Precisión en entrenamiento')
plt.plot(history.history['val_binary_accuracy'], label='Precisión en validación')
plt.xlabel('Época')
plt.ylabel('Precisión')
plt.legend()
plt.show()

Multiclase:

import numpy as np
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.losses import SparseCategoricalCrossentropy
from tensorflow.keras.metrics import SparseCategoricalAccuracy

# Generar datos de ejemplo
X, y = make_classification(n_samples=1000, n_features=20, n_classes=3, n_informative=15, random_state=42)

# Dividir en 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
model = Sequential([
    Dense(64, activation='relu', input_shape=(X_train.shape[1],)),
    Dense(32, activation='relu'),
    Dense(3, activation='softmax')  # 3 neuronas de salida para 3 clases
])

# Compilar el modelo
model.compile(optimizer=Adam(),
              loss=SparseCategoricalCrossentropy(),
              metrics=[SparseCategoricalAccuracy()])

# Entrenar el modelo
history = model.fit(X_train, y_train, epochs=20, batch_size=32, validation_split=0.2, verbose=1)

# Evaluar el modelo en el conjunto de prueba
loss, accuracy = model.evaluate(X_test, y_test, verbose=0)
print(f"Precisión del modelo en el conjunto de prueba: {accuracy:.2f}")

# Graficar el historial de precisión (opcional)
import matplotlib.pyplot as plt

plt.plot(history.history['sparse_categorical_accuracy'], label='Precisión en entrenamiento')
plt.plot(history.history['val_sparse_categorical_accuracy'], label='Precisión en validación')
plt.xlabel('Época')
plt.ylabel('Precisión')
plt.legend()
plt.show()

Regresión lineal:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.optimizers import Adam

# Generar datos de ejemplo
np.random.seed(42)
X = np.random.rand(1000, 1) * 10  # 1000 muestras, 1 característica (X)
y = 2.5 * X + np.random.randn(1000, 1)  # Relación lineal con ruido

# Dividir en 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
model = Sequential([
    Dense(1, input_shape=(X_train.shape[1],))  # 1 neurona para la salida
])

# Compilar el modelo
model.compile(optimizer=Adam(learning_rate=0.01), loss='mean_squared_error')

# Entrenar el modelo
history = model.fit(X_train, y_train, epochs=100, batch_size=32, verbose=1)

# Evaluar el modelo en el conjunto de prueba
loss = model.evaluate(X_test, y_test, verbose=0)
print(f"Pérdida del modelo en el conjunto de prueba: {loss:.2f}")

# Hacer predicciones
y_pred = model.predict(X_test)

# Graficar resultados
plt.scatter(X_test, y_test, label='Datos reales', alpha=0.5)
plt.scatter(X_test, y_pred, color='red', label='Predicciones', alpha=0.5)
plt.xlabel('X')
plt.ylabel('y')
plt.title('Regresión Lineal con Keras')
plt.legend()
plt.show()

Polinómicas:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.optimizers import Adam
from sklearn.preprocessing import PolynomialFeatures

# Generar datos de ejemplo
np.random.seed(42)
X = np.random.rand(1000, 1) * 10  # 1000 muestras, 1 característica (X)
y = 0.5 * X**3 - 2 * X**2 + 3 * X + np.random.randn(1000, 1) * 5  # Relación polinómica con ruido

# Transformar características a polinomios
poly = PolynomialFeatures(degree=3)  # Cambia el grado según lo que necesites
X_poly = poly.fit_transform(X)

# Dividir en entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X_poly, y, test_size=0.2, random_state=42)

# Crear el modelo
model = Sequential([
    Dense(64, activation='relu', input_shape=(X_train.shape[1],)),
    Dense(64, activation='relu'),
    Dense(1)  # Capa de salida para regresión
])

# Compilar el modelo
model.compile(optimizer=Adam(learning_rate=0.01), loss='mean_squared_error')

# Entrenar el modelo
history = model.fit(X_train, y_train, epochs=100, batch_size=32, verbose=1)

# Evaluar el modelo en el conjunto de prueba
loss = model.evaluate(X_test, y_test, verbose=0)
print(f"Pérdida del modelo en el conjunto de prueba: {loss:.2f}")

# Hacer predicciones
y_pred = model.predict(X_test)

# Graficar resultados
plt.scatter(X_test[:, 1], y_test, label='Datos reales', alpha=0.5)  # Usar la característica polinómica de interés
plt.scatter(X_test[:, 1], y_pred, color='red', label='Predicciones', alpha=0.5)
plt.xlabel('X')
plt.ylabel('y')
plt.title('Regresión Polinómica con Keras')
plt.legend()
plt.show()

El dataset Iris:

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import OneHotEncoder
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.utils import to_categorical

# 1. Cargar el conjunto de datos Iris
iris = load_iris()
X = iris.data  # Características
y = iris.target  # Etiquetas

# 2. Preprocesar los datos
# Convertir las etiquetas a formato one-hot
y = to_categorical(y)

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

# 4. Construir y compilar el modelo
model = Sequential()
model.add(Dense(10, input_dim=4, activation='relu'))  # Capa oculta
model.add(Dense(3, activation='softmax'))  # Capa de salida para clasificación multi-clase

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

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

# 6. Evaluar el modelo
loss, accuracy = model.evaluate(X_test, y_test, verbose=0)
print(f"Pérdida del modelo: {loss:.2f}, Precisión: {accuracy:.2f}")

# 7. Visualizar los resultados
# Graficar la precisión y la pérdida durante el entrenamiento
plt.figure(figsize=(12, 4))

# Gráfico de la precisión
plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='Precisión en entrenamiento')
plt.plot(history.history['val_accuracy'], label='Precisión en validación')
plt.title('Precisión del modelo')
plt.xlabel('Épocas')
plt.ylabel('Precisión')
plt.legend()

# Gráfico de la pérdida
plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='Pérdida en entrenamiento')
plt.plot(history.history['val_loss'], label='Pérdida en validación')
plt.title('Pérdida del modelo')
plt.xlabel('Épocas')
plt.ylabel('Pérdida')
plt.legend()

plt.tight_layout()
plt.show()