📗XOR en python

Aquí tienes un ejemplo de implementación en Python de un perceptrón multicapa para resolver la operación XOR utilizando la biblioteca numpy:

import numpy as np

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

# Función para entrenar el perceptrón
def train_perceptron(X, y, num_epochs, learning_rate):
    # Inicializar los pesos y los sesgos aleatoriamente
    np.random.seed(0)
    synapse_0 = 2 * np.random.random((2, 2)) - 1
    synapse_1 = 2 * np.random.random((2, 1)) - 1

    for epoch in range(num_epochs):
        # Propagación hacia adelante
        layer_0 = X
        layer_1 = sigmoid(np.dot(layer_0, synapse_0))
        layer_2 = sigmoid(np.dot(layer_1, synapse_1))

        # Cálculo del error
        error = y - layer_2

        # Retropropagación del error y ajuste de pesos
        delta_layer_2 = error * (layer_2 * (1 - layer_2))
        delta_layer_1 = delta_layer_2.dot(synapse_1.T) * (layer_1 * (1 - layer_1))

        synapse_1 += learning_rate * layer_1.T.dot(delta_layer_2)
        synapse_0 += learning_rate * layer_0.T.dot(delta_layer_1)

    return synapse_0, synapse_1

# Datos de entrenamiento
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([[0, 1, 1, 0]]).T

# Entrenar el perceptrón
synapse_0, synapse_1 = train_perceptron(X, y, num_epochs=10000, learning_rate=0.1)

# Función para predecir la salida
def predict(X):
    layer_0 = X
    layer_1 = sigmoid(np.dot(layer_0, synapse_0))
    layer_2 = sigmoid(np.dot(layer_1, synapse_1))
    return layer_2

# Ejemplo de predicción
test_input = np.array([[0, 1]])
prediction = predict(test_input)
print("Predicción:", prediction)

En este ejemplo, la función train_perceptron entrena el perceptrón multicapa utilizando la técnica de retropropagación del error durante un número determinado de épocas. La función predict realiza la propagación hacia adelante para predecir la salida del perceptrón dado un conjunto de entrada.

La implementación utiliza la función de activación sigmoidal y la biblioteca numpy para realizar operaciones matriciales de manera eficiente.

Es importante destacar que este es solo un ejemplo básico de un perceptrón multicapa en Python. Para aplicaciones más complejas, es posible que necesites utilizar bibliotecas y técnicas más avanzadas, como TensorFlow o PyTorch, y ajustar la arquitectura y los parámetros del perceptrón según los requisitos del problema que estés resolviendo.