seismicnet.cpp

Go to the documentation of this file.

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

int main()
{
        // first some global constants that can be changed to play with
        const int seglength = 3; // the length of the segment we want to work on
        const double maxinit = 0.01; // the maximum the neuron weights are initialized to
        const double maxbias = 0.01; // the maximum bias for each neuron
        const int hiddenlayers = 2; // the number of hiddenlayers
        const double mu = 0.1; // the stepsize for weight adaptation for each neuron;
        const int noiseseglength = 70000;
        const int plotintervall = 200;
        const double noisepower = 10;
        int currentindex = 0;
        ttypeVector typeVector; // a vector that contains the type for each neuron in a layer
        ttypeArray typeArray; // an array of typevectors that contains the neuron type for the whole network;
        ifstream datafile, noisefile; // the file objects for the two inputfiles: the noise time series and the reference 
        ofstream outputfile,epsfile,weightfile; // the file objects for the two outputfiles: the cleaned file and the difference to the original
        UniformRNG Random;
        
        double currentinput, currentref; // the current input and reference values we're working on
        
        string datafilename, noisefilename; // the strings containing the filenames 
        string outputfilename, epsfilename, weightfilename;
        
        
        //cout << "Datafile:";
        //cin >> datafilename; // read in reference filename
        cout << "Datafile:";
        cin >> noisefilename; 
        outputfilename = noisefilename+".clean"; // set outputfilename for clean file
        epsfilename = noisefilename+".eps"; // and for difference file
        weightfilename = noisefilename+".weight";
        noisefile.open(noisefilename.c_str()); // reading
        //datafile.open(datafilename.c_str()); // reading
        epsfile.open(epsfilename.c_str()); // writing
        weightfile.open(weightfilename.c_str()); 
        outputfile.open(outputfilename.c_str()); // writing
        
        typeVector.assign(seglength,bipolar); // we want seglength number of bipolar neurons per hidden layer 
        for (int i = 0; i < hiddenlayers; ++i) //intialize the type array for the hidden layers
        {
                typeArray.push_back(typeVector); // all layers are the same, so we copy the same vector there
        }
        typeVector.assign(1,identity); 
        typeArray.push_back(typeVector); // and then we add it to the type Array
        
        NeuralNetwork Network; //We declare a new variable for the network
        Network.Input.assign(seglength,0); // We have to allocate memory for the network input and set it to zero
        Network.SetLayers(typeArray); // We use the type array we created before to setup the neurons in the Network
        Network.InitWeights(maxinit,maxbias); // The Weights are initialized with the two maximum values
        Network.mu = mu; // The mu value is copied to the network properties
        for (int i = 0; i < seglength; ++i)  // We read in the first segment of data
        {
                noisefile >> currentinput;
                epsfile << currentinput;
                Network.Input.at(i) = currentinput; // copy same value to Network input vector  
        }
        //datafile >> currentref; // read from file into variable
        Network.Desired.at(0) =  (0.5 - Random.GetNumber())*2 * noisepower;
        currentindex = seglength;
        Network.CalcOutput(); // We calculate the output for the first segment 
        Network.AdaptWeights(); // and adapt the weights
        // this is done outside the first loop, because we don't want to output this value
        
        while (noisefile.good() )
        {
                //datafile >> currentref; // read in a new input value 
                noisefile >> currentinput;
                for (int i = 0; i < typeArray.size(); ++i)
                {
                        cout << "Layer: " << i << endl;
                        for (int j = 0; j < typeArray.at(i).size(); ++j)
                        {
                                cout << "Neuron: " << j << endl;
                                cout << "Delta: " << Network.Layers.at(i).at(j)->Delta << endl;
                                cout << "Net: " << Network.Layers.at(i).at(j)->Net << endl;
                                cout << "Output: " << Network.Layers.at(i).at(j)->Output << endl;
                        }
                        cout << endl;
                }
                if (noisefile.good())
                {
                        if ( !(currentindex % plotintervall))
                                Network.WriteWeights(weightfile);
                        rotate(Network.Input.begin(),Network.Input.begin()+1,Network.Input.end()); // shift all elements so that the second becomes the first
                        Network.Input.back() = currentinput; // and copy the new values to the last position
                        Network.Desired.back() =  (0.5 - Random.GetNumber())*2 * noisepower; // currentref; // again set the reference
                        Network.CalcOutput(); // and calculate output 
                        if (currentindex < noiseseglength)
                                Network.AdaptWeights(); // and adapt weights
                        outputfile << Network.Output.at(0) <<endl ; // finally write calculated output to file
                        //epsfile << (Network.Desired.at(0) - Network.Output.at(0)) << endl; // calculated difference and write to file as well
                        epsfile << (currentinput - Network.Desired.at(0)) << endl;
                        currentindex++;
                }
        }
        
        noisefile.close();
        datafile.close();
        outputfile.close();
        epsfile.close();
        weightfile.close();
}