network.cpp

Go to the documentation of this file.

# include <qmessagebox.h>
# include <network.h>
# include <iostream>
# include <list>
# include <learningThread.h>
# include <randomc.h>

extern LearningThread lt;
extern TRandomMersenne *rg ;

using namespace std ;

Network::Network() {
   nextFreeId = 0;
   input = new Layer(nextFreeId);
   nextFreeId++;
   output = new Layer(nextFreeId);
   nextFreeId++;
   hidden = new list<Layer*>();
   axons = new list<Axon*>();
   
   vstep = 1.0 ;
   neursize = 0.1 ;
   axsize = 0.01 ;
   shiny = 32 ;
   
   k = 1.0 ;
   
   displayaxons_ = true ;
   displayneurons_ = true ;
   displaylayers_ = true ;
   displayvalues_ = false ;
   
   errorEvolution = new vector<double>();
   currentAverageError = 0.0;
}

Layer* Network::getInputLayer( void ) { return input ; }

Layer* Network::getOutputLayer( void ) { return output ; }

list<Layer*>* Network::getHiddenLayers( void ) { return hidden ; }

list<Axon*>* Network::getAxons( void ) { return axons ; }

int Network::getNbNeurons( int id_layer ) {
        if (id_layer == input->getId()) { 
                return input->nbNeurons() ;
        } else if (id_layer == output->getId()) { 
                return output->nbNeurons() ; 
        } else {
                for( list<Layer*>::iterator iter = hidden->begin() ; iter != hidden->end() ; iter++ ) {
                        if( (*iter)->getId() == id_layer )
                                return (*iter)->nbNeurons() ;
                }
        }
        return 0 ;
}

int Network::getHiddenLayerId(int i) {
        if ((unsigned int)(i-1) < hiddenLayersId.size() && (i-1) >= 0) return hiddenLayersId[i-1];
        else return -1;
}

int Network::getHiddenLayerPos( int id ) {
        // if the layer does not exist, this function returns -1
        // the first hidden layer has pos equals to 1
        vector<int>::iterator iter;
        int pos = 1 ;
        for (iter = hiddenLayersId.begin(); iter != hiddenLayersId.end(); iter++) {
        if ((*iter) == id) return pos ;
        pos++ ;
        }
        return -1 ;
}

Layer* Network::getLayer(int id_l) {
        if (id_l == input->getId()) return input;
   
        if (id_l == output->getId()) return output;
   
        list<Layer*>::iterator iter;
        for (iter = hidden->begin(); iter != hidden->end(); iter++)
                if ((*iter)->getId() == id_l) return (*iter);
      
        return NULL;
}

Neuron* Network::getNeuronFromId(int id_neur) {
        if (input->existNeuron(id_neur)) return input->getNeuronFromId(id_neur);
   
        else if (output->existNeuron(id_neur)) return output->getNeuronFromId(id_neur);
   
        else {
                list<Layer*>::iterator iter;
                for (iter = hidden->begin(); iter != hidden->end(); iter++)
                        if ((*iter)->existNeuron(id_neur)) return (*iter)->getNeuronFromId(id_neur);
        }
   
        QMessageBox::warning(0, "Warning", "getNeuronFromId : The neuron does not exist...");
        return NULL;
}

int Network::getLayerNumTheNeuronIsOn( int id_neur ) {
        if (input->existNeuron(id_neur)) return 0;
   
        int num = 1 ;
        list<Layer*>::iterator iter;
        for (iter = hidden->begin(); iter != hidden->end(); iter++, num++)
        if ((*iter)->existNeuron(id_neur)) return num ;
   
        if (output->existNeuron(id_neur)) return nbHiddenLayers()+1 ;
   
        return -1 ;
}

int Network::getLayerNumFromLayerId( int id_layer ) {
        if( input->getId() == id_layer ) return 0 ;
        int num = 1 ;
        list<Layer*>::iterator iter;
        for (iter = hidden->begin(); iter != hidden->end(); iter++, num++)
        if ((*iter)->getId() == id_layer ) return num ;
        if (output->getId() == id_layer) return nbHiddenLayers()+1 ;
        return -1 ;
}

float Network::getK() { return k; }

void Network::setK(float _k) { k = _k; }

int Network::getEPS() { return EPS; }

void Network::setEPS(int e) { EPS = e; }

int Network::getCurrentEpoch() { return currentEpoch; }

double Network::getCurrentAverageError() { return currentAverageError; }

vector<double>* Network::getErrorEvolution() { return errorEvolution; }

int Network::shininess( void ) {
        return shiny ;
}

float Network::neuronsize( void ) {
        return neursize ;
}

float Network::axonsize( void ) {
        return axsize ;
}

bool Network::displayaxons(void) {
        return displayaxons_ ;
}

bool Network::displayneurons(void) {
        return displayneurons_ ;
}

bool Network::displaylayers(void) {
        return displaylayers_ ;
}

bool Network::displayvalues(void) {
        return displayvalues_ ;
}

void Network::setDisplayAxons( bool display ) {
        displayaxons_ = display ;
}

void Network::setDisplayNeurons( bool display ) {
        displayneurons_ = display ;
}

void Network::setDisplayLayers( bool display ) {
        displaylayers_ = display ;
}

void Network::setDisplayValues( bool display ) {
        displayvalues_ = display ;
}

float Network::getVStep( void ) {
        return vstep ;
}

ManipulatedFrame * Network::frame( int id ) {
        if( input->frame(id) != NULL ) return input->frame(id) ;
        if( output->frame(id) != NULL ) return output->frame(id) ;
        
        list<Layer*>::iterator iter;
        for (iter = hidden->begin(); iter != hidden->end(); iter++)
        if( (*iter)->frame(id) != NULL ) return (*iter)->frame(id) ;
        
        //QMessageBox::warning(0, "Warning", "network->frame() : pas trouve !!") ;
        
        return NULL ;
}

void Network::setShininess( int shiny ) {
        this->shiny = shiny ;
}

void Network::draw( int selected, const bool names ) {
        list<Layer*>::iterator layeriter;
        input->drawNeurons( selected, names ) ;
        for (layeriter = hidden->begin(); layeriter != hidden->end(); layeriter++)
                (*layeriter)->drawNeurons( selected, names ) ;
        output->drawNeurons( selected, names ) ;
        list<Axon*>::iterator axoniter;
        for (axoniter = axons->begin(); axoniter != axons->end(); axoniter++)
                (*axoniter)->draw( selected, names ) ;
        input->draw( selected, names ) ;
        for (layeriter = hidden->begin(); layeriter != hidden->end(); layeriter++)
                (*layeriter)->draw( selected, names ) ;
        output->draw( selected, names ) ;
}

int Network::nbHiddenLayers() {
        return hidden->size();
}

int Network::nbLayers() {
        return hidden->size() + 2;
}

void Network::addHiddenLayer() {
        Layer *l = new Layer(nextFreeId);
        hiddenLayersId.push_back(nextFreeId);
        nextFreeId++;
        hidden->push_back(l);
}

void Network::addHiddenLayer(int id) {
        Layer *l = new Layer(id);
        hiddenLayersId.push_back(id);
        hidden->push_back(l);
}

void Network::addNHiddenLayers( int n ) {
        for( int i = 0 ; i < n ; i++ )
                addHiddenLayer() ;
}

void Network::removeHiddenLayer(int id_layer) {
        if (existLayer(id_layer)) {
                bool found = false;
                list<Layer*>::iterator iter = hidden->begin();
                while (iter != hidden->end() && !found) {
                        if (id_layer == (*iter)->getId()) found = true;
                        if (!found) iter++;
                }
                (*iter)->removeNeurons();
                hidden->erase(iter);
                delete (*iter);
                found = false;
                vector<int>::iterator iter2 = hiddenLayersId.begin();
                while (iter2 != hiddenLayersId.end() && !found) {
                        if (id_layer == (*iter2)) found = true;
                        if (!found) iter2++;
                }
                hiddenLayersId.erase(iter2);
        }
   //else QMessageBox::warning(0, "Warning", "removeHiddenLayer : The hidden layer does not exist...");
}

void Network::clearLayer(int id_layer) {
        if (id_layer == input->getId()) input->removeNeurons();
   
        else if (id_layer == output->getId()) output->removeNeurons();

        else {
                if (existLayer(id_layer)) {
                        bool found = false;
                        list<Layer*>::iterator iter = hidden->begin();
                        while(iter != hidden->end() && !found) {
                                if (id_layer == (*iter)->getId()) { (*iter)->removeNeurons(); found = true; }
                                if (!found) iter++;
                        }
                }
                else QMessageBox::warning(0, "Warning", "clearLayer : The layer does not exist...");
        }
}

void Network::clearHiddenLayers() {
        list<Layer*>::iterator iter;
        for (iter = hidden->begin(); iter != hidden->end(); iter++)
                clearLayer((*iter)->getId());
        hidden->clear();
        hiddenLayersId.clear();
}

bool Network::existLayer(int id_layer) {
        if (id_layer == input->getId() || id_layer == output->getId()) return true;
   
        list<Layer*>::iterator iter;
        for (iter = hidden->begin(); iter != hidden->end(); iter++)
                if (id_layer == (*iter)->getId()) return true;
   
        return false;
}

void Network::addNeuron(int id_layer) {
        if (id_layer == input->getId()) { input->addNeuron(nextFreeId); nextFreeId++; }
   
        else if (id_layer == output->getId()) { output->addNeuron(nextFreeId); nextFreeId++; }
   
        else {
                if (existLayer(id_layer)) {
                        bool found = false;
                        list<Layer*>::iterator iter = hidden->begin();
                        while(iter != hidden->end() && !found) {
                                if (id_layer == (*iter)->getId()) { (*iter)->addNeuron(nextFreeId); nextFreeId++; found = true; }
                                if (!found) iter++;
                        }
                }
                else QMessageBox::warning(0, "Warning", "addNeuron : The layer does not exist...");
        }
}

void Network::addNeuron(int id_layer, int id, float x, float z) {
        if (id_layer == input->getId()) { input->addNeuron(id, x, z);  }
   
        else if (id_layer == output->getId()) { output->addNeuron(id, x, z); }
   
        else {
                if (existLayer(id_layer)) {
                        bool found = false;
                        list<Layer*>::iterator iter = hidden->begin();
                        while(iter != hidden->end() && !found) {
                                if (id_layer == (*iter)->getId()) { (*iter)->addNeuron(id, x, z); found = true; }
                                if (!found) iter++;
                        }
                }
                else QMessageBox::warning(0, "Warning", "addNeuron : The layer does not exist...");
        }
}

void Network::addNNeurons(int id_layer, int n) {
        for(int i=0; i<n; i++)
                addNeuron(id_layer);
}

void Network::removeNeuron(int id_neur) {
        if (input->existNeuron(id_neur)) input->removeNeuron(id_neur);
   
        else if (output->existNeuron(id_neur)) output->removeNeuron(id_neur);
   
        else {
                list<Layer*>::iterator iter;
                for (iter = hidden->begin(); iter != hidden->end(); iter++)
                        if ((*iter)->existNeuron(id_neur)) { (*iter)->removeNeuron(id_neur); return; }
                QMessageBox::warning(0, "Warning", "removeNeuron : The neuron does not exist...");
        }
}

int Network::nbNeurons( void ) {
        int nb = 0 ;
        nb += input->nbNeurons() ;
        nb += output->nbNeurons() ;
        list<Layer*>::iterator iter;
        for (iter = hidden->begin(); iter != hidden->end(); iter++)
        nb += (*iter)->nbNeurons() ;
    return nb ;
}

bool Network::existNeuron(int id_neur) {
        if (input->existNeuron(id_neur)) return true;
   
        list<Layer*>::iterator iter;
        for (iter = hidden->begin(); iter != hidden->end(); iter++)
                if ((*iter)->existNeuron(id_neur)) return true;
   
        if (output->existNeuron(id_neur)) return true;
   
        return false;
}

int Network::nbAxons( void ) {
        return axons->size() ;
}

void Network::addAxon(int id_neur1, int id_neur2) {
        Neuron *n1 = getNeuronFromId(id_neur1);
        Neuron *n2 = getNeuronFromId(id_neur2);
        if (n1 != NULL && n2 != NULL) {
                Axon *a = new Axon(nextFreeId, n1, n2);
                nextFreeId++;
                n1->addAxonOut(a);
                n2->addAxonIn(a);
                axons->push_back(a);
        }
        else QMessageBox::warning(0, "Warning", "addAxon : One or both of the neurons do not exist...");
}

void Network::addAxon(int id, int id_neur1, int id_neur2) {
        Neuron *n1 = getNeuronFromId(id_neur1);
        Neuron *n2 = getNeuronFromId(id_neur2);
        if (n1 != NULL && n2 != NULL) {
                Axon *a = new Axon(id, n1, n2);
                n1->addAxonOut(a);
                n2->addAxonIn(a);
                axons->push_back(a);
        }
        else QMessageBox::warning(0, "Warning", "addAxon : One or both of the neurons do not exist...");
}

void Network::addAxon(int id, int id_neur1, int id_neur2, double weight) {
        Neuron *n1 = getNeuronFromId(id_neur1);
        Neuron *n2 = getNeuronFromId(id_neur2);
        if (n1 != NULL && n2 != NULL) {
                Axon *a = new Axon(id, n1, n2);
                n1->addAxonOut(a);
                n2->addAxonIn(a);
                a->setWeight(weight) ;
                axons->push_back(a);
        }
        else QMessageBox::warning(0, "Warning", "addAxon : One or both of the neurons do not exist...");
}

// The boolean indicates if we also have to remove the pointers of the connected neurons or not
void Network::removeAxon(int id_ax, bool b) {
        bool found = false;
        list<Axon*>::iterator iter = axons->begin();
        while (iter != axons->end() && !found) {
                if ((*iter)->getId() == id_ax) found = true;
                if (!found) iter++;
        }
        if (iter != axons->end()) {
                if (b) {
                        (*iter)->getNeuronIn()->removeAxonOut(id_ax);
                        (*iter)->getNeuronOut()->removeAxonIn(id_ax);
                }
                axons->erase(iter);
                delete (*iter);
        }
}

void Network::removeAxons() {
        list<Axon*>::iterator iter;
        for (iter = axons->begin(); iter != axons->end(); iter++) {
                (*iter)->getNeuronIn()->removeAxonOut((*iter)->getId());
                (*iter)->getNeuronOut()->removeAxonIn((*iter)->getId());
                delete (*iter);
        }
        axons->clear();
}

bool Network::existAxon( int id_ax ) {
        list<Axon*>::iterator iter;
        for (iter = axons->begin(); iter != axons->end(); iter++)
                if ((*iter)->getId() == id_ax) return true;
        return false;
}

bool Network::existAxon(int id_neur_in, int id_neur_out) {
        list<Axon*>::iterator iter;
        for (iter = axons->begin(); iter != axons->end(); iter++)
                if (((*iter)->getNeuronIn()->getId() == id_neur_in) && ((*iter)->getNeuronOut()->getId() == id_neur_out))
                        return true;
        return false;
}

void Network::resetAllValues() {
        input->resetAllValues();
        output->resetAllValues();
        list<Layer*>::iterator iter;
        for (iter = hidden->begin(); iter != hidden->end(); iter++)
                (*iter)->resetAllValues();
}

void Network::resetTempValues() {
        input->resetTempValues();
        output->resetTempValues();
        list<Layer*>::iterator iter;
        for (iter = hidden->begin(); iter != hidden->end(); iter++)
                (*iter)->resetTempValues();
}

void Network::initLayerIn(vector<double> in) {
        int i = 0;
        list<Neuron*>::iterator iter;
        for (iter = input->getNeurons()->begin(); iter != input->getNeurons()->end(); iter++) {
                (*iter)->setOutValue(in[i]);
                /*
                (*iter)->setOutValueTemp(in[i]);
                (*iter)->computeOutValue();
                */
                i++;
        }
}

void Network::forwardPropagation() {
        list<Layer*>::iterator iter;
        for (iter = hidden->begin(); iter != hidden->end(); iter++)
                (*iter)->forwardPropagation();
        output->forwardPropagation();
}

vector<double>* Network::getOutValues() {
        vector<double> *computed = new vector<double>();
        list<Neuron*>::iterator iter;
        for (iter = output->getNeurons()->begin(); iter != output->getNeurons()->end(); iter++)
                computed->push_back((*iter)->getOutValue());
        return computed;
}

vector<double>* Network::computeOut(vector<double> *in) {
        resetTempValues();
        initLayerIn(*in);
        forwardPropagation();
        vector<double> *computed = getOutValues();
        return computed;
}

double Network::computeErrorRate(vector<double> *errors) {
        double sum = 0.0;
        double err;
        vector<double>::iterator iter;
        for (iter = errors->begin(); iter != errors->end(); iter++){
                if ((*iter) < 0) err = -1 * (*iter);
                else err = (*iter);
                sum += err;
                /*
                err = (*iter);
                sum += err * err;
                */
        }
        sum = sum / errors->size();
        return sum;
}

vector<double>* Network::computeErrors(vector<double> *computed, vector<double> *expected) {
        vector<double> *errors = new vector<double>();
        vector<double>::iterator iterC = computed->begin();
        vector<double>::iterator iterE = expected->begin();
        while (iterC != computed->end()) {
                errors->push_back( (*iterE) - (*iterC) );
                iterE++;
                iterC++;
        }
        return errors;
}

void Network::initLayerOutGradient(vector<double> *errors) {
        vector<double>::iterator iterE = errors->begin();
        list<Neuron*>::iterator iter;
        for (iter = output->getNeurons()->begin(); iter != output->getNeurons()->end(); iter++) {
                (*iter)->computeGradientValue((*iterE));
                iterE++;
        }
}

void Network::gradientBackPropagation(vector<double> *errors) {
        initLayerOutGradient(errors);
        list<Layer*>::iterator iterL;
        for (iterL = hidden->end() ; iterL != hidden->begin(); ) {
                iterL--;
                (*iterL)->gradientBackPropagation();
        }
        input->gradientBackPropagation();
}

void Network::changeAxonsWeight(double convergenceCoeff) {
        list<Axon*>::iterator iter;
        for (iter = axons->begin(); iter != axons->end(); iter++)
                (*iter)->changeWeight(convergenceCoeff);
}

double Network::learnExample(vector<double> *exampleIn, vector<double> *exampleOut, double convergenceCoeff) {
        vector<double> *computedOut = computeOut(exampleIn);
        vector<double> *errors = computeErrors(computedOut, exampleOut);
        double errorRate = computeErrorRate(errors);
        gradientBackPropagation(errors);
        changeAxonsWeight(convergenceCoeff);

        return errorRate;
}

double Network::computeAverage(vector<double> v) {
        double av = 0.0;
        vector<double>::iterator iter;
        for (iter = v.begin(); iter != v.end(); iter++)
                av += (*iter);
        av = av / v.size();
        return av;
}

list< vector<double> >* Network::readExampleFile(QTextStream *file, QString mode) {
        int begin = 0, end = 0;
        int nbIn = input->nbNeurons(), nbOut = output->nbNeurons();
        if (mode == "in") { begin = 0; end = nbIn; }
        else if (mode == "out") { begin = nbIn; end = nbIn + nbOut; }
        list< vector<double> > *examplesList = new list< vector<double> >();
        QString str = file->readLine();
        while (str != NULL) {
                vector<double> example;
                for (int i = begin; i < end; i++)
                        example.push_back(str.section(';', i, i).toDouble());
                examplesList->push_back(example);
                str = file->readLine();
        }
        return examplesList;
}

vector<double> Network::readTestFile(QTextStream *file) {
        int nbIn = input->nbNeurons();
        vector<double> example ;
        QString str = file->readLine();
        for (int i = 0; i < nbIn; i++)
                example.push_back(str.section(';', i, i).toDouble());
        return example;
}

void Network::link2Layers(Layer *first, Layer *second) {
        list<Neuron*>::iterator iterNF, iterNS;
        for (iterNF = first->getNeurons()->begin(); iterNF != first->getNeurons()->end(); iterNF++)
                for (iterNS = second->getNeurons()->begin(); iterNS != second->getNeurons()->end(); iterNS++)
                        addAxon((*iterNF)->getId(), (*iterNS)->getId());
}

void Network::constructTopologyMLP() {
        if (nbHiddenLayers() == 0)
                link2Layers(input, output);
        else {
                link2Layers(input, hidden->front());
                list<Layer*>::iterator iterHL = hidden->begin();
                while ((*iterHL) != hidden->back()) {
                        Layer *temp = (*iterHL);
                        iterHL++;
                        link2Layers(temp, (*iterHL));
                }
                link2Layers(hidden->back(), output);
        }
}

void Network::constructTopologyCC() {
        if (nbHiddenLayers() == 0)
                link2Layers(input, output);
        else {
                //link2Layers(input, hidden->front());
                list<Layer*>::iterator iterHL;
                for (iterHL = hidden->begin(); iterHL != hidden->end(); iterHL++) {
                        link2Layers(input, (*iterHL));
                }
                link2Layers(input, output);
                iterHL = hidden->begin();
                list<Layer*>::iterator iterHL2 = hidden->begin();
                while ((*iterHL) != hidden->back()) {
                        iterHL++; iterHL2 = iterHL; iterHL--;
                        for ( ; iterHL2 != hidden->end(); iterHL2++) {
                                link2Layers((*iterHL), (*iterHL2));
                        }
                        iterHL++;
                        link2Layers((*iterHL), output);
                }
                link2Layers(hidden->back(), output);
        }
}

void Network::clearErrorEvolution() {
        errorEvolution->clear();
}

void Network::setExampleOrder(int o) {
        exampleOrder = o;
}

void Network::learning(QString filename, double errorThreshold, int maxNbEpoch, double convergenceCoeff) {      
        QFile *file;
        QTextStream *filetext;
        file = new QFile(filename);
        if ( !file->open( IO_ReadOnly ) ) {
                QMessageBox::warning(0, "Warning", "The specified file cannot be opened...");
                return;
        }
    filetext = new QTextStream(file);
        list< vector<double> > *exampleInList = readExampleFile(filetext, "in");
        file->close();
        delete file;
        file = new QFile(filename);
        if ( !file->open( IO_ReadOnly ) ) return;
        delete filetext;
    filetext = new QTextStream(file);
        list< vector<double> > *exampleOutList = readExampleFile(filetext, "out");
        
        list< vector<double> >::iterator iterIn, iterOut;
        vector<double> errors;
        double error, averageError = 1.0;
        currentEpoch = 1;
        
        while ((averageError > errorThreshold) && (currentEpoch <= maxNbEpoch)) {
                if (exampleOrder == SEQUENTIAL) {
                        for (iterIn = exampleInList->begin(), iterOut = exampleOutList->begin();
                                                                iterIn != exampleInList->end(); iterIn++, iterOut++) {
                                error = learnExample(&(*iterIn), &(*iterOut), convergenceCoeff);
                                errors.push_back(error);
                                if (EPS < 100 || lt.getState() != PLAY) {
                                        if (lt.getState() == STEP) lt.setState(PAUSE);
                                        lt.uwait(1000000 / EPS);
                                }
                        }
                } else if (exampleOrder == RANDOM_WITH) {
                        int card = exampleInList->size() ;
                        int i = 0 ;
                        while(i<card) {
                                int r = rg->IRandom(0, exampleInList->size()-1);
                                iterIn = exampleInList->begin();
                                iterOut = exampleOutList->begin();
                                for (int k=0; k<r; k++) { iterIn++; iterOut++; }
                                error = learnExample(&(*iterIn), &(*iterOut), convergenceCoeff);
                                errors.push_back(error);
                                if (EPS < 100 || lt.getState() != PLAY) {
                                        if (lt.getState() == STEP) lt.setState(PAUSE);
                                        lt.uwait(1000000 / EPS);
                                }
                                i++;
                        }
                } else if (exampleOrder == RANDOM_WITHOUT) {
                        list< vector<double> > *exampleInListCopy = copyVectorList(exampleInList);
                        list< vector<double> > *exampleOutListCopy = copyVectorList(exampleOutList);
                        while (exampleInListCopy->size() > 0) {
                                int r = rg->IRandom(0, exampleInListCopy->size()-1);
                                iterIn = exampleInListCopy->begin();
                                iterOut = exampleOutListCopy->begin();
                                for (int k=0; k<r; k++) { iterIn++; iterOut++; }
                                error = learnExample(&(*iterIn), &(*iterOut), convergenceCoeff);
                                exampleInListCopy->erase(iterIn);
                                exampleOutListCopy->erase(iterOut);
                                errors.push_back(error);
                                if (EPS < 100 || lt.getState() != PLAY) {
                                        if (lt.getState() == STEP) lt.setState(PAUSE);
                                        lt.uwait(1000000 / EPS);
                                }
                        }
                }
                
                averageError = computeAverage(errors);
                errors.clear();
                errorEvolution->push_back(averageError);
                currentAverageError = averageError;
                currentEpoch++;
        }
}

list< vector<double> >* Network::copyVectorList(list< vector<double> > *vl) {
        list< vector<double> > *copy = new list< vector<double> >();
        list< vector<double> >::iterator iter;
        for (iter = vl->begin(); iter != vl->end(); iter++) {
                vector<double> vec;
                for (unsigned int i=0; i<(*iter).size(); i++)
                        vec.push_back((*iter)[i]);
                copy->push_back(vec);
        }
        return copy;
}

void Network::description() {
        cout << "Input Layer :" << endl;
        input->description();
        cout << "Hidden Layers (" << hidden->size() << ") :" << endl;
        list<Layer*>::iterator iter;
        for (iter = hidden->begin(); iter != hidden->end(); iter++)
                (*iter)->description();
        cout << "Output Layer :" << endl;
        output->description();
}

---