Construye Redes Neuronales en Python & Scratch: ¡Una Introducción Divertida!

Desatando la IA: Creando Redes Neuronales en Python y Scratch

Hola, soy Alex Petrov, un ingeniero de ML. Hoy vamos a desmitificar las redes neuronales. Podrías pensar que son complejas, reservadas para programadores avanzados. Pero te mostraré cómo comenzar a crear redes neuronales en Python y, sorprendentemente, incluso visualizar conceptos básicos usando Scratch. Este artículo proporciona pasos prácticos y accionables para que los principiantes entiendan y construyan sus primeros modelos de IA.

Nuestra travesía cubrirá la teoría fundamental, una implementación práctica en Python y, luego, una forma creativa de entender la mecánica a través de Scratch. El objetivo es hacer que “crear redes neuronales en Python en Scratch” sea accesible y comprensible para todos.

¿Qué es una Red Neuronal? La Idea Central

Imagina tu cerebro. Tiene miles de millones de neuronas, interconectadas, procesando información. Una red neuronal es un modelo simplificado de este proceso biológico. Es una serie de algoritmos que intenta identificar relaciones subyacentes en un conjunto de datos a través de un proceso que imita la forma en que opera el cerebro humano.

En su esencia, una red neuronal toma datos de entrada, los pasa a través de capas de “neuronas” (o nodos) interconectadas, y produce una salida. Cada conexión tiene un “peso”, y cada neurona tiene un “sesgo”. Estos pesos y sesgos se ajustan durante el entrenamiento para hacer que las predicciones de la red sean más precisas.

Entradas, Capas Ocultas y Salidas

Piénsalo así:

• Capa de Entrada: Aquí es donde tus datos entran. Por ejemplo, si estás prediciendo precios de casas, las entradas podrían ser el metraje cuadrado, el número de habitaciones y la ubicación.
• Capas Ocultas: Estas son las partes “pensantes”. Realizan cálculos sobre los datos de entrada, transformándolos. Una red puede tener una o muchas capas ocultas. Los problemas más complejos a menudo requieren más capas ocultas.
• Capa de Salida: Este es el resultado final. Para los precios de casas, la salida sería el precio predicho. Para clasificar imágenes, podría ser la etiqueta “gato” o “perro”.

Pesos y Sesgos: Los Parámetros Aprendibles de la Red

Cada conexión entre neuronas tiene un peso. Este peso determina la fuerza e importancia de esa conexión. Un peso más alto significa que la entrada tiene una influencia más fuerte en la activación de la siguiente neurona. Un sesgo es un parámetro adicional en cada neurona que ayuda a desplazar la función de activación. Juntos, pesos y sesgos son lo que la red neuronal “aprende” durante el entrenamiento.

Funciones de Activación: Introduciendo No Linealidad

Después de que una neurona recibe entradas, las multiplica por sus pesos y añade un sesgo, pasa el resultado por una función de activación. Esta función introduce no linealidad en la red. Sin funciones de activación, una red neuronal sería simplemente un modelo lineal, incapaz de aprender patrones complejos. Las funciones de activación comunes incluyen ReLU (Unidad Lineal Rectificada), Sigmoide y Tanh.

Construyendo una Red Neuronal Simple en Python

Ahora, pongámonos prácticos. Usaremos Python para construir una red neuronal básica. Para esto, utilizaremos NumPy para operaciones numéricas, que es una biblioteca fundamental para la computación científica en Python. Este será nuestro primer paso para crear redes neuronales en Python.

Configurando tu Entorno

Primero, asegúrate de tener Python instalado. Luego, instala NumPy:

pip install numpy

El Problema: Puerta XOR

Entrenaremos nuestra red para resolver el problema de la XOR (o exclusivo). La puerta XOR es un ejemplo clásico en redes neuronales porque no es linealmente separable. Esto significa que una sola línea recta no puede separar las salidas verdaderas de las falsas. Requiere una capa oculta.

Tabla de verdad de XOR:

• Entrada (0, 0) -> Salida (0)
• Entrada (0, 1) -> Salida (1)
• Entrada (1, 0) -> Salida (1)
• Entrada (1, 1) -> Salida (0)

Implementación en Python: Una Red Neuronal de Dos Capas

A continuación, te muestro el código en Python para una red neuronal simple de feedforward con una capa oculta. Usaremos la función de activación sigmoide e implementaremos el algoritmo de retropropagación para el entrenamiento.

import numpy as np

# Función de activación sigmoide y su derivada
def sigmoid(x):
 return 1 / (1 + np.exp(-x))

def sigmoid_derivative(x):
 return x * (1 - x)

# Conjunto de datos de entrada
X = np.array([[0,0],
 [0,1],
 [1,0],
 [1,1]])

# Conjunto de datos de salida
y = np.array([[0],
 [1],
 [1],
 [0]])

# Semilla para reproducibilidad
np.random.seed(1)

# Inicializar pesos y sesgos
# Pesos para la capa de entrada a la capa oculta (2 entradas, 4 neuronas ocultas)
weights_input_hidden = np.random.uniform(size=(2,4))
# Pesos para la capa oculta a la capa de salida (4 neuronas ocultas, 1 salida)
weights_hidden_output = np.random.uniform(size=(4,1))

# Sesgos (opcional, pero buena práctica para redes más complejas)
# Para simplificar, omitiremos sesgos explícitos en este ejemplo básico,
# dejando que los pesos manejen el desplazamiento por ahora.
# Para redes más avanzadas, los sesgos son cruciales.

learning_rate = 0.1
epochs = 10000

print("Pesos iniciales (entrada a oculta):\n", weights_input_hidden)
print("Pesos iniciales (oculta a salida):\n", weights_hidden_output)

for epoch in range(epochs):
 # Propagación hacia adelante
 # Calcular salida de la capa oculta
 hidden_layer_input = np.dot(X, weights_input_hidden)
 hidden_layer_output = sigmoid(hidden_layer_input)

 # Calcular salida de la capa de salida
 output_layer_input = np.dot(hidden_layer_output, weights_hidden_output)
 predicted_output = sigmoid(output_layer_input)

 # Retropropagación
 # Calcular error
 error = y - predicted_output

 # Calcular delta para la capa de salida
 d_predicted_output = error * sigmoid_derivative(predicted_output)

 # Calcular error para la capa oculta
 error_hidden_layer = d_predicted_output.dot(weights_hidden_output.T)
 d_hidden_layer = error_hidden_layer * sigmoid_derivative(hidden_layer_output)

 # Actualizar pesos
 weights_hidden_output += hidden_layer_output.T.dot(d_predicted_output) * learning_rate
 weights_input_hidden += X.T.dot(d_hidden_layer) * learning_rate

 if epoch % 1000 == 0:
 loss = np.mean(np.abs(error))
 print(f"Época {epoch}, Pérdida: {loss:.4f}")

print("\nEntrenamiento completo.")
print("Pesos finales (entrada a oculta):\n", weights_input_hidden)
print("Pesos finales (oculta a salida):\n", weights_hidden_output)
print("\nSalida predicha después del entrenamiento:\n", predicted_output.round())

Entendiendo el Código en Python

Desglosemos el código en Python para crear una red neuronal en Python:

1. Funciones `sigmoid` y `sigmoid_derivative`: Estas implementan la función de activación sigmoide y su derivada, esenciales para la retropropagación.
2. Conjuntos de datos `X` y `y`: Estos representan nuestras entradas y salidas para el problema XOR.
3. Inicialización de Pesos: `weights_input_hidden` y `weights_hidden_output` se inicializan con valores aleatorios. Esta aleatoriedad es crucial para evitar que todas las neuronas aprendan lo mismo.
4. `learning_rate`: Esto controla cuánto se ajustan los pesos durante cada paso de entrenamiento. Un learning rate más pequeño significa un aprendizaje más lento pero potencialmente más estable.
5. `epochs`: El número de veces que la red pasará por todo el conjunto de datos de entrenamiento.
6. Propagación Hacia Adelante:
   • Las entradas se multiplican por `weights_input_hidden` para obtener `hidden_layer_input`.
   • `hidden_layer_input` se pasa a través de la función `sigmoid` para obtener `hidden_layer_output`.
   • `hidden_layer_output` se multiplica por `weights_hidden_output` para obtener `output_layer_input`.
   • `output_layer_input` se pasa a través de `sigmoid` para obtener `predicted_output`.
7. Retropropagación: Esta es la parte “aprendizaje”.
   • Cálculo de Error: Encontramos la diferencia entre `y` (salida real) y `predicted_output`.
   • Delta de la Capa de Salida: Este es el error multiplicado por la derivada de la sigmoide de la salida predicha. Nos dice cuánto ajustar los pesos de la capa de salida.
   • Error de la Capa Oculta: Propagamos el error de regreso desde la capa de salida a la capa oculta.
   • Delta de la Capa Oculta: Similar a la capa de salida, esto nos indica cuánto ajustar los pesos de la capa oculta.
   • Actualizaciones de Pesos: Finalmente, se ajustan los pesos en función de sus respectivos deltas y el `learning_rate`. Este es el núcleo de cómo aprende la red.

Después de ejecutar este código, verás que la pérdida de la red disminuye durante las épocas, y el `predicted_output` debería coincidir estrechamente con los valores de `y` (tabla de verdad XOR), lo que demuestra un aprendizaje exitoso. Este es un ejemplo fundamental para crear redes neuronales en Python.

Visualizando Conceptos de Redes Neuronales con Scratch

Entender las matemáticas abstractas puede ser difícil. ¡Ahí es donde entra Scratch! Aunque no puedes construir una red neuronal compleja directamente en Scratch, puedes crear simulaciones interactivas que demuestren conceptos centrales como neuronas, pesos y activación. Esto ayuda a consolidar la comprensión de “crear redes neuronales en Python en Scratch” proporcionando una analogía visual.

¿Por Qué Scratch para Redes Neuronales?

• Retroalimentación Visual: Ve cómo las entradas afectan las salidas en tiempo real.
• Aprendizaje Interactivo: Manipula “pesos” y “sesgos” directamente.
• Simplifica la Complejidad: Enfócate en un concepto a la vez.
• Interesante: Hace que aprender sea divertido y accesible.

Creando un Único “Neurona” en Scratch

Simulemos una sola neurona que toma dos entradas, las multiplica por pesos, las suma y aplica un umbral simple (como una función de activación escalonada). Esta es una excelente manera de visualizar un perceptrón, la forma más simple de una red neuronal.

Idea de Proyecto en Scratch: Una Neurona “Tomadora de Decisiones”

Imagina una neurona que decide si debes “Salir al Exterior” basado en dos entradas: “¿Está Soleado?” (1 para Sí, 0 para No) y “¿Está Caliente?” (1 para Sí, 0 para No).

Pasos en Scratch:

1. Crear Variables:
   • `Input_Sunny` (control deslizante, rango 0-1)
   • `Input_Warm` (control deslizante, rango 0-1)
   • `Weight_Sunny` (control deslizante, rango -2 a 2)
   • `Weight_Warm` (control deslizante, rango -2 a 2)
   • `Bias` (control deslizante, rango -2 a 2)
   • `Weighted_Sum`
   • `Output_Decision` (será 0 o 1)
2. Crear Sprites:
   • Un sprite de “Neurona” (un círculo)
   • Un sprite de “Salida” (por ejemplo, una cara feliz para “Salir al Exterior”, una cara triste para “Quedarse dentro”)
3. Script del Sprite de Neurona:

   
    cuando se hace clic en la bandera verde
    por siempre
    establecer Weighted_Sum en (Input_Sunny * Weight_Sunny) + (Input_Warm * Weight_Warm) + Bias
    si Weighted_Sum > 0 entonces
    establecer Output_Decision en 1 // Salir al Exterior
    else
    establecer Output_Decision en 0 // Quedarse Dentro
    fin
    fin
    

4. Script del Sprite de Salida:

   
    cuando se hace clic en la bandera verde
    por siempre
    si Output_Decision = 1 entonces
    cambiar disfraz a [Cara Feliz]
    decir "¡Vamos a salir!" durante 2 segundos
    else
    cambiar disfraz a [Cara Triste]
    decir "Quedándome dentro hoy." durante 2 segundos
    fin
    fin
    

Experimentando en Scratch

Una vez que hayas construido esto en Scratch, juega con los controles deslizantes:

• Cambia `Weight_Sunny` y `Weight_Warm`: ¿Cómo hace que aumentar un peso haga que esa entrada sea más importante para la decisión de “Salir al Exterior”?
• Ajusta `Bias`: ¿Cómo afecta el sesgo al umbral? ¿Puedes hacer que la neurona siempre decida salir, incluso si no está soleado o caliente? ¿O siempre quedarse dentro?
• Observa `Weighted_Sum`: Ve cómo cambia con diferentes entradas y pesos.

Este simple proyecto de Scratch ilustra vívidamente la mecánica básica: entradas, pesos, suma y una función de activación (umbral). Es una excelente ayuda visual para entender la conexión de “crear una red neuronal en python en scratch”, particularmente la parte de “scratch” para la comprensión conceptual.

Ampliando Tu Conocimiento: Próximos Pasos en Python

Mientras que nuestro simple ejemplo en Python es un gran comienzo, las redes neuronales en el mundo real utilizan bibliotecas y técnicas más avanzadas. Aquí hay algunas direcciones para explorar después de dominar los conceptos básicos de crear redes neuronales en Python:

TensorFlow y Keras

Estas son bibliotecas poderosas y ampliamente utilizadas para construir y entrenar redes neuronales. Keras, en particular, proporciona una API de alto nivel que facilita enormemente la construcción de modelos complejos en comparación con NumPy en bruto. Definimos capas, funciones de activación y compilamos nuestro modelo con solo unas pocas líneas de código.

# Ejemplo usando Keras (simplificado)
from tensorflow import keras
from tensorflow.keras import layers

# Definir el modelo
model = keras.Sequential([
 layers.Dense(4, activation='relu', input_shape=(2,)), # Capa oculta con 4 neuronas, ReLU
 layers.Dense(1, activation='sigmoid') # Capa de salida con 1 neurona, Sigmoide
])

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

# Entrenar el modelo (usando X e y de nuestro ejemplo de XOR)
model.fit(X, y, epochs=1000, verbose=0)

# Hacer predicciones
predictions = model.predict(X)
print("Predicciones de Keras:\n", predictions.round())

Diferentes Funciones de Activación

Experimenta con ReLU, Leaky ReLU, Tanh y otras funciones de activación. Cada una tiene sus fortalezas y debilidades dependiendo del problema.

Más Capas y Neuronas

Construye redes más profundas (más capas ocultas) y redes más amplias (más neuronas por capa) para abordar problemas más complejos. Ten en cuenta el sobreajuste, donde la red aprende demasiado bien los datos de entrenamiento y rinde mal en datos nuevos y no vistos.

Funciones de Pérdida y Optimizadores

Explora diferentes funciones de pérdida (por ejemplo, Error Cuadrático Medio, Entropía Cruzada Categórica) y optimizadores (por ejemplo, Adam, SGD con momento). Estos impactan significativamente en qué tan bien y rápido aprende tu red.

Conjuntos de Datos del Mundo Real

Ve más allá de XOR. Trabaja con conjuntos de datos de scikit-learn (por ejemplo, Iris, Wine) o conjuntos de datos públicos como MNIST para clasificación de imágenes. Aquí es donde el poder de crear redes neuronales en Python realmente brilla.

Conclusión

Has dado un paso significativo en el mundo de la IA al entender e implementar una red neuronal. Desde los conceptos fundamentales de neuronas, pesos y funciones de activación, hasta una implementación práctica en Python para el problema de XOR, y hasta una simulación visual en Scratch, ahora tienes una sólida comprensión. El viaje de crear redes neuronales en python en scratch no se trata solo de codificar; se trata de construir intuición y entender cómo estos sistemas inteligentes aprenden.

Recuerda, la IA es un proceso iterativo. Sigue experimentando, sigue aprendiendo y no tengas miedo de romper cosas y reconstruirlas. Las habilidades que has adquirido aquí son transferibles y servirán como una base sólida para proyectos de aprendizaje automático más avanzados. ¡Feliz codificación!

FAQ

Q1: ¿Por qué es necesaria una capa oculta para problemas como XOR?

A1: El problema de XOR es “no linealmente separable.” Esto significa que no puedes trazar una sola línea recta para separar las entradas que resultan en una salida de 0 de aquellas que resultan en una salida de 1. Un perceptrón de una sola capa (sin capa oculta) solo puede aprender patrones linealmente separables. Una capa oculta permite a la red neuronal aprender relaciones más complejas y no lineales al transformar los datos de entrada en una nueva representación que luego puede ser separada linealmente por la capa de salida.

Q2: ¿Cuál es la principal diferencia entre usar NumPy y Keras para crear redes neuronales?

A2: NumPy proporciona las herramientas fundamentales para el cálculo numérico en Python, permitiendo implementar redes neuronales desde cero manejando manualmente las multiplicaciones de matrices, funciones de activación y retropropagación. Esto te da una visión profunda de la mecánica subyacente. Keras (construido sobre TensorFlow) es una API de alto nivel que abstrae gran parte de esta complejidad. Proporciona capas preconstruidas, optimizadores y funciones de pérdida, facilitando significativamente la construcción, entrenamiento y experimentación con arquitecturas de redes neuronales complejas, especialmente para conjuntos de datos más grandes y modelos más sofisticados. Mientras que NumPy es genial para aprender lo básico, Keras es preferido para aplicaciones prácticas del mundo real.

Q3: ¿Puedo construir una red neuronal completa y compleja directamente en Scratch?

A3: No, Scratch no está diseñado para construir redes neuronales completas y complejas. Carece de la eficiencia computacional, bibliotecas matemáticas (como NumPy) y características avanzadas necesarias para entrenar modelos grandes con muchas capas y parámetros. Sin embargo, Scratch es una excelente herramienta para visualizar y entender los conceptos fundamentales de las redes neuronales, como cómo funcionan las neuronas individuales, cómo se ponderan las entradas y cómo las funciones de activación toman decisiones. Es una herramienta educativa fantástica para que los principiantes comprendan la intuición detrás de “crear redes neuronales en python en scratch” antes de sumergirse en el código.

Q4: ¿Qué tan importante es la tasa de aprendizaje y qué sucede si es demasiado alta o baja?

A4: ¡La tasa de aprendizaje es crucial! Determina el tamaño del paso con el que se actualizan los pesos de la red neuronal durante el entrenamiento.

• Demasiado Alta: Si la tasa de aprendizaje es demasiado alta, la red podría “sobrepasar” los pesos óptimos, haciendo que la pérdida oscile salvajemente o incluso se desvíe (aumente en lugar de disminuir). La red podría nunca converger a una buena solución.
• Demasiado Baja: Si la tasa de aprendizaje es demasiado baja, la red aprenderá muy lentamente. El entrenamiento tomará mucho tiempo y podría quedar atrapada en un “mínimo local” – una solución subóptima – antes de alcanzar el óptimo global.

Encontrar una tasa de aprendizaje apropiada es a menudo un proceso de prueba y error, o utilizando optimizadores adaptativos como Adam, que ajustan automáticamente la tasa de aprendizaje durante el entrenamiento.

🕒 Published: March 26, 2026