nettest2.cpp

Go to the documentation of this file.

#include "NeuralNetwork.h"
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <iterator>
#include <cmath>
#include <fstream>
#include "UniformRNG.h"
using namespace std;

int main()
{
        UniformRNG Random;
        NeuralNetwork::ttypeVector typeVector;
        NeuralNetwork::ttypeArray typeArray;
                
        const int seglength = 5;
        const double maxinit = 0.1;
        const int maxit = 5000;
        const int hlayers = 1;
        const int deslength = 1;
        const double mu = 0.1;
        const double alpha = 0.1;
        const double period = 35.2;
        const double PI = acos(-1.0);
        const double noiselevel = 0.2;
        gplib::rvec input(seglength), desired(deslength), output(deslength);
        vector<double> filedes, fileout;;
        
        typeVector.assign(seglength,SigmoidalNeuron::bipolar);
        for (int i = 0; i < hlayers; ++i)
        {
                typeArray.push_back(typeVector);
        }
        typeVector.assign(1,SigmoidalNeuron::identity);
        typeArray.push_back(typeVector);
        
        NeuralNetwork Network(seglength,deslength);
        Network.SetLayers(typeArray);
        Network.InitWeights(maxinit,maxinit);
        Network.SetMu(mu);
        Network.SetAlpha(alpha);
        std::cout << std::endl;
        std::cout << "Weights: " << std::endl;
        Network.PrintWeights(std::cout);
        std::cout << std::endl;
        for (int iterations = 0; iterations < maxit; ++iterations)
        {
                for (int i = 0; i < seglength; ++i)
                        input(i) =sin( 2.0 * PI * (i+iterations)/period);
        
                for (int i = 0; i < deslength; ++i)
                        desired(i) = 2.0*cos( 2.0 * PI * (iterations+i)/period)+Random.GetNumber(-noiselevel,noiselevel);
                //std::cout << "Input: ";
                //std::copy(input.begin(),input.end(),ostream_iterator<double>(cout," "));
                //std::cout << std::endl;
                Network.CalcOutput(input,output);
                if (iterations < maxit/2)
                        Network.AdaptFilter(input,desired);
                //std::copy(output.begin(),output.end(),ostream_iterator<double>(cout," "));
                //cout << desired.at(0) << " " << output.at(0) << endl;
                filedes.push_back(desired(0));
                fileout.push_back(output(0));
                /*std::cout << std::endl;
                std::cout << "Weights: " << std::endl;
                Network.WriteWeights(std::cout);
                std::cout << std::endl;*/
        }
        std::cout << std::endl;
        std::cout << "Weights: " << std::endl;
        Network.PrintWeights(std::cout);
        std::cout << std::endl;
        ofstream outdes("des.out");
        copy(filedes.begin(),filedes.end(),ostream_iterator<double>(outdes,"\n"));
        ofstream outout("out.out");
        copy(fileout.begin(),fileout.end(),ostream_iterator<double>(outout,"\n"));
}

---