Эксперты с++ посоревнуйтесь с ИИ

@VAF34 · Регистрация: 10.06.2023

Студворк — интернет-сервис помощи студентам

Заинтересовавшись ИИ и, имея значительный опыт использования вычислительной техники в научной деятельности, решил познакомиться с некоторыми алгоритмами, использующимися при создании элементов ИИ. Обнаружил, что основной язык, применяемый при программирования ИИ это питон, мне совершенно не знакомый. Оказалось, что работа с ним основана на использовании большого количества специальных библиотек, в которых и их вариантах и в вариантах самого питона разобраться очень сложно. С++ более открытый язык. Нашел в интернете простенькую программу распознавания, погонял ее, обнаружил странности, не разрешил их, даже обратившись к форуму.
Решил усложнить для себя проблему и посмотреть, что такое сети Колмогорова Арнольда, предполагая, что идеи этих двух великих математиков, достаточно подробно обсуждаемые в литературе по ИИ, помогут понять алгоритмизацию ИИ.
И решил использовать ИИ в качестве помощника в написании кода. Несколько первых попыток перевода программ с питона на с++, оптимизация кодов, получение программ по заявке были успешны. Успешно прошло получение графиков в программах на с++.
Но при переходе к более сложным программам вскрылись недостатки ИИ в этой, на очень сложной деятельности - программирование. Первый - ИИ дает вам советы, сам ничего не делая.
Второй - столкнувшись с трудно разрешаемой проблемой, не объявляет об этом, а либо "ваша квота исчерпана", либо "сервер перегружен".
Предлагаю задачу исправить программу TimeSeriesKAN.cpp, которую создал DeepSeek по запросу
анализ временного ряда средствами сети Колмогорова Арнольда.
Пусть на вход поступает сигнал, в котором в случайные моменты времени появляются пакеты
двух типов. постоянный сигнал, длящийся некоторое время, и сигнал, напоминающий распределение Гаусса.
На паре выходов функции времени, изображающие амплитуды обнаруженных пакетов.
Была получена

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
#include <iostream>
#include <vector>
#include <cmath>
#include <random>
#include <functional>
#include <algorithm>
#include <fstream>
 
using namespace std;
 
// Генератор случайных чисел
random_device rd;
mt19937 gen(rd());
 
// Активационные функции и их производные
double phi(double x) {
    return tanh(x);
}
 
double phi_derivative(double x) {
    return 1.0 - tanh(x) * tanh(x);
}
 
double psi(double x) {
    return x * exp(-x * x / 2.0);
}
 
double psi_derivative(double x) {
    return (1 - x * x) * exp(-x * x / 2.0);
}
 
class KANLayer {
public:
    vector<vector<double>> weights;
    vector<vector<function<double(double)>>> transforms;
    vector<vector<function<double(double)>>> transform_derivatives;
    int input_size, output_size;
 
    KANLayer(int in_size, int out_size) : input_size(in_size), output_size(out_size) {
        uniform_real_distribution<> weight_dis(-0.1, 0.1);
 
        weights.resize(input_size, vector<double>(output_size));
        transforms.resize(input_size, vector<function<double(double)>>(output_size));
        transform_derivatives.resize(input_size, vector<function<double(double)>>(output_size));
 
        for (int i = 0; i < input_size; ++i) {
            for (int j = 0; j < output_size; ++j) {
                weights[i][j] = weight_dis(gen);
                transforms[i][j] = (j % 2 == 0) ? phi : psi;
                transform_derivatives[i][j] = (j % 2 == 0) ? phi_derivative : psi_derivative;
            }
        }
    }
 
    vector<double> forward(const vector<double>& input) {
        vector<double> output(output_size, 0.0);
        for (int j = 0; j < output_size; ++j) {
            for (int i = 0; i < input_size; ++i) {
                output[j] += weights[i][j] * transforms[i][j](input[i]);
            }
        }
        return output;
    }
 
    void update_weights(const vector<double>& input, const vector<double>& gradient, double lr) {
        for (int i = 0; i < input_size; ++i) {
            for (int j = 0; j < output_size; ++j) {
                weights[i][j] -= lr * input[i] * transform_derivatives[i][j](input[i]) * gradient[j];
            }
        }
    }
};
 
class KANNetwork {
private:
    vector<KANLayer> layers;
    double learning_rate;
    vector<double> losses_history;
 
public:
    KANNetwork(double lr = 0.01) : learning_rate(lr) {}
 
    void addLayer(int input_size, int output_size) {
        layers.emplace_back(input_size, output_size);
    }
 
    vector<double> predict(const vector<double>& input) {
        vector<double> current = input;
        for (auto& layer : layers) {
            current = layer.forward(current);
        }
        return current;
    }
 
    void train(const vector<vector<double>>& inputs, const vector<vector<double>>& targets, int epochs) {
        for (int epoch = 0; epoch < epochs; ++epoch) {
            double total_loss = 0.0;
            for (size_t k = 0; k < inputs.size(); ++k) {
                // Forward pass
                vector<double> output = predict(inputs[k]);
 
                // Calculate loss and gradient
                vector<double> output_gradient(output.size());
                for (size_t j = 0; j < output.size(); ++j) {
                    output_gradient[j] = output[j] - targets[k][j];
                    total_loss += 0.5 * output_gradient[j] * output_gradient[j];
                }
 
                // Update weights (упрощенный backprop)
                vector<double> grad = output_gradient;
                for (int l = static_cast<int>(layers.size()) - 1; l >= 0; --l) {
                    vector<double> input_for_layer = (l == 0) ? inputs[k] : layers[l - 1].forward(inputs[k]);
                    layers[l].update_weights(input_for_layer, grad, learning_rate);
                }
            }
 
            losses_history.push_back(total_loss / inputs.size());
            if (epoch % 100 == 0) {
                cout << "Epoch " << epoch << ", Loss: " << losses_history.back() << endl;
            }
        }
    }
 
    void save_loss_history() {
        ofstream f("loss_history.txt");
        for (double loss : losses_history) {
            f << loss << "\n";
        }
        f.close();
    }
};
 
// Генератор тестового сигнала
vector<double> generate_signal(int length) {
    vector<double> signal(length, 0.0);
    uniform_int_distribution<> pos_dist(0, length - 50);
    uniform_real_distribution<> amp_dist(0.5, 2.0);
    normal_distribution<> gauss_noise(0, 0.1);
 
    // Генерация постоянных пакетов
    for (int i = 0; i < 3; ++i) {
        int start = pos_dist(gen);
        int duration = 20 + gen() % 30;
        double amplitude = amp_dist(gen);
        for (int j = start; j < min(start + duration, length); ++j) {
            signal[j] += amplitude;
        }
    }
 
    // Генерация гауссовых пакетов
    for (int i = 0; i < 3; ++i) {
        int center = pos_dist(gen);
        int width = 10 + gen() % 20;
        double amplitude = amp_dist(gen);
        for (int j = max(0, center - width); j < min(center + width, length); ++j) {
            signal[j] += amplitude * exp(-pow((j - center) / 5.0, 2));
        }
    }
 
    // Добавляем шум
    for (int i = 0; i < length; ++i) {
        signal[i] += gauss_noise(gen);
    }
 
    return signal; 
}
 
// Создание обучающих данных
void create_training_data(const vector<double>& signal, int window_size,
    vector<vector<double>>& inputs, vector<vector<double>>& targets) {
    for (size_t i = 0; i < signal.size() - window_size; ++i) {
        vector<double> input(window_size);
        vector<double> target(2, 0.0); // [постоянный_пакет, гауссов_пакет]
 
        // Копируем окно сигнала
        copy(signal.begin() + i, signal.begin() + i + window_size, input.begin());
 
        // Анализируем центр окна для определения типа пакета
        double center_val = signal[i + window_size / 2];
        double avg = accumulate(input.begin(), input.end(), 0.0) / window_size;
 
        // Простая эвристика для определения типа пакета
        if (center_val > avg * 1.5 && center_val > 0.3) {
            // Проверяем форму сигнала (постоянный или гауссов)
            double diff = abs(input.back() - input.front());
            if (diff < 0.2 * center_val) {
                target[0] = 1.0; // Постоянный пакет
            }
            else {
                target[1] = 1.0; // Гауссов пакет
            }
        }
 
        inputs.push_back(input);
        targets.push_back(target);
    }
}
 
// Визуализация результатов
void visualize_results(const vector<double>& signal, const vector<vector<double>>& outputs) {
    ofstream script("visualize.py");
    script << "import matplotlib.pyplot as plt\n";
    script << "import numpy as np\n\n";
 
    // Сигнал
    script << "signal = [";
    for (double x : signal) script << x << ",";
    script << "]\n";
 
    // Выходы сети
    script << "output_constant = [";
    for (const auto& out : outputs) script << out[0] << ",";
    script << "]\n";
 
    script << "output_gaussian = [";
    for (const auto& out : outputs) script << out[1] << ",";
    script << "]\n";
 
    script << "plt.figure(figsize=(12, 8))\n";
    script << "plt.subplot(3, 1, 1)\n";
    script << "plt.plot(signal, label='Original Signal')\n";
    script << "plt.legend()\n";
    script << "plt.subplot(3, 1, 2)\n";
    script << "plt.plot(output_constant, 'r', label='Constant Packet Detection')\n";
    script << "plt.legend()\n";
    script << "plt.subplot(3, 1, 3)\n";
    script << "plt.plot(output_gaussian, 'g', label='Gaussian Packet Detection')\n";
    script << "plt.legend()\n";
    script << "plt.tight_layout()\n";
    script << "plt.savefig('packet_detection.png')\n";
    script << "plt.show()\n";
    script.close();
 
    system("python visualize.py");
}
 
int main() {
    // Параметры
    const int signal_length = 1000;
    const int window_size = 30;
    const int epochs = 500;
 
    // Генерация сигнала
    vector<double> signal = generate_signal(signal_length);
 
    // Создание обучающих данных
    vector<vector<double>> inputs;
    vector<vector<double>> targets;
    create_training_data(signal, window_size, inputs, targets);
 
    // Создание и обучение сети
    KANNetwork network(0.01);
    network.addLayer(window_size, 20);
    network.addLayer(20, 10);
    network.addLayer(10, 2);
 
    cout << "Training network..." << endl;
    network.train(inputs, targets, epochs);
    network.save_loss_history();
 
    // Тестирование на всем сигнале
    vector<vector<double>> outputs;
    for (size_t i = 0; i < signal.size() - window_size; ++i) {
        vector<double> input(window_size);
        copy(signal.begin() + i, signal.begin() + i + window_size, input.begin());
        outputs.push_back(network.predict(input));
    }
 
    // Визуализация результатов
    visualize_results(signal, outputs);
 
    return 0;
}

При попытке компиляции в VS2019 win10 обнаружено ошибка в строке double avg = accumulate(input.begin(), input.end(), 0.0) / window_size;
ИИ после пяти попыток исправлений сдался, ответив "сервер занят, приходите позже". Я не буду излагать подробности попыток, но они были достаточно долгими из-за необходимости проверок на VS моего ПК и достаточно долгих ответов, каждый раз медленно передавалась вся программа, сопровождаемая повторением тривиальных советов.
Ну кто победит? Коммерческого интереса к программе у меня нет.

@Python_Val · 10.04.2025, 10:44

Сообщение от VAF34

Возвращать вам не обязательно

Добавил full backpropagation - первый график
а потом добавил bias - второй график

@VAF34 · 10.04.2025, 16:55 **[ТС]**

Не бейте меня сильно! Решение #include <numeric> Почему его не нашел DeepSeek?

@Python_Val · 11.04.2025, 05:51

Сообщение от VAF34

Не бейте меня сильно! Решение #include <numeric> Почему его не нашел DeepSeek?

Это сразу высвечивал visual studio - он подчёркивал accumulator.
Но там дело было не только в этом - там всё время выходила ошибка по классу Vector 1925, а потом 1926 - выход за пределы.
Я просто сделал то что говорил в посте на предыдущей странице - ну там ещё пришлось ещё кучу printout поставить, для дебага. А потом, ещё и первый класс чуть изменить - но это уже сделал AI (кстати, после deepsearch он выходит на страницу этого Колмогорова (я просто видел где он ищет). И вот только после этого оно заработало (час 4 потратил).
И кстати, с загрузкой в память (на первой странице) стало работать, т.к. каждый вес получает именно то что нужно именно для этого веса (это тоже AI мне пояснил )). А с full backpropagation работает в разы быстрее. Bias даёт чуть большее отклонение (на графике видно) при обучении, но он нужен при работе например в фильтрах с обработкой "на лету". (я пробовал обработку сигнала, но в vosk-api-master нет папки cpp, т.к. нужен vosk.dll, и скомпилировать не получилось - нечего компилировать, хотя portaudio я скомпилировал через make, через kaldi тоже не вышло - уже не помню почему, т.к. уже пошёл 8й час вчера... ).
В общем, пока оставил как есть.

Добавлено через 2 часа 41 минуту

Сообщение от VAF34

Почему его не нашел DeepSeek?

Вы очень хорошо написали. там вектор ругался только в функции train, ну и ещё там...
Скидываю первый вариант. (не знаю, может кто будет и не согласен, но как есть)...

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
#include <iostream>
#include <vector>
#include <cmath>
#include <random>
#include <functional>
#include <algorithm>
#include <fstream>
#include <numeric>
#include <cassert>
 
using namespace std;
 
// Генератор случайных чисел
random_device rd;
mt19937 gen(rd());
 
// Активационные функции и их производные
double phi(double x) {
    return tanh(x);
}
 
double phi_derivative(double x) {
    return 1.0 - tanh(x) * tanh(x);
}
 
double psi(double x) {
    return x * exp(-x * x / 2.0);
}
 
double psi_derivative(double x) {
    return (1 - x * x) * exp(-x * x / 2.0);
}
 
class KANLayer {
public:
    vector<vector<double>> weights;
    vector<vector<function<double(double)>>> transforms;
    vector<vector<function<double(double)>>> transform_derivatives;
    int input_size, output_size;
 
    KANLayer(int in_size, int out_size) : input_size(in_size), output_size(out_size) {
        uniform_real_distribution<> weight_dis(-0.1, 0.1);
 
        weights.resize(input_size, vector<double>(output_size));
        transforms.resize(input_size, vector<function<double(double)>>(output_size));
        transform_derivatives.resize(input_size, vector<function<double(double)>>(output_size));
 
        for (int i = 0; i < input_size; ++i) {
            for (int j = 0; j < output_size; ++j) {
                weights[i][j] = weight_dis(gen);
                transforms[i][j] = (j % 2 == 0) ? phi : psi;
                transform_derivatives[i][j] = (j % 2 == 0) ? phi_derivative : psi_derivative;
            }
        }
    }
 
    vector<double> forward(const vector<double>& input) {
        assert(input.size() == input_size);
        vector<double> output(output_size, 0.0);
        for (int j = 0; j < output_size; ++j) {
            for (int i = 0; i < input_size; ++i) {
                output[j] += weights[i][j] * transforms[i][j](input[i]);
            }
        }
        return output;
    }
 
    void update_weights(const vector<double>& input, const vector<double>& gradient, double lr) {
        assert(input.size() == input_size);
        assert(gradient.size() == output_size);
        for (int i = 0; i < input_size; ++i) {
            for (int j = 0; j < output_size; ++j) {
                weights[i][j] -= lr * input[i] * transform_derivatives[i][j](input[i]) * gradient[j];
            }
        }
    }
};
 
class KANNetwork {
private:
    vector<KANLayer> layers;
    double learning_rate;
    vector<double> losses_history;
 
public:
    KANNetwork(double lr = 0.01) : learning_rate(lr) {}
 
    void addLayer(int input_size, int output_size) {
        layers.emplace_back(input_size, output_size);
    }
 
    vector<double> predict(const vector<double>& input) {
        vector<double> current = input;
        for (auto& layer : layers) {
            current = layer.forward(current);
        }
        return current;
    }
 
    void train(const vector<vector<double>>& inputs, const vector<vector<double>>& targets, int epochs) {
        for (int epoch = 0; epoch < epochs; ++epoch) {
            double total_loss = 0.0;
            for (size_t k = 0; k < inputs.size(); ++k) {
                // Запоминаем выходы всех слоёв
                vector<vector<double>> layer_outputs;
                vector<double> current = inputs[k];
                layer_outputs.push_back(current);
 
                for (auto& layer : layers) {
                    current = layer.forward(current);
                    layer_outputs.push_back(current);
                }
                // Forward pass
                vector<double> output = current;
 
                // Calculate loss and gradient
                vector<double> output_gradient(output.size());
                for (size_t j = 0; j < output.size(); ++j) {
                    output_gradient[j] = output[j] - targets[k][j];
                    total_loss += 0.5 * output_gradient[j] * output_gradient[j];
                }
 
                // Используем запомненные выходы слоёв (упрощённый backpropagation)
                vector<double> grad = output_gradient;
                for (int l = static_cast<int>(layers.size()) - 1; l >= 0; --l) {
                    const vector<double>& input_for_layer = layer_outputs[l];
                    if (input_for_layer.size() != layers[l].input_size || grad.size() != layers[l].output_size) {
                        cerr << "[train] Mismatch sizes at layer " << l
                            << ": input_for_layer=" << input_for_layer.size()
                            << ", expected=" << layers[l].input_size
                            << "; grad=" << grad.size()
                            << ", expected=" << layers[l].output_size << endl;
                        continue; // или exit(1);
                    }
                    // Обновляем веса 
                    layers[l].update_weights(input_for_layer, grad, learning_rate);
                }
            }
 
            losses_history.push_back(total_loss / inputs.size());
            if (epoch % 100 == 0) {
                cout << "Epoch " << epoch << ", Loss: " << losses_history.back() << endl;
            }
        }
    }
 
    void save_loss_history() {
        ofstream f("loss_history.txt");
        for (double loss : losses_history) {
            f << loss << "\n";
        }
        f.close();
    }
};
 
// Генератор тестового сигнала
vector<double> generate_signal(int length) {
    vector<double> signal(length, 0.0);
    uniform_int_distribution<> pos_dist(0, length - 50);
    uniform_real_distribution<> amp_dist(0.5, 2.0);
    normal_distribution<> gauss_noise(0, 0.1);
 
    // Генерация постоянных пакетов
    for (int i = 0; i < 3; ++i) {
        int start = pos_dist(gen);
        int duration = 20 + gen() % 30;
        double amplitude = amp_dist(gen);
        for (int j = start; j < min(start + duration, length); ++j) {
            signal[j] += amplitude;
        }
    }
 
    // Генерация гауссовых пакетов
    for (int i = 0; i < 3; ++i) {
        int center = pos_dist(gen);
        int width = 10 + gen() % 20;
        double amplitude = amp_dist(gen);
        for (int j = max(0, center - width); j < min(center + width, length); ++j) {
            signal[j] += amplitude * exp(-pow((j - center) / 5.0, 2));
        }
    }
 
    // Добавляем шум
    for (int i = 0; i < length; ++i) {
        signal[i] += gauss_noise(gen);
    }
 
    return signal;
}
 
// Создание обучающих данных
void create_training_data(const vector<double>& signal, int window_size,
    vector<vector<double>>& inputs, vector<vector<double>>& targets) {
    for (size_t i = 0; i < signal.size() - window_size; ++i) {
        vector<double> input(window_size);
        vector<double> target(2, 0.0);// [постоянный_пакет, гауссов_пакет]
 
        // Копируем окно сигнала
        copy(signal.begin() + i, signal.begin() + i + window_size, input.begin());
 
        // Анализируем центр окна для определения типа пакета
        double center_val = signal[i + window_size / 2];
       // double avg = accumulate(input.begin(), input.end(), 0.0) / window_size;
        double avg = accumulate(input.begin(), input.end(), 0.0, std::plus<double>()) / window_size;
 
        // Простая эвристика для определения типа пакета
        if (center_val > avg * 1.5 && center_val > 0.3) {
            //Проверяем форму сигнала (постоянный или гауссов)
            double diff = abs(input.back() - input.front());
            if (diff < 0.2 * center_val) {
                target[0] = 1.0; // Постоянный пакет
            }
            else {
                target[1] = 1.0; // Гауссов пакет
            }
        }
 
        inputs.push_back(input);
        targets.push_back(target);
    }
}
// Визуализация результатов
void visualize_results(const vector<double>& signal, const vector<vector<double>>& outputs) {
    ofstream script("visualize.py");
    script << "import matplotlib.pyplot as plt\n";
    script << "import numpy as np\n\n";
 
    // Сигнал
    script << "signal = [";
    for (double x : signal) script << x << ",";
    script << "]\n";
 
    // Выходы сети
    script << "output_constant = [";
    for (const auto& out : outputs) script << out[0] << ",";
    script << "]\n";
 
    script << "output_gaussian = [";
    for (const auto& out : outputs) script << out[1] << ",";
    script << "]\n";
 
    script << "plt.figure(figsize=(12, 8))\n";
    script << "plt.subplot(3, 1, 1)\n";
    script << "plt.plot(signal, label='Original Signal')\n";
    script << "plt.legend()\n";
    script << "plt.subplot(3, 1, 2)\n";
    script << "plt.plot(output_constant, 'r', label='Constant Packet Detection')\n";
    script << "plt.legend()\n";
    script << "plt.subplot(3, 1, 3)\n";
    script << "plt.plot(output_gaussian, 'g', label='Gaussian Packet Detection')\n";
    script << "plt.legend()\n";
    script << "plt.tight_layout()\n";
    script << "plt.savefig('packet_detection.png')\n";
    script << "plt.show()\n";
    script.close();
 
    system("python visualize.py");
}
 
int main() {
    try {
        const int signal_length = 1000;
        const int window_size = 30;
        const int epochs = 500;
        // generation of signal
        vector<double> signal = generate_signal(signal_length);
        cout << "Signal generated. Size: " << signal.size() << endl;
 
        if (signal.size() < window_size) {
            cerr << "Error: signal shorter than window size" << endl;
            return 1;
        }
        // creating the training data
        vector<vector<double>> inputs;
        vector<vector<double>> targets;
        create_training_data(signal, window_size, inputs, targets);
 
        if (inputs.empty()) {
            cerr << "Error: no training data generated" << endl;
            return 1;
        }
 
        // Создание и обучение сети
        KANNetwork network(0.01);
        network.addLayer(window_size, 20);
        network.addLayer(20, 10);
        network.addLayer(10, 2);
 
        cout << "Training network..." << endl;
        network.train(inputs, targets, epochs);
        network.save_loss_history();
 
        // Тестирование на всём сигнале
        vector<vector<double>> outputs;
        for (size_t i = 0; i < signal.size() - window_size; ++i) {
            vector<double> input(window_size);
            //vector<double> input;
 
            if (i + window_size > signal.size()) {
                cerr << "[main] Skipping out-of-range copy at i = " << i << endl;
                continue;
            }
 
            try {
                copy(signal.begin() + i, signal.begin() + i + window_size, input.begin());
            }
            catch (const exception& e) {
                cerr << "[main] Exception during copy: " << e.what() << endl;
                continue;
            }
 
            try {
                outputs.push_back(network.predict(input));
            }
            catch (const exception& e) {
                cerr << "[main] Exception during prediction: " << e.what() << endl;
                continue;
            }
        }
 
        // Визуализация результатов
        visualize_results(signal, outputs);
 
        cout << "Done." << endl;
    }
    catch (const exception& e) {
        cerr << "[Global] Unhandled exception: " << e.what() << endl;
    }
    catch (...) {
        cerr << "[Global] Unknown fatal exception caught." << endl;
    }
 
    return 0;
}

Там ещё сюда, чтобы на 400 не обрывало вывод надо вставить
cout << "Training finished at epoch " << epochs << ", final loss: " << losses_history.back() << endl;
(в функцию train после for).

C++
1
2
3
4
5
6
7
8
        losses_history.push_back(total_loss / inputs.size());
        if (epoch % 100 == 0) {
            cout << "Epoch " << epoch << ", Loss: " << losses_history.back() << endl;
        }
    }
    cout << "Training finished at epoch " << epochs << ", final loss: " << losses_history.back() << endl;
 
}

@SmallEvil · 29.04.2025, 04:02

Сообщение от VAF34

Мне не надо решения, это не повод получить его. Это пример, на котором эксперты могут показать, что они сильнее ИИ. И все.

Так просто спроси у своих ЖоПиТи: "кто умнее, нейросети или люди?"
И всё. И гордо иди гулять.
Зачем кому то никому не нужные, даже тебе, задачи?

Или нужные?

Сообщение от avedeo

и никогда винда не падала

Новые блоги и статьи Все статьи Все блоги /
Мобильное приложение ColorStep pavlinmavlin 17.09.2026 Реализовал приложение Красный, Зеленый, Синий в Unity3d + c#. Название изменил на ColorStep. Приложение прошло модерацию и теперь доступно для скачивания. Делал его сам, шаг за шагом — и вот,. . .	Запрет дублирования строк в табличной части Maks 13.09.2026 Реализация из решения ниже выполнена на нетиповом справочнике "Нормы ТО" с табличной часть "Виды ТО", разработанного в КА2, со следующими реквизитами: - ВидТО (СправочникСсылка. ВидыТО); - ВидГСМ. . .	Скрипты Tampermonkey для CyberForum, ChatGPT, Claude и пр. Jin X 06.09.2026 Скрипты Tampermonkey для CyberForum, ChatGPT, Claude и пр. Работая с форумом и нейросетями в браузере часто хочется что-то подкорректировать или добавить какого-то функционала. Ниже прикреплён. . .	Программа опроса у.з. расходомера SLS-720F Argus19 02.09.2026 Программа опроса у. з. расходомера SLS-720F Программа опрашивает один раз в минуту три ультразвуковых расходомера SLS-720F через интерфейс RS-485 по протоколу Modbus RTU. Опрашиваются регистры. . .
Hyper-V: Компьютер должен поддерживать доверенный платформенный модуль 2.0. Maks 31.08.2026 При установке Windows 11 на виртуальную машину Hyper-V 2-го поколения вылезла такая ошибка: Решение: в параметрах виртуальной машины, в разделе "Безопасность" (Security) активировать флаг. . .	Архитектура биовида Стива в Майнкрафте: Зачем бонобо кубический каннибализм anaschu 30.08.2026 Кубический Вагинокапитализм в Minecraft: Математический инвариант ОДУ и рок Стивов-бонобо Главная задача разработанной «Модели Всего» — наглядно продемонстрировать наличие системной «судьбы». . .	Оттачиваю умение писать js программы. russiannick 30.08.2026 Проектом выходного дня стало написание Книги шифров Виженера. Итогом стала версия 200, синий туман. Синий туман назван так, потому что замораживает текст под собой. Нажатие синих кнопок управляют. . .	мат медиц модель 30. презентация проекта anaschu 27.08.2026 хоп хоп хоп хидахоп, а я кладую))

@VAF34 27 / 63 / 4 Регистрация: 10.06.2023 Сообщений: 1,048
	10.04.2025, 16:55 [ТС]
	Не бейте меня сильно! Решение #include <numeric> Почему его не нашел DeepSeek? 0