На основе теоретических основ реализовать алгоритм подбора весовых коэффициентов персептрона программно

#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime> 
 
using namespace std;
 
class Perceptron {
private:
    vector<vector<double>> weights;
    double learning_rate;
    int num_inputs;
    int num_outputs;
 
public:
    Perceptron(int num_inputs, int num_outputs, double learning_rate) {
        this->learning_rate = learning_rate;
        this->num_inputs = num_inputs;
        this->num_outputs = num_outputs;
 
        // Инициализируем веса случайными значениями от -1 до 1
        srand(time(NULL)); // засеваем генератор случайных чисел
        for (int i = 0; i < num_inputs; i++) {
            vector<double> row;
            for (int j = 0; j < num_outputs; j++) {
                row.push_back(((double) rand() / RAND_MAX) * 2 - 1);
            }
            weights.push_back(row);
        }
    }
 
    int predict(vector<double> input) {
        double sum = 0.0;
        for (int i = 0; i < num_inputs; i++) {
            for (int j = 0; j < num_outputs; j++) {
                sum += weights[i][j] * input[i];
            }
        }
        return (sum > 0.0) ? 1 : 0;
    }
 
    void train(vector<vector<double>> inputs, vector<int> desired_outputs, int max_iterations) {
        int num_iterations = 0;
        while (num_iterations < max_iterations) {
            bool errors = false;
            for (int i = 0; i < inputs.size(); i++) {
                vector<double> input = inputs[i];
                int desired_output = desired_outputs[i];
                int output = predict(input);
                int error = desired_output - output;
                if (error != 0) {
                    errors = true;
                    for (int j = 0; j < num_inputs; j++) {
                        for (int k = 0; k < num_outputs; k++) {
                            weights[j][k] += learning_rate * error * input[j];
                        }
                    }
                }
            }
            if (!errors) {
                break;
            }
            num_iterations++;
        }
    }
 
    vector<vector<double>> get_weights() {
        return weights;
    }
};
 
int main() {
    vector<vector<double>> inputs = {{0, 0}, {0, 1}, {1, 0}, {1, 1}};
    vector<int> desired_outputs = {0, 0, 0, 1};
    Perceptron p(inputs[0].size(), 1, 0.1);
    p.train(inputs, desired_outputs, 100);
    vector<vector<double>> weights = p.get_weights();
    for (int i = 0; i < weights.size(); i++) {
        for (int j = 0; j < weights[i].size(); j++) {
            cout << weights[i][j] << " ";
        }
        cout << endl;
    }
    return 0;
}