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

#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;
}

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); // выход текущего слоя
}
vector<double> output = current;

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);
}

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];
    layers[l].update_weights(input_for_layer, grad, learning_rate);
    
}

double avg = accumulate(input.begin(), input.end(), 0.0, std::plus<double>()) / window_size;