import numpy as np

class NeuralNetwork:
    def __init__(self, input_size, hidden_size, output_size):
        # Инициализация весов
        self.weights_input_to_hidden = np.random.rand(input_size, hidden_size)
        self.weights_hidden_to_output = np.random.rand(hidden_size, output_size)

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

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

    def forward_pass(self, inputs):
        self.input = inputs
        self.hidden = self.sigmoid(np.dot(self.input, self.weights_input_to_hidden))
        self.output = self.sigmoid(np.dot(self.hidden, self.weights_hidden_to_output))
        return self.output

    def backward_pass(self, inputs, expected_output, learning_rate):
        error = expected_output - self.output
        d_output = error * self.sigmoid_derivative(self.output)

        error_hidden = d_output.dot(self.weights_hidden_to_output.T)
        d_hidden = error_hidden * self.sigmoid_derivative(self.hidden)

        # Обновление весов
        self.weights_hidden_to_output += self.hidden.T.dot(d_output) * learning_rate
        self.weights_input_to_hidden += inputs.T.dot(d_hidden) * learning_rate

    def train(self, training_inputs, training_outputs, learning_rate):
        output = self.forward_pass(training_inputs)
        self.backward_pass(training_inputs, training_outputs, learning_rate)

# Пример использования
input_size = 3
hidden_size = 4
output_size = 1
learning_rate = 0.1
network = NeuralNetwork(input_size, hidden_size, output_size)

# Данные для обучения
training_inputs = np.array([[0,0,1], [1,1,1], [1,0,1], [0,1,1]])
training_outputs = np.array([[0,1,1,0]]).T

# Обучение
for i in range(2000):
    network.train(training_inputs, training_outputs, learning_rate)