import numpy as np

def sigmoid(x):
return 1 / (1 + np.exp(-x))

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

class NeuralNetwork:
def __init__(self, input_size, hidden_size, output_size):
self.input_size = input_size
self.hidden_size = hidden_size
self.output_size = output_size
self.weights1 = np.random.randn(input_size, hidden_size)
self.bias1 = np.zeros((1, hidden_size))
self.weights2 = np.random.randn(hidden_size, output_size)
self.bias2 = np.zeros((1, output_size))

def forward(self, X):

self.hidden_layer = sigmoid(np.dot(X, self.weights1) + self.bias1)
self.output_layer = sigmoid(np.dot(self.hidden_layer, self.weights2) + self.bias2)

def backward(self, X, y, learning_rate):

delta_output = (y - self.output_layer) * sigmoid_derivative(self.output_layer)
delta_hidden = delta_output.dot(self.weights2.T) * sigmoid_derivative(self.hidden_layer)
self.weights2 += self.hidden_layer.T.dot(delta_output) * learning_rate
self.bias2 += np.sum(delta_output, axis=0, keepdims=True) * learning_rate
self.weights1 += X.T.dot(delta_hidden) * learning_rate
self.bias1 += np.sum(delta_hidden, axis=0, keepdims=True) * learning_rate

def train(self, X, y, epochs, learning_rate):

for epoch in range(epochs):
self.forward(X)
self.backward(X, y, learning_rate)

def predict(self, X):

self.forward(X)
return self.output_layer
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([[0], [1], [1], [0]])

network = NeuralNetwork(2, 2, 1)

network.train(X, y, epochs=10000, learning_rate=0.1)

predictions = network.predict(X)
print(predictions)

Output:
[[0.03171818]
[0.96887494]
[0.96888095]
[0.03230392]]