import numpy as np

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.weights_input_hidden = np.random.rand(input_size, hidden_size)
        self.weights_hidden_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 train(self, X, y, learning_rate, epochs):
        for epoch in range(epochs):
            # Прямое распространение
            hidden_layer_input = np.dot(X, self.weights_input_hidden)
            hidden_layer_output = self.sigmoid(hidden_layer_input)
            output_layer_input = np.dot(hidden_layer_output, self.weights_hidden_output)
            output_layer_output = self.sigmoid(output_layer_input)

            # Вычисление ошибки
            error = y - output_layer_output

            # Обратное распространение
            d_output = error * self.sigmoid_derivative(output_layer_output)
            error_hidden = d_output.dot(self.weights_hidden_output.T)
            d_hidden = error_hidden * self.sigmoid_derivative(hidden_layer_output)

            # Обновление весов
            self.weights_hidden_output += hidden_layer_output.T.dot(d_output) * learning_rate
            self.weights_input_hidden += X.T.dot(d_hidden) * learning_rate

    def predict(self, X):
        hidden_layer_input = np.dot(X, self.weights_input_hidden)
        hidden_layer_output = self.sigmoid(hidden_layer_input)
        output_layer_input = np.dot(hidden_layer_output, self.weights_hidden_output)
        output_layer_output = self.sigmoid(output_layer_input)
        return output_layer_output

# Загрузка данных из iris.json и подготовка их для обучения
import json

with open('iris.json', 'r') as f:
    data = json.load(f)

X = np.array([item[:2] for item in data])
y = np.array([item[2] for item in data])

# Создание и обучение нейронной сети
input_size = 2
hidden_size = 4
output_size = 1

nn = NeuralNetwork(input_size, hidden_size, output_size)
nn.train(X, y, learning_rate=0.1, epochs=1000)

# Теперь вы можете использовать nn.predict() для предсказания класса для новых данных и построения карты классификации.