A+B AI 模型版

原版是我自己写的，这是 AI 改写的 C++ 版。经实验及提问，C++ 版训练效果更佳。

#include<bits/stdc++.h>
#define rep(i,a,b) for(auto i=a;i<b;++i)
using namespace std;

constexpr auto ReLU(double x){
    return max(0.0,x);
}

constexpr auto d_ReLU(double x){
    return x>0;
}

constexpr auto loss(double res,double ans){
    return (res-ans)*(res-ans);
}

constexpr auto d_loss(double res,double ans){
    return (res-ans)*2;
}

static constexpr auto learningRate=0.001;

template<const int dir>
class stage{
private:
    array<double,dir> w;
    double b;
public:
    auto f(array<double,dir> x){
        auto res=0.0;
        rep(i,0,dir) res+=w[i]*x[i];
        return res+b;
    }

    auto update(array<double,dir> x,double d_loss){
        rep(i,0,dir){
            w[i]-=learningRate*d_loss*x[i];
        }
        b-=learningRate*d_loss;
    }

    auto give_loss(double d_loss){
        array<double,dir> x;
        rep(i,0,dir) x[i]=d_loss*w[i];
        return x;
    }

    stage(array<double,dir> _w,double _b):w(_w),b(_b){}
};

class model{
private:
    stage<2> a0,a1,a2,a3;
    stage<4> b0;
public:
    auto calc(double a,double b){
        const auto v0=ReLU(a0.f({a,b}));
        const auto v1=ReLU(a1.f({a,b}));
        const auto v2=ReLU(a2.f({a,b}));
        const auto v3=ReLU(a3.f({a,b}));
        const auto res=b0.f({v0,v1,v2,v3});
        return res;
    }

    auto train(double a,double b,double ans){
        const auto v0=ReLU(a0.f({a,b}));
        const auto v1=ReLU(a1.f({a,b}));
        const auto v2=ReLU(a2.f({a,b}));
        const auto v3=ReLU(a3.f({a,b}));
        const auto res=b0.f({v0,v1,v2,v3});
        const auto u_d_loss=d_loss(res,ans);
        const auto vx=b0.give_loss(u_d_loss);
        b0.update({v0,v1,v2,v3},u_d_loss);
        a0.update({a,b},vx[0]*d_ReLU(v0));
        a1.update({a,b},vx[1]*d_ReLU(v1));
        a2.update({a,b},vx[2]*d_ReLU(v2));
        a3.update({a,b},vx[3]*d_ReLU(v3));
    }

    model(uniform_real_distribution<double> rng,mt19937 eng):
        a0({rng(eng),rng(eng)},rng(eng)),
        a1({rng(eng),rng(eng)},rng(eng)),
        a2({rng(eng),rng(eng)},rng(eng)),
        a3({rng(eng),rng(eng)},rng(eng)),
        b0({rng(eng),rng(eng),rng(eng),rng(eng)},rng(eng)){
    }
};

auto getModel(uint32_t _seed=251,const int T=800000){
    mt19937 eng(_seed);
    uniform_real_distribution<double> rng(-5.0,5.0);
    uniform_real_distribution<double> data_rng(-5.0,5.0);
    auto res=model(rng,eng);
    rep(i,0,T){
        const auto a=data_rng(eng);
        const auto b=data_rng(eng);
        res.train(a,b,a+b);
    }
    return res;
}

int main(){
    ios::sync_with_stdio(false),cin.tie(nullptr);
    int a,b;cin>>a>>b;
    auto calc=getModel();
    cout<<(int)(round(calc.calc(a,b)))<<'\n';
    return 0;
}