线性神经网络的实现C++

线性神经网络实现或运算

#include<iostream>
#include<stdlib.h>
#include<math.h>
using namespace std;
#define innode 2
#define outnode 1
#define sample 4
class linerAnn
{
public:
    linerAnn();
    ~linerAnn();
    double w[outnode][innode];
    double b[outnode];
    void init();
    void train(double p[sample][innode], double t[sample][outnode]);
    void pattern(double *p);
    double randval(double low, double high);
    void initval(double w[], int n);
    double lr;
    double E;
    double error;
};
double linerAnn::randval(double low, double high)
{
    double val;
    val = ((double)rand()/ (double)RAND_MAX) + (high - low) + low;
    return val;
}
void linerAnn::initval(double w[], int n)
{
    for (int i = 0; i < n; i++)
    {
        w[i] = randval(-0.01, 0.01);
    }
}
void linerAnn::init()
{
    initval((double*)w, innode*outnode);
    initval(b, outnode);
}
void linerAnn::train(double p[sample][innode], double t[sample][outnode])
{
    double err[outnode];
    double nodesum[outnode];
    double nodeout[outnode];
    double x[innode];
    double d[outnode];
    for (int i = 0; i < sample; i++)
    {
        for (int j = 0; j < innode; j++)
        {
            x[j] = p[i][j];
        }
        for (int k = 0; k < outnode;k++)
        {
            d[k] = t[i][k];
        }
        for (int k = 0; k < outnode; k++)
        {
            nodesum[k] = 0.0;
            for (int j = 0; j < innode; j++)
            {
                nodesum[k] += w[k][j] * x[j];
            }
            nodeout[k] = nodesum[k] + b[k];
        }
        for (int k = 0; k < outnode;k++)
        {
            err[k] = (d[k] - nodeout[k]);
            for (int j = 0; j < innode; j++)
            {
                w[j][k] += lr*err[k] * x[j];
            }
        }
        for (int k = 0; k < outnode; k++)
        {
            E += pow(d[k] - nodeout[k],2);
        }
        error = E / 2;
        for (int k = 0; k < outnode; k++)
        {
            b[k] += lr*err[k];
        }

    }
}
void linerAnn::pattern(double* p)
{
    double nodesum[outnode];
    double nodeout[outnode];
    double x[innode];
    for (int i = 0; i < innode; i++)
    {
        x[i] = p[i];
    }
    for (int k = 0; k < outnode; k++)
    {
        nodesum[k] = 0.0;
        for (int j = 0; j < innode; j++)
        {
            nodesum[k] += w[k][j] * x[j];
        }
        
        nodeout[k] = nodesum[k] + b[k];
        
    }
    for (int i = 0; i < outnode; i++)
    {
        cout << int(floor(nodeout[i] + 0.5)) << endl;
    }
}

linerAnn::linerAnn()
{
    lr = 0.01;
    E = 0.0;
    error = 1.0;
}
linerAnn::~linerAnn()
{

}


double X[sample][innode] = {
    {0,0},
    {0,1},
    {1,0},
    {1,1}
};
double Y[sample][outnode]=
{
    {0},
    {1},
    {1},
    {1}
};
int main()
{
    linerAnn linerann;
    linerann.init();
    int times = 0;
    while (linerann.error > 0.001&&times < 10000)
    {
        times++;
        linerann.train(X, Y);
    }
    double m[innode] = { 1,0 };
    linerann.pattern(m);
    return 0;

}