Ir al contenido principal

Explorando el Perceptrón Multicapa: XOR y Backpropagation


 

El perceptrón multicapa (MLP, por sus siglas en inglés) representa un avance significativo en la arquitectura de las redes neuronales, permitiendo superar limitaciones de modelos más simples como el perceptrón único. A través de la incorporación de múltiples capas de neuronas entre la entrada y la salida, los MLP pueden modelar relaciones complejas y no lineales entre los datos de entrada y salida, lo que los hace adecuados para una amplia gama de tareas de aprendizaje automático, desde la clasificación hasta la regresión.

La Importancia de XOR

Uno de los problemas clásicos que el perceptrón simple no puede resolver es el de la operación lógica XOR (exclusivo O). El XOR es una operación que devuelve verdadero (1) si y solo si el número de entradas verdaderas es impar. En términos de entradas binarias, esto significa que XOR devuelve 1 si las entradas son diferentes y 0 si son iguales.

La incapacidad del perceptrón simple para resolver XOR se debe a su linealidad; XOR es un problema no linealmente separable, lo que significa que no se puede dibujar una única línea recta que separe las entradas en las categorías correctas. La solución a este problema vino con el perceptrón multicapa y el algoritmo de backpropagation.

Backpropagation: El Motor de Aprendizaje

Backpropagation, o propagación hacia atrás, es un método utilizado para entrenar redes neuronales, incluidos los MLP. Funciona ajustando los pesos de la red de forma iterativa en función del error de la salida predicha respecto a la salida esperada. Este ajuste se realiza a través de un proceso llamado descenso de gradiente, donde el gradiente del error se calcula y se propaga hacia atrás a través de la red, permitiendo que cada peso se ajuste de manera que minimice el error total.

El proceso consta de dos pasos principales: la propagación hacia adelante, donde las entradas se pasan a través de la red para obtener una salida, y la propagación hacia atrás, donde se calcula el gradiente del error respecto a cada peso y se ajustan los pesos para minimizar el error.

Implementación de un MLP para XOR en Python

Implementar un MLP para resolver el problema XOR es un excelente ejercicio para entender cómo las redes más complejas pueden modelar problemas que no son linealmente separables. A continuación, presentamos una implementación básica de un perceptrón multicapa que puede aprender la operación XOR usando backpropagation.

import numpy as np def sigmoid(x): return 1 / (1 + np.exp(-x)) def sigmoid_derivative(x): return x * (1 - x) # Datos de entrenamiento para XOR inputs = np.array([[0,0], [0,1], [1,0], [1,1]]) expected_output = np.array([[0], [1], [1], [0]]) epochs = 10000 lr = 0.1 inputLayerNeurons, hiddenLayerNeurons, outputLayerNeurons = 2, 2, 1 # Inicialización de pesos y sesgos hidden_weights = np.random.uniform(size=(inputLayerNeurons,hiddenLayerNeurons)) hidden_bias =np.random.uniform(size=(1,hiddenLayerNeurons)) output_weights = np.random.uniform(size=(hiddenLayerNeurons,outputLayerNeurons)) output_bias = np.random.uniform(size=(1,outputLayerNeurons)) # Entrenamiento for _ in range(epochs): # Propagación hacia adelante hidden_layer_activation = np.dot(inputs, hidden_weights) hidden_layer_activation += hidden_bias hidden_layer_output = sigmoid(hidden_layer_activation) output_layer_activation = np.dot(hidden_layer_output, output_weights) output_layer_activation += output_bias predicted_output = sigmoid(output_layer_activation) # Cálculo del error error = expected_output - predicted_output d_predicted_output = error * sigmoid_derivative(predicted_output) # Propagación hacia atrás error_hidden_layer = d_predicted_output.dot(output_weights.T) d_hidden_layer = error_hidden_layer * sigmoid_derivative(hidden_layer_output) # Actualizando pesos y sesgos output_weights += hidden_layer_output.T.dot(d_predicted_output) * lr output_bias += np.sum(d_predicted_output,axis=0,keepdims=True)

Comentarios

Entradas más populares de este blog

Redes Neuronales Convolucionales: Revolucionando el Reconocimiento de Números e Imágenes

  Las Redes Neuronales Convolucionales (CNNs, por sus siglas en inglés) han transformado radicalmente el campo del reconocimiento de imágenes y visión por computadora. Inspiradas en la organización del córtex visual humano, las CNNs son especialmente adeptas para procesar datos en forma de matrices, lo que las hace ideales para trabajar con imágenes. A través de la aplicación de filtros o núcleos de convolución, estas redes son capaces de capturar patrones espaciales y temporales en los datos, como bordes, texturas y formas, lo que permite una eficaz clasificación y reconocimiento de imágenes. ¿Cómo Funcionan las CNNs? Las CNNs se componen de varias capas que transforman la entrada (por ejemplo, una imagen) a través de operaciones como la convolución, la activación no lineal (como ReLU), el pooling (o submuestreo), y finalmente capas completamente conectadas. Este proceso se resume en tres pasos principales: Convolución : Aplica filtros a la entrada para crear mapas de característi...

Mini video Educativo