!De la geometría a la IA! Cómo predecir el volumen de un cilindro con Tensorflow 🧠🤖

¡Hola, hola Omesitos! En este post encontrarás el código completo usado en el video: !De la geometría a la IA! Cómo predecir el volumen de un cilindro con Tensorflow 🧠🤖. Este programa te guiará paso a paso para construir un modelo que permite predecir el volumen de un cilindro, comenzando con la preparación del dataset hasta realizar predicciones.

Si quieres la explicación del proceso con más detalle, puedes seguir el videotutorial relacionado aquí.

A continuación, te comparto el programa para que puedas ejecutarlo y experimentar con él. ¡Disfruta aprendiendo y explorando las redes neuronales!

👩‍🔬 ¡A crear el dataset!

import numpy as np
import pandas as pd

# Generar el dataset
np.random.seed(42)
n_samples = 20000

# Valores aleatorios para el radio y la altura
r = np.random.uniform(1, 10, n_samples)
h = np.random.uniform(1, 20, n_samples)

# Calcular el volumen del cilindro
V = np.pi * (r**2) * h

# Crear el dataset de entrada (X) y salida (y)
X = np.vstack([r, h]).T
y = V.reshape(-1, 1)
print(X)
print(y)

🔍¡A explorar el dataset!

import matplotlib.pyplot as plt
plt.style.use("ggplot")

# Crear gráficos
plt.figure(figsize=(10, 4))

# Gráfico del radio
plt.subplot(1, 3, 1)
plt.hist(r, bins=20, color='plum', edgecolor='black')
plt.title('Distribución del Radio', fontsize=10)
plt.xlabel('Radio', fontsize=10)
plt.ylabel('Frecuencia', fontsize=10)

# Gráfico de la altura
plt.subplot(1, 3, 2)
plt.hist(h, bins=20, color='mediumpurple', edgecolor='black')
plt.title('Distribución de la Altura', fontsize=10)
plt.xlabel('Altura', fontsize=10)
plt.ylabel('Frecuencia', fontsize=10)

# Gráfico del volumen
plt.subplot(1, 3, 3)
plt.hist(V, bins=20, color='lightblue', edgecolor='black')
plt.title('Distribución del Volumen', fontsize=10)
plt.xlabel('Volumen', fontsize=10)
plt.ylabel('Frecuencia', fontsize=10)

# Mostrar los gráficos
plt.tight_layout()
plt.show()

df = pd.DataFrame(X, columns=['radio', 'altura'])
df['volumen'] = y
df.head()

df.describe()

⚖️ ¡A preprocesar los datos!

from sklearn.preprocessing import StandardScaler

# Escalar los datos
scaler_X = StandardScaler()
scaler_y = StandardScaler()

X_scaled = scaler_X.fit_transform(X)
y_scaled = scaler_y.fit_transform(y)

✂️ Dividir el dataset en entrenamiento y validación

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X_scaled, y_scaled, test_size=0.2, random_state=42)

# Verificar las dimensiones
print("X_train shape:", X_train.shape, " y_train shape:", y_train.shape)
print("X_test shape:", X_test.shape, " y_test shape:", y_test.shape)

🛠️ ¡A construir la arquitectura del modelo!

from tensorflow.keras import Sequential
from tensorflow.keras.layers import Input, Dense

# Crear modelo con Input
model = Sequential([
    Input(shape=(2,)),                 # Definir explícitamente la forma de entrada
    Dense(16, activation='relu'),      # Capa oculta 1
    Dense(16, activation='relu'),      # Capa oculta 2
    Dense(1)
])
model.summary()

⚙️¡A compilar el modelo!

# Compilar modelo
model.compile(optimizer='adam',
              loss='mse',
              metrics=['mae'])

🏋️‍♂️ ¡A entrenar el modelo!

# Entrenar modelo
history = model.fit(X_train,
                    y_train,
                    epochs=30,
                    batch_size=32,
                    validation_data=(X_test, y_test))

📐 ¡A evaluar el modelo!

history.history.keys()

import matplotlib.pyplot as plt

plt.figure(figsize=(6, 4))
plt.plot(np.arange(0, len(history.history["loss"])), history.history["loss"], label="train_loss")
plt.plot(np.arange(0, len(history.history["loss"])), history.history["val_loss"], label="val_loss")
plt.title("Train and Test Loss")
plt.xlabel("Epoch #")
plt.ylabel("Loss")
plt.legend()
plt.show()

plt.style.use("ggplot")
plt.figure(figsize=(6, 4))
plt.plot(np.arange(0, len(history.history["mae"])), history.history["mae"], label="train_mae")
plt.plot(np.arange(0, len(history.history["val_mae"])), history.history["val_mae"], label="val_mae")
plt.title("Train and Test Mae")
plt.xlabel("Epoch #")
plt.ylabel("Mae")
plt.legend()
plt.show()

model.evaluate(X_train, y_train)

model.evaluate(X_test, y_test)

🤖 ¡A hacer predicciones con el modelo!

# Hacer predicciones con el modelo
X_new = np.array([[5.43, 10.32],
                  [7.5, 15.09],
                  [3, 4.4]])

X_new_scaled = scaler_X.transform(X_new)

# Predecir volúmenes escalados
y_pred_scaled = model.predict(X_new_scaled)
#print(y_pred_scaled)

# Revertir el escalado de las predicciones
y_pred = scaler_y.inverse_transform(y_pred_scaled)
print(y_pred)

# Calcular el volumen real a comparar
y_true = np.pi * X_new[:, 0]**2 * X_new[:, 1]

# Mostrar las predicciones y los valores reales
print("PREDICCIONES VS VALORES REALES")
for i, (pred, real) in enumerate(zip(y_pred, y_true)):
    print(f"Entrada {i +1}: Radio={X_new[i, 0]}, Altura={X_new[i, 1]}")
    print(f"Predicción {i+1}: {pred[0]:.2f} - Valor Real: {real:.2f}")
    print()