Как запустить программу, созданную ИИ

import numpy as np
 
class FeedforwardNetwork:
    def __init__(self, num_layers, num_nodes_per_layer, activation_function, derivative_function):
        self.num_layers = num_layers
        self.num_nodes_per_layer = num_nodes_per_layer
        self.activation_function = activation_function
        self.derivative_function = derivative_function
        self.weights = self.initialize_weights()
 
    def initialize_weights(self):
        weights = []
        for i in range(self.num_layers - 1):
            layer_weights = np.random.randn(self.num_nodes_per_layer[i], self.num_nodes_per_layer[i + 1])
            weights.append(layer_weights)
        return weights
 
    def feedforward(self, inputs):
        activations = [inputs]
        for i in range(self.num_layers - 1):
            layer_inputs = np.dot(activations[-1], self.weights[i])
            layer_outputs = self.activation_function(layer_inputs)
            activations.append(layer_outputs)
        return activations[-1]
 
    def train(self, data, learning_rate, epochs):
        for epoch in range(epochs):
            for sample in data:
                inputs = sample[:-1]
                expected_outputs = sample[-1]
                outputs = self.feedforward(inputs)
                error = expected_outputs - outputs
                deltas = [error * self.derivative_function(outputs)]
                for i in range(self.num_layers - 2, -1, -1):
                    delta = np.dot(deltas[0], self.weights[i].T) * self.derivative_function(activations[i + 1])
                    deltas.insert(0, delta)
                for i in range(self.num_layers - 1):
                    self.weights[i] += learning_rate * np.outer(activations[i], deltas[i])
 
    def use(self, inputs):
        return self.feedforward(inputs)
 
# Example usage
activation_function = lambda x: 1 / (1 + np.exp(-x))  # Sigmoid activation function
derivative_function = lambda x: x * (1 - x)  # Derivative of the sigmoid function
 
network = FeedforwardNetwork(num_layers=3, num_nodes_per_layer=[2, 3, 1], activation_function=activation_function, derivative_function=derivative_function)
 
# Training stage
data = np.array([[0, 0, 0], [0, 1, 1], [1, 0, 1], [1, 1, 0]])
network.train(data, learning_rate=0.1, epochs=10000)
 
# Usage stage
input_data = np.array([1, 0])
output = network.use(input_data)
print("Output:", output)

import numpy as np
 
 
class FeedforwardNetwork:
    def __init__(
        self, num_layers, num_nodes_per_layer, activation_function, derivative_function
    ):
        self.num_layers = num_layers
        self.num_nodes_per_layer = num_nodes_per_layer
        self.activation_function = activation_function
        self.derivative_function = derivative_function
        self.weights = self.initialize_weights()
 
    def initialize_weights(self):
        weights = []
        for i in range(self.num_layers - 1):
            layer_weights = np.random.randn(
                self.num_nodes_per_layer[i], self.num_nodes_per_layer[i + 1]
            )
            weights.append(layer_weights)
        return weights
 
    def feedforward(self, inputs):
        activations = [inputs]
        current_inputs = inputs
        
        for i in range(self.num_layers - 1):
            current_inputs = self.activation_function(
                np.dot(current_inputs, self.weights[i])
            )
            activations.append(current_inputs)
        
        return activations[-1], activations
 
    def train(self, samples, learning_rate=0.1, epochs=1000):
        for _ in range(epochs):
            for sample in samples:
                inputs = sample[0]
                expected_outputs = sample[-1]
                outputs, activations = self.feedforward(inputs)
                
                # Initialize deltas list for output layer
                error = expected_outputs - outputs
                deltas = [error * self.derivative_function(outputs)]
                
                # Backpropagate through hidden layers
                for i in range(self.num_layers - 2, 0, -1):
                    delta = np.dot(
                        deltas[-1], self.weights[i].T
                    ) * self.derivative_function(activations[i])
                    deltas.append(delta)
                
                # Reverse deltas to match layer order
                deltas = deltas[::-1]
                
                # Update weights
                for i in range(self.num_layers - 1):
                    self.weights[i] += learning_rate * np.outer(
                        activations[i], deltas[i]
                    )
 
    def use(self, inputs):
        return self.feedforward(inputs)[0]
 
 
# Example usage
activation_function = lambda x: 1 / (1 + np.exp(-x))  # Sigmoid activation function
derivative_function = lambda x: x * (1 - x)  # Derivative of the sigmoid function
 
network = FeedforwardNetwork(
    num_layers=3,
    num_nodes_per_layer=[2, 3, 1],
    activation_function=activation_function,
    derivative_function=derivative_function,
)
 
# Training stage
data = [([0, 0], [0]), ([0, 1], [1]), ([1, 0], [1]), ([1, 1], [0])]
network.train(data, learning_rate=0.1, epochs=10000)
 
# Usage stage
input_data = np.array([1, 0])
output = network.use(input_data)
print("Output:", output)