reverse

#pragma hdrstop
#pragma argsused

#ifdef _WIN32
#include <tchar.h>
#else
  typedef char _TCHAR;
  #define _tmain main
#endif

#include <algorithm>
#include <stdio.h>
#include <math.h>
#include <iostream>

const double E = 2.71828182845904523536;

using std::cin;
using std::cout;
using std::endl;

    double training_set_inputs[4][3];
    double training_set_outputs[4];
    double SynapticWeight[4], new_situation[3];
    double i,j,l, Output5, DOToutput5;
    double Boutput[5], BsigmoidPart[5], Bsigmoid_DerivativePart[5], BerrorPart[5], BadjustmentPart[5], BadjustSynapticWeight[4];
    int q,m;
    double output;


 int _tmain(int argc, _TCHAR* argv[])
{   srand (time(NULL));

    training_set_inputs[0][0]=3000;training_set_inputs[0][1]=2000;training_set_inputs[0][2]=1000;
    training_set_inputs[1][0]=7500;training_set_inputs[1][1]=8000;training_set_inputs[1][2]=8000;
    training_set_inputs[2][0]=5500;training_set_inputs[2][1]=6700;training_set_inputs[2][2]=4300;
    training_set_inputs[3][0]=3300;training_set_inputs[3][1]=4215;training_set_inputs[3][2]=7178;

    training_set_outputs[0]=6000;
    training_set_outputs[1]=23500;
    training_set_outputs[2]=16500;
    training_set_outputs[3]=14693;


    //yes needs a function to convert, will do later.
    training_set_inputs[0][0]=  1/(1 + exp(-(1/training_set_inputs[0][0])));
    training_set_inputs[0][1]=  1/(1 + exp(-(1/training_set_inputs[0][1])));
    training_set_inputs[0][2]=  1/(1 + exp(-(1/training_set_inputs[0][2])));

    training_set_inputs[1][0]= 1/(1 + exp(-(1/training_set_inputs[1][0])));
    training_set_inputs[1][1]= 1/(1 + exp(-(1/training_set_inputs[1][1])));
    training_set_inputs[1][2]= 1/(1 + exp(-(1/training_set_inputs[1][2])));

    training_set_inputs[2][0]= 1/(1 + exp(-(1/training_set_inputs[2][0])));
    training_set_inputs[2][1]= 1/(1 + exp(-(1/training_set_inputs[2][1])));
    training_set_inputs[2][2]= 1/(1 + exp(-(1/training_set_inputs[2][2])));

    training_set_inputs[3][0]=  1/(1 + exp(-(1/training_set_inputs[3][0])));
    training_set_inputs[3][1]=  1/(1 + exp(-(1/training_set_inputs[3][1])));
    training_set_inputs[3][2]=  1/(1 + exp(-(1/training_set_inputs[3][2])));

    training_set_outputs[0]= 1/(1 + exp(-(1/training_set_outputs[0])));
    training_set_outputs[1]= 1/(1 + exp(-(1/training_set_outputs[1])));
    training_set_outputs[2]= 1/(1 + exp(-(1/training_set_outputs[2])));
    training_set_outputs[3]= 1/(1 + exp(-(1/training_set_outputs[3])));

    //printf("\n waarden  %.14f %.14f %.14f",  training_set_inputs[0][0], training_set_inputs[0][1], training_set_inputs[0][2]);




    for (m = 1; m < 21; m++) {


    SynapticWeight[1]=rand() % 2000/double(1000)-double(1);
    SynapticWeight[2]=rand() % 2000/double(1000)-double(1);
    SynapticWeight[3]=rand() % 2000/double(1000)-double(1);

    //printf("\n waarden  %.14f %.14f %.14f",  SynapticWeight[1], SynapticWeight[2], SynapticWeight[3]);


    for( i = 1; i <= 200000000; i++ ){

        for( q = 1; q <= 4; q++) {

        Boutput[q] = training_set_inputs[q-1][0]*SynapticWeight[1]+training_set_inputs[q-1][1]*SynapticWeight[2]+training_set_inputs[q-1][2]*SynapticWeight[3];

        BsigmoidPart[q] = 1 / (1 + exp(-(Boutput[q])));

        Bsigmoid_DerivativePart[q] = BsigmoidPart[q] * (1 - BsigmoidPart[q]);

        BerrorPart[q] = (training_set_outputs[q-1] - BsigmoidPart[q]);

        BadjustmentPart[q] =  BerrorPart[q] * Bsigmoid_DerivativePart[q];

        }


        for( q = 1; q <= 3; q++) {

        BadjustSynapticWeight[q] = training_set_inputs[0][q-1]*BadjustmentPart[1]+training_set_inputs[1][q-1]*BadjustmentPart[2]+training_set_inputs[2][q-1]*BadjustmentPart[3]+training_set_inputs[3][q-1]*BadjustmentPart[4];

        SynapticWeight[q]=SynapticWeight[q]+BadjustSynapticWeight[q];

        }


       //printf("\nTEST %.14f %.14f %.14f ADJUSTMENTS %.14f %.14f %.14f", SynapticWeight[1], SynapticWeight[2], SynapticWeight[3], BadjustSynapticWeight[1], BadjustSynapticWeight[2], BadjustSynapticWeight[3]);
    }

    //new_situation[0]=28;new_situation[1]=40;new_situation[2]=44; //outcome should be 68, it reaches 84,5
    new_situation[0]=4000;new_situation[1]=4200;new_situation[2]=1000; //outcome should be 9200, it reaches 8000



    //yes needs a function to convert, will do later.
    new_situation[0]= 1/(1 + exp(-(1/new_situation[0])));
    new_situation[1]= 1/(1 + exp(-(1/new_situation[1])));
    new_situation[2]= 1/(1 + exp(-(1/new_situation[2])));

    Output5=new_situation[0]*SynapticWeight[1]+new_situation[1]*SynapticWeight[2]+new_situation[2]*SynapticWeight[3];

    DOToutput5 = 1 / (1 + exp(-(Output5)));

    //yes needs a function to convert back, will do later.
    output = 1 / DOToutput5;
    output = output - 1;
    output = log10(E)/log10(output);
    output = -output;

    printf("\n Attempt nr %d gave as output %.2f       (the real answer should be 9200)\n", m, output);
    } //m



    cout << "Press enter to exit..." << endl;
    cin.get();





    return 0;
}

// python and c++
// ref:   medium.com/technology-invention-and-more/how-to-build-a-simple-neural-network-in-9-lines-of-python-code-cc8f23647ca1
// A.I. / Neural Network crude example






//  0,502957 = 1/(1 + exp(-x))

//  1/x
//  1,9882 = (1 + exp(-x))
//  -1
//  0.9882 = exp(-x)

//  -x = log(e)/log0.9882

//  -82.24

//  x=84.24