> For the complete documentation index, see [llms.txt](https://red-neuronal-artificial.gitbook.io/neuronas/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://red-neuronal-artificial.gitbook.io/neuronas/contenido/1.-introduccion-a-las-redes-neuronales./1.1-arquitectura-de-una-neurona-artificial/perceptron-multicapa/xor-en-python.md).

# 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`:

```python
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.