axon.cpp

Go to the documentation of this file.

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

using namespace qglviewer ;

extern Network * network ;
extern Inn * inn ;
extern TRandomMersenne *rg ;

Axon::Axon(int _id, Neuron *_in, Neuron *_out) {
        id = _id;
        in = _in;
        out = _out;
        
        float value = rg->Random();
        value /= 10.0 ;
        int sign = rg->IRandom(0, 10) ;
        if( sign>5 ) value *= -1 ;
        weight = value ;
        lastWeight = 0.0 ;
        
        frame_ = new ManipulatedFrame() ;
}

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


double Axon::getWeight(void) { return weight ; }
void Axon::setWeight( double weight ) { this->weight = weight ; }

Neuron* Axon::getNeuronIn() {
        return in;
}

Neuron* Axon::getNeuronOut() {
        return out;
}

void Axon::draw(int selected, const bool names) {
        if(network->displayaxons()) {
                float v = (1.0 / (1 + exp(-1.0 * weight)));
                if( selected != id ) glColor4f( 1.0, 1.0-v, 0.0, 0.4 ) ;
                else glColor4f( 1.0, 0.0, 1.0, 0.5 ) ;
                frame_->setPosition( in->frame()->position() ) ;  
                drawAxon( in->frame()->position(), out->frame()->position(), names ) ;
        }
}

void Axon::drawAxon( Vec from, Vec to, const bool names ) {
        if( names ) glPushName(id);
                glPushMatrix() ; 
                        glLineWidth( 1.5 ) ;
                        glDisable(GL_LIGHTING) ;
                        glBegin(GL_LINES) ;
                                glVertex3f( from.x, from.y, from.z ) ;
                                glVertex3f( to.x, to.y, to.z ) ;
                        glEnd() ;
                        if( network->displayvalues() ) {
                                float midx, midy, midz ;
                                midx = (from.x+to.x)/2 ;
                                midy = (from.y+to.y)/2 ;
                                midz = (from.z+to.z)/2 - 1.5*network->neuronsize() ;
                                glColor3ub( 200, 200, 200 ) ;
                                QString value ; value.setNum(weight, 'f', 3) ;
                                float x, y, z ;
                                inn->viewer->camera()->getPosition( x, y, z ) ;
                                inn->viewer->drawText( midx, midy, midz, value, QFont( "Arial", 30/((int)z+1) ) );  
                        }
                        glEnable(GL_LIGHTING) ;
                glPopMatrix() ;
        if( names ) glPopName() ;
}

void Axon::forwardPropagation() {
        out->incOutValueTemp(in->getOutValue() * weight);
}

void Axon::gradientPropagation() {
        in->incGradientValueTemp(out->getGradientValue() * weight);     
}

void Axon::changeWeight(double convergenceCoeff) {
        weight += convergenceCoeff * in->getOutValue() * out->getGradientValue();
        //weight += convergenceCoeff * in->getOutValue() * out->getGradientValue() + 0.9 * lastWeight;
        //lastWeight = convergenceCoeff * in->getOutValue() * out->getGradientValue();
}

float Axon::rad2deg( float rad ) {
    return rad*(180/3.14159) ;
}

float Axon::deg2rad( float deg ) {
    return deg*( 3.14159/180 ) ;
}

---