include/liboutputfunctions.h

Go to the documentation of this file.

/********************************************************************************
 *  Neural Network Framework.                                                   *
 *  Copyright (C) 2005-2008 Gianluca Massera <emmegian@yahoo.it>                *
 *                                                                              *
 *  This program is free software; you can redistribute it and/or modify        *
 *  it under the terms of the GNU General Public License as published by        *
 *  the Free Software Foundation; either version 2 of the License, or           *
 *  (at your option) any later version.                                         *
 *                                                                              *
 *  This program is distributed in the hope that it will be useful,             *
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of              *
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               *
 *  GNU General Public License for more details.                                *
 *                                                                              *
 *  You should have received a copy of the GNU General Public License           *
 *  along with this program; if not, write to the Free Software                 *
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA  *
 ********************************************************************************/

#ifndef LIBOUTPUTFUNCTIONS_H
#define LIBOUTPUTFUNCTIONS_H

#include "types.h"

#include "outputfunction.h"
#include "derivableoutputfunction.h"


namespace nnfw {

class NNFW_API IdentityFunction : public DerivableOutputFunction {
public:

    IdentityFunction();

    IdentityFunction( PropertySettings& prop );

    virtual ~IdentityFunction() { /* Nothing to do */ };



    virtual void apply( RealVec& inputs, RealVec& outputs );

    virtual void derivate( const RealVec& x, const RealVec& y, RealVec& d ) const;

    virtual IdentityFunction* clone() const;

};

class NNFW_API ScaleFunction : public OutputFunction {
public:

    ScaleFunction( Real rate = 1.0 );

    ScaleFunction( PropertySettings& prop );

    virtual ~ScaleFunction() { /* Nothing to do */ };



    bool setRate( const Variant& v );

    Variant getRate();

    virtual void apply( RealVec& inputs, RealVec& outputs );

    virtual ScaleFunction* clone() const;

private:
    Real rate;
};

class NNFW_API GainFunction : public OutputFunction {
public:
    
    GainFunction( Real gain = 1.0 );
    
    GainFunction( PropertySettings& prop );
    
    virtual ~GainFunction() { /* Nothing to do */ };
    

    
    bool setGain( const Variant& v );
    
    Variant gain();
    
    virtual void apply( RealVec& inputs, RealVec& outputs );
    
    virtual GainFunction* clone() const;
    
private:
    Real gainv;
};

class NNFW_API SigmoidFunction : public DerivableOutputFunction {
public:

    SigmoidFunction( Real l = 1.0 );

    SigmoidFunction( PropertySettings& prop );

    virtual ~SigmoidFunction() { /* Nothing to do */ };



    bool setLambda( const Variant& v );

    Variant getLambda();

    virtual void apply( RealVec& inputs, RealVec& outputs );

    virtual void derivate( const RealVec& x, const RealVec& y, RealVec& d ) const;

    virtual SigmoidFunction* clone() const;

private:
    Real lambda;
};

class NNFW_API FakeSigmoidFunction : public DerivableOutputFunction {
public:

    FakeSigmoidFunction( Real l = 1.0 );

    FakeSigmoidFunction( PropertySettings& prop );

    virtual ~FakeSigmoidFunction() { /* Nothing to do */ };



    bool setLambda( const Variant& v );

    Variant getLambda();

    virtual void apply( RealVec& inputs, RealVec& outputs );

    virtual void derivate( const RealVec& x, const RealVec& y, RealVec& d ) const;

    virtual FakeSigmoidFunction* clone() const;


    Real lambda;
};

class NNFW_API ScaledSigmoidFunction : public DerivableOutputFunction {
public:

    ScaledSigmoidFunction( Real l = 1.0, Real min = -1.0, Real max = +1.0 );

    ScaledSigmoidFunction( PropertySettings& prop );

    virtual ~ScaledSigmoidFunction() { /* Nothing to do */ };



    bool setLambda( const Variant& v );

    Variant getLambda();

    bool setMin( const Variant& v );

    Variant getMin();

    bool setMax( const Variant& v );

    Variant getMax();

    virtual void apply( RealVec& inputs, RealVec& outputs );

    virtual void derivate( const RealVec& x, const RealVec& y, RealVec& d ) const;

    virtual ScaledSigmoidFunction* clone() const;


    Real lambda;
    Real min;
    Real max;
};

class NNFW_API RampFunction : public DerivableOutputFunction {
public:
    
    RampFunction( Real minX, Real maxX, Real minY = -1, Real maxY = +1 );
    
    RampFunction( PropertySettings& prop );
    
    virtual ~RampFunction() { /* Nothing to do */ };
    

    
    bool setMinX( const Variant& v );
    
    Variant minX();
    
    bool setMaxX( const Variant& v );
    
    Variant maxX();
    
    bool setMinY( const Variant& v );
    
    Variant minY();
    
    bool setMaxY( const Variant& v );
    
    Variant maxY();
    
    virtual void apply( RealVec& inputs, RealVec& outputs );
    
    virtual void derivate( const RealVec& x, const RealVec& y, RealVec& d ) const;
    
    virtual RampFunction* clone() const;
    
    
    Real min_x;
    Real max_x;
    Real min_y;
    Real max_y;
};

class NNFW_API LinearFunction : public DerivableOutputFunction {
public:
    
    LinearFunction( Real m, Real b );
    
    LinearFunction( PropertySettings& prop );
    
    virtual ~LinearFunction() { /* Nothing to do */ };
    

    
    bool setM( const Variant& v );
    
    Variant m();
    
    bool setB( const Variant& v );
    
    Variant b();
    
    virtual void apply( RealVec& inputs, RealVec& outputs );
    
    virtual void derivate( const RealVec& x, const RealVec& y, RealVec& d ) const;
    
    virtual LinearFunction* clone() const;
    
    
    Real mv;
    Real bv;
};

class NNFW_API StepFunction : public DerivableOutputFunction {
public:

    StepFunction( Real min = 0.0f, Real max = 1.0f, Real threshold = 0.0f );

    StepFunction( PropertySettings& prop );

    virtual ~StepFunction() { /* Nothing to do */ };



    bool setMin( const Variant& v );

    Variant getMin();

    bool setMax( const Variant& v );

    Variant getMax();

    bool setThreshold( const Variant& v );

    Variant getThreshold();

    virtual void apply( RealVec& inputs, RealVec& outputs );

    virtual void derivate( const RealVec& x, const RealVec& y, RealVec& d ) const;

    virtual StepFunction* clone() const;


    Real min;
    Real max;
    Real threshold;
};

class NNFW_API LeakyIntegratorFunction : public OutputFunction {
public:

    LeakyIntegratorFunction( const RealVec& d );

    LeakyIntegratorFunction( PropertySettings& prop );

    virtual ~LeakyIntegratorFunction() { /* Nothing to do */ };



    RealVec& getDelta() {
        return delta;
    };

    void setDelta( const RealVec& v ) {
        delta.assign( v );
    };

    Variant getDeltaV();

    bool setDeltaV( const Variant& v );

    void zeroingStatus();

    virtual void apply( RealVec& inputs, RealVec& outputs );

    virtual LeakyIntegratorFunction* clone() const;

    virtual void setCluster( Cluster* );


    RealVec delta;
    RealVec outprev;
};

class NNFW_API LogLikeFunction : public OutputFunction {
public:

    LogLikeFunction( Real A=1.0, Real B=5.0 );

    LogLikeFunction( PropertySettings& prop );

    virtual ~LogLikeFunction() { /* Nothing to do */ };



    Real A() {
        return a;
    };

    void setA( Real na ) {
        a = na;
    };

    Variant getAV();

    bool setAV( const Variant& v );

    Real B() {
        return b;
    };

    void setB( Real nb ) {
        b = nb;
    };

    Variant getBV();

    bool setBV( const Variant& v );

    virtual void apply( RealVec& inputs, RealVec& outputs );

    virtual LogLikeFunction* clone() const;


private:
    Real a;
    Real b;
};

class NNFW_API PoolFunction : public OutputFunction {
public:

    PoolFunction( const OutputFunction& prototype, u_int dim );

    PoolFunction( PropertySettings& prop );

    PoolFunction( u_int dim = 1 );

    ~PoolFunction();



    OutputFunction* getOutputFunction( u_int i );

    void setOutputFunction( u_int i, const OutputFunction& prototype );

    Variant getOutputFunctionV( u_int i );

    bool setOutputFunction( u_int i, const Variant& prototype );

    unsigned int size();

    Variant sizeV();

    virtual void apply( RealVec& inputs, RealVec& outputs );

    virtual PoolFunction* clone() const;

    virtual void setCluster( Cluster* );


private:
    VectorData<OutputFunction*> ups;
};



class NNFW_API CompositeFunction : public OutputFunction {
public:

    CompositeFunction( const OutputFunction& f, const OutputFunction& g );

    CompositeFunction( PropertySettings& prop );

    virtual ~CompositeFunction();



    bool setFirstFunction( const Variant& v );

    Variant getFirstFunction();

    bool setSecondFunction( const Variant& v );

    Variant getSecondFunction();

    virtual void apply( RealVec& inputs, RealVec& outputs );

    virtual CompositeFunction* clone() const;

    virtual void setCluster( Cluster* );


    //--- functions
    OutputFunction* first;
    OutputFunction* second;
    //--- intermediate result
    RealVec mid;
    //--- Cluster
    Cluster* cl;
};

class NNFW_API LinearComboFunction : public OutputFunction {
public:

    LinearComboFunction( Real w1, const OutputFunction& f, Real w2, const OutputFunction& g );

    LinearComboFunction( PropertySettings& prop );

    virtual ~LinearComboFunction();



    bool setFirstFunction( const Variant& v );
    Variant getFirstFunction();
    bool setFirstWeight( const Variant& v );
    Variant getFirstWeight();

    bool setSecondFunction( const Variant& v );
    Variant getSecondFunction();
    bool setSecondWeight( const Variant& v );
    Variant getSecondWeight();

    virtual void apply( RealVec& inputs, RealVec& outputs );

    virtual LinearComboFunction* clone() const;
    virtual void setCluster( Cluster* );


    //--- functions
    OutputFunction* first;
    OutputFunction* second;
    //--- temporary result
    RealVec mid;
    //--- weights
    Real w1, w2;
    //--- Cluster
    Cluster* cl;
};

}

#endif

Copyright © 2005-2008 G. Massera

Contact: emmegian (at) yahoo (dot) it

  Documentation generated by