Как сделать динамическое добавление слоев в нейронной сети?

Question

[mIka01]

Нейронная сеть. Вместо массивов векторы. Как сделать динамическое выделение векторов, когда мы выбираем сколько слоев нам нужно между начальным и конечным. Например, в интерфейсе указать, что у меня 3 слоя и эти 3 слоя сами создались как вектор векторов.

int main()
{
    setlocale(LC_ALL, "Russian");

    vector < vector < double >> no(10, vector<double>(2)); // нулевой слой        

    vector < vector < double >> n1(5, vector<double>(2)); // первый слой        

    vector < vector < double >> n2(4, vector<double>(2)); // второй слой        

    vector < vector < double >> n3(2, vector<double>(2)); // третий слой

    vector < vector < double >> idl(2, vector<double>(1)); // нужно получить

    static double k = 0.5;

    vector < vector < double >> w01(10, vector<double>(4));
    vector < vector < double >> w12(5, vector<double>(3));
    vector < vector < double >> w23(4, vector<double>(2));


    vector < vector < double >> test_questions =
    {
        { 1, 1, 1, 0, 0, 0, 0, 0, 0 },
        { 0, 1, 0, 0, 1, 0, 0, 1, 0 },
        { 1, 1, 1, 0, 0, 1, 0, 0, 1 },
        { 1, 0, 0, 1, 0, 0, 1, 1, 1 },
        { 0, 0, 0, 1, 1, 1, 0, 0, 0 },
        { 0, 0, 1, 0, 0, 1, 0, 0, 1 },
        { 1, 0, 0, 1, 1, 1, 1, 0, 0 },
        { 0, 1, 0, 0, 1, 0, 1, 1, 1 },
        { 0, 0, 0, 0, 0, 0, 1, 1, 1 },
        { 1, 1, 1, 1, 0, 0, 1, 0, 0 },
        { 0, 1, 0, 1, 1, 1, 0, 1, 0 },
        { 0, 0, 1, 0, 0, 1, 1, 1, 1 },
        { 1, 0, 0, 1, 0, 0, 1, 0, 0 },
        { 1, 1, 1, 0, 1, 0, 0, 1, 0 },
        { 0, 0, 1, 1, 1, 1, 0, 0, 1 },
        { 0, 0, 0, 0, 0, 0, 0, 0, 0 },
    };
    vector < vector < double >> test_answers =
    {
        { 1, 0 },
        { 0, 1 },
        { 1, 1 },
        { 1, 1 },
        { 1, 0 },
        { 0, 1 },
        { 1, 1 },
        { 1, 1 },
        { 1, 0 },
        { 1, 1 },
        { 1, 1 },
        { 1, 1 },
        { 0, 1 },
        { 1, 1 },
        { 1, 1 },
        { 0, 0 },
    };

    no[9][0] = 1;
    n1[4][0] = 1;
    n2[3][0] = 1;

    communication neuro;
    neuro.fillW(w01); // рандом весов
    neuro.fillW(w12);
    neuro.fillW(w23);


    for (int i = 0; i < 100000; i++)
    {

        for (int j = 0; j < test_questions[0].size(); j++)
        {
            neuro.getTask(no, test_questions, test_answers, idl, j); // новый пример для нейроситей

            neuro.forWards(no, w01, n1); // проход по слою
            neuro.forWards(n1, w12, n2);
            neuro.forWards(n2, w23, n3);

            neuro.fixOutError(idl, n3); // нахождение отклонений
            neuro.findError(n2, w23, n3); // нахождение ошибок слоя
            neuro.findError(n1, w12, n2);

            neuro.backWards(n2, w23, n3, k); // изменение весов
            neuro.backWards(n1, w12, n2, k);
            neuro.backWards(no, w01, n1, k);
        }



    }

    cout << "===========================================================" << endl;

    while (true)
    {
        int i;
        cin >> i;

        neuro.getTask(no, test_questions, test_answers, idl, i);
        neuro.forWards(no, w01, n1);
        neuro.forWards(n1, w12, n2);
        neuro.forWards(n2, w23, n3);

        neuro.read(test_questions, test_answers, i);
        cout << endl;
        neuro.write(n3);
        cout << "===========================================================" << endl;
    }
    return 0;
}