neuron.cpp

Go to the documentation of this file.

# include <neuron.h>
# include <network.h>
# include <qgl.h>
# include <qglviewer.h>
# include <inn.h>
# include <interface.h>

using namespace qglviewer ;

extern Inn * inn ;
extern Network * network ;

Neuron::Neuron(int _id) {
   id = _id;
   axonsIn = new list<Axon*>();
   axonsOut = new list<Axon*>();
   frame_ = new ManipulatedFrame() ;
   outValue = 0.0 ;
}

int Neuron::getId() {
        return id;
}

double Neuron::getOutValue() {
        return outValue;
}

double Neuron::getGradientValue() {
        return gradientValue;
}

void Neuron::setOutValue(double v) {
        outValue = v;
}

void Neuron::setGradientValue(double v) {
        gradientValue = v;
}

void Neuron::draw( int selected, const bool names ) {
        if( network->displayneurons() ) {
                Vec position = frame_->position() ;
                position.y = network->getLayerNumTheNeuronIsOn(id) ;
                frame_->setPosition( position ) ;
                glPushMatrix() ;
                        glMultMatrixd(frame_->matrix());      
                        if( names ) glPushName(id);
                                if( selected != id ) glColor4f( 0.0+outValue, 1.0-outValue, 0.0, 0.9 ) ;
                                else glColor4f( 1.0, 0.0, 1.0, 0.8 ) ;
                                glutSolidSphere( network->neuronsize(), network->shininess(), network->shininess() ) ;
                                if( network->displayvalues() ) {
                                        glDisable(GL_LIGHTING) ;
                                        glColor3ub( 200, 200, 200 ) ;
                                        QString value ; value.setNum(outValue, 'f', 3) ;
                                        float x, y, z ;
                                        inn->viewer->camera()->getPosition( x, y, z ) ;
                                        inn->viewer->drawText( network->neuronsize()*-0.5, network->neuronsize()*-0.5, network->neuronsize()*1.20, value, QFont( "Arial", 30/((int)z+1) ) );  
                                        glEnable(GL_LIGHTING) ;
                                }
                        if( names ) glPopName() ;
                glPopMatrix() ;
        }
}

float Neuron::getX( void ) { return frame_->position().x ; }

float Neuron::getY( void ) { return frame_->position().y ; }

float Neuron::getZ( void ) { return frame_->position().z ; }

void Neuron::setX(float x) { 
        Vec position = frame_->position() ;
        position.x = x ;
        frame_->setPosition( position ) ;
}

void Neuron::setY( float y) {
        Vec position = frame_->position() ;
        position.y = y ;
        frame_->setPosition( position ) ;
}

void Neuron::setZ(float z) { 
        Vec position = frame_->position() ;
        position.z = z ;
        frame_->setPosition( position ) ;
}

ManipulatedFrame * Neuron::frame( void ) {
        return frame_ ;
}

void Neuron::addAxonIn(Axon *a) {
        axonsIn->push_back(a);
}

void Neuron::removeAxonIn(int id_ax) {
        bool found = false;
        list<Axon*>::iterator iter = axonsIn->begin();
        while (iter != axonsIn->end() && !found) {
                if((*iter)->getId() == id_ax) found = true;
                if (!found) iter++;
        }
        if (iter != axonsIn->end())
                axonsIn->erase(iter);
}

void Neuron::addAxonOut(Axon *a) {
        axonsOut->push_back(a);
}

void Neuron::removeAxonOut(int id_ax) {
        bool found = false;
        list<Axon*>::iterator iter = axonsOut->begin();
        while (iter != axonsOut->end() && !found) {
                if((*iter)->getId() == id_ax) found = true;
                if (!found) iter++;
        }
        if (iter != axonsOut->end())
                axonsOut->erase(iter);
}

void Neuron::removeAxons() {
        list<Axon*>::iterator iterI, iterO;
        
        for (iterI = axonsIn->begin(); iterI != axonsIn->end(); iterI++) {
                (*iterI)->getNeuronIn()->removeAxonOut((*iterI)->getId());
                network->removeAxon((*iterI)->getId(), false);
        }
        for (iterO = axonsOut->begin(); iterO != axonsOut->end(); iterO++) {
                (*iterO)->getNeuronOut()->removeAxonIn((*iterO)->getId());
                network->removeAxon((*iterO)->getId(), false);
        }
        axonsIn->clear();
        axonsOut->clear();
}

void Neuron::setOutValueTemp(double val) {
        outValueTemp = val;
}

void Neuron::incOutValueTemp(double val) {
        outValueTemp += val;
}

void Neuron::setGradientValueTemp(double val) {
        gradientValueTemp = val;
}

void Neuron::incGradientValueTemp(double val) {
        gradientValueTemp += val;
}

double Neuron::sigmoide(double val) {
        return (1.0 / (1 + exp(-1.0 * network->getK() * val)));
}

double Neuron::sigmoideDerived(double val) {
        //return ((exp(-1.0*val))/((1+exp(-1.0*val))*(1+exp(-1.0*val))));
        return (sigmoide(val) * (1 - sigmoide(val)));
}

void Neuron::computeOutValue() {
        outValue = sigmoide(outValueTemp);
}

void Neuron::computeGradientValue(double err) {
        //gradientValue = 2 * sigmoideDerived(outValueTemp) * err;
        gradientValue = 2 * sigmoideDerived(outValue) * err;
}

void Neuron::forwardPropagation() {
        list<Axon*>::iterator iter;
        for (iter = axonsIn->begin(); iter != axonsIn->end(); iter++)
                (*iter)->forwardPropagation();
        outValue = sigmoide(outValueTemp);
}

void Neuron::gradientBackPropagation() {
        list<Axon*>::iterator iter;
        for (iter = axonsOut->begin(); iter != axonsOut->end(); iter++)
                (*iter)->gradientPropagation();
        //gradientValue = sigmoideDerived(outValueTemp) * gradientValueTemp;
        gradientValue = sigmoideDerived(outValue) * gradientValueTemp;
}

---