¿Cómo construir tu primera red neuronal con Python?

¿Realmente necesitas miles de líneas de código?

Puedes construir una red neuronal funcional en Python con menos de 20 líneas de código.

Eso suena imposible, ¿verdad? La mayoría de las personas imagina que programar inteligencia artificial requiere meses de trabajo y equipos enteros de ingenieros. La realidad es diferente. Gracias a TensorFlow y Keras, una red neuronal que hace predicciones reales cabe en media pantalla.

En esta lección vas a construir tu primera red neuronal desde cero. Verás código real, resultados concretos y aprenderás a leer los mensajes de error más comunes.

El problema que vas a resolver

Imagina que trabajas en el área de recursos humanos de Bimbo. Tu jefe quiere predecir si un empleado nuevo permanecerá más de un año en la empresa, basándose en dos datos: su edad y su salario mensual.

Este es un problema de clasificación binaria: el resultado es 1 (se queda) o 0 (se va). Es exactamente el tipo de problema donde una red neuronal brilla. Y es perfecto para aprender porque los datos son fáciles de entender.

Instala las herramientas necesarias

Antes de escribir código, necesitas instalar TensorFlow. Abre tu terminal y ejecuta:

pip install tensorflow

Eso instala automáticamente Keras, que es la interfaz de alto nivel que usaremos. Keras es como el volante de un auto: te permite controlar el motor (TensorFlow) sin conocer cada engranaje interno.

Los datos: tu materia prima

En el mundo real, los datos vienen de bases de datos del SAT, del IMSS o de sistemas internos. Para aprender, vamos a crear datos sintéticos que simulan empleados de Bimbo.

import numpy as np

# Datos de entrenamiento: [edad, salario]
X = np.array([
    [22, 12000],
    [35, 18500],
    [28, 15000],
    [45, 25000],
    [24, 10500],
    [38, 22000],
    [30, 17000],
    [50, 28000],
])

# Etiquetas: 1 = se queda, 0 = se va
y = np.array([0, 1, 1, 1, 0, 1, 1, 1])

Cada fila de X representa un empleado. La primera columna es la edad. La segunda es el salario mensual en pesos. El arreglo y dice si ese empleado se quedó o se fue.

Normaliza los datos: el paso que todos olvidan

Aquí viene una sorpresa: si alimentas esos datos directamente a la red, el entrenamiento fallará o será muy lento. ¿Por qué?

Because la edad está entre 22 y 50, pero el salario está entre $10,500 y $28,000. Esa diferencia de escala confunde al algoritmo. Es como pedirle a alguien que compare kilómetros con milímetros en la misma ecuación.

La solución es normalizar: convertir todos los valores a una escala común entre 0 y 1.

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler()
X_norm = scaler.fit_transform(X)

print(X_norm)

Después de normalizar, la edad 22 se convierte en 0.0 y la edad 50 en 1.0. El salario $10,500 se convierte en 0.0 y $28,000 en 1.0. Ahora ambas variables juegan en igualdad de condiciones.

Construye la red neuronal

Aquí está el momento central de la lección. Vamos a construir la red usando Keras.

import tensorflow as tf
from tensorflow import keras

# Construir el modelo
modelo = keras.Sequential([
    keras.layers.Dense(8, activation='relu', input_shape=(2,)),
    keras.layers.Dense(4, activation='relu'),
    keras.layers.Dense(1, activation='sigmoid')
])

Analiza cada línea:

• keras.Sequential: Define que las capas van una tras otra, en secuencia.
• Primera capa Dense(8, activation='relu'): Tiene 8 neuronas y usa ReLU. Recibe 2 entradas (edad y salario normalizados).
• Segunda capa Dense(4, activation='relu'): Tiene 4 neuronas. Procesa lo que encontró la primera capa.
• Capa de salida Dense(1, activation='sigmoid'): Una sola neurona con Sigmoid. Produce un número entre 0 y 1, que interpretamos como probabilidad.

Estas elecciones no son arbitrarias. Como viste en la lección anterior, ReLU va en capas ocultas y Sigmoid va en la salida de problemas binarios. Aquí ves esa regla en acción.

Compila y entrena

Construir la red es como armar un motor. Compilar es ponerle gasolina y configurar el acelerador. Entrenar es finalmente arrancar.

modelo.compile(
    optimizer='adam',
    loss='binary_crossentropy',
    metrics=['accuracy']
)

historial = modelo.fit(
    X_norm, y,
    epochs=100,
    verbose=0
)

print(f"Precisión final: {historial.history['accuracy'][-1]:.2f}")

Salida esperada:

Precisión final: 0.88

Eso significa que la red clasifica correctamente el 88% de los ejemplos. Para un dataset pequeño de 8 personas, es un resultado sólido.

¿Qué son estos parámetros?

• optimizer='adam': El algoritmo que ajusta los pesos durante el entrenamiento. Adam es el más popular hoy. Lo usan más del 70% de los proyectos publicados en Kaggle.
• loss='binary_crossentropy': La función que mide qué tan equivocada está la red. Para clasificación binaria, esta es la opción estándar.
• epochs=100: La red va a ver los datos completos 100 veces. Cada vuelta aprende un poco más.

Haz tu primera predicción

Ahora viene lo más emocionante: pedirle a la red que prediga un empleado nuevo.

# Nuevo empleado: 32 años, salario $19,500
nuevo = np.array([[32, 19500]])
nuevo_norm = scaler.transform(nuevo)

prediccion = modelo.predict(nuevo_norm)
print(f"Probabilidad de quedarse: {prediccion[0][0]:.2f}")

if prediccion[0][0] >= 0.5:
    print("Predicción: el empleado SE QUEDA")
else:
    print("Predicción: el empleado SE VA")

Salida esperada:

Probabilidad de quedarse: 0.79
Predicción: el empleado SE QUEDA

La red dice que hay un 79% de probabilidad de que este empleado permanezca en Bimbo. El umbral de 0.5 es el estándar: arriba de ese número, predecimos que se queda.

El Marco de las Cuatro Fases

Todo proyecto con redes neuronales sigue el mismo camino. Llámalo el Marco de las Cuatro Fases:

1. Preparar: Limpiar y normalizar los datos.
2. Construir: Definir la arquitectura con Sequential y capas Dense.
3. Compilar: Elegir el optimizador, la función de pérdida y las métricas.
4. Entrenar y predecir: Ejecutar fit() y luego predict().

Este marco aplica si estás prediciendo rotación de personal en Bimbo, detección de fraude en FEMSA o clasificación de productos en Liverpool. La estructura no cambia. Solo cambian los datos y algunos parámetros.

Errores comunes y cómo resolverlos

Aquí están los tres errores que cometen casi todos los principiantes:

Error 1: Olvidar normalizar los datos. Los síntomas son que la precisión se queda atascada en 0.50 o que la función de pérdida sube en vez de bajar. Solución: siempre aplica MinMaxScaler o StandardScaler antes de entrenar.

Error 2: Usar Sigmoid en capas ocultas. Recuerda la lección anterior: Sigmoid en capas intermedias mata el gradiente. Si tu red no aprende después de 200 épocas, revisa que todas las capas ocultas usen ReLU.

Error 3: No transformar el dato nuevo con el mismo scaler. Si normalizas los datos de entrenamiento con scaler.fit_transform(X), pero luego haces scaler.fit_transform(nuevo) para el dato nuevo, estás usando escalas diferentes. El resultado será basura. Siempre usa scaler.transform() (sin fit) para datos nuevos.

Error 4: Evaluar con los mismos datos de entrenamiento. En este ejemplo usamos datos pequeños para aprender. En proyectos reales, siempre separa un conjunto de prueba que la red nunca haya visto. De lo contrario, mides memorización, no aprendizaje.

Lo que acabas de construir

En menos de 40 líneas de código creaste un sistema que puede aprender patrones en datos y hacer predicciones sobre empleados nuevos. Eso es exactamente lo que hacen los equipos de análisis de datos en empresas como Mercado Libre o FEMSA, solo que con millones de filas en vez de ocho.

La diferencia entre tu código de hoy y el de producción no es el concepto. Es la escala, la cantidad de datos y las pruebas de validación. Los fundamentos que acabas de aplicar son los mismos.