nnfw/include/liboutputfunctions.h

Go to the documentation of this file.

/********************************************************************************
 *  Neural Network Framework.                                                   *
 *  Copyright (C) 2005-2011 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 "nnfwconfig.h"

#include "outputfunction.h"
#include <configurationparameters.h>
#include <memory>

namespace farsa {

class FARSA_NNFW_API IdentityFunction : public OutputFunction {
public:
    IdentityFunction();
    virtual ~IdentityFunction() { /* Nothing to do */ };
    virtual void apply( DoubleVector& inputs, DoubleVector& outputs );
    virtual bool derivate( const DoubleVector& x, const DoubleVector& y, DoubleVector& d ) const;
    virtual void configure(ConfigurationParameters& params, QString prefix);
    virtual void save(ConfigurationParameters& params, QString prefix);
};

class FARSA_NNFW_API ScaleFunction : public OutputFunction {
public:
    ScaleFunction( double rate = 1.0 );
    virtual ~ScaleFunction() { /* Nothing to do */ };
    virtual void apply( DoubleVector& inputs, DoubleVector& outputs );
    virtual bool derivate( const DoubleVector& x, const DoubleVector& y, DoubleVector& d ) const;
    virtual void configure(ConfigurationParameters& params, QString prefix);
    virtual void save(ConfigurationParameters& params, QString prefix);
    double rate;
};

class FARSA_NNFW_API GainFunction : public OutputFunction {
public:
    GainFunction( double gain = 1.0 );
    virtual ~GainFunction() { /* Nothing to do */ };
    virtual void apply( DoubleVector& inputs, DoubleVector& outputs );
    virtual bool derivate( const DoubleVector& x, const DoubleVector& y, DoubleVector& d ) const;
    virtual void configure(ConfigurationParameters& params, QString prefix);
    virtual void save(ConfigurationParameters& params, QString prefix);
    double gainv;
};

class FARSA_NNFW_API SigmoidFunction : public OutputFunction {
public:
    SigmoidFunction( double l = 1.0 );
    virtual ~SigmoidFunction() { /* Nothing to do */ };
    virtual void apply( DoubleVector& inputs, DoubleVector& outputs );
    virtual bool derivate( const DoubleVector& x, const DoubleVector& y, DoubleVector& d ) const;
    virtual void configure(ConfigurationParameters& params, QString prefix);
    virtual void save(ConfigurationParameters& params, QString prefix);
    double lambda;
};

class FARSA_NNFW_API FakeSigmoidFunction : public OutputFunction {
public:
    FakeSigmoidFunction( double l = 1.0 );
    virtual ~FakeSigmoidFunction() { /* Nothing to do */ };
    virtual void apply( DoubleVector& inputs, DoubleVector& outputs );
    virtual bool derivate( const DoubleVector& x, const DoubleVector& y, DoubleVector& d ) const;
    virtual void configure(ConfigurationParameters& params, QString prefix);
    virtual void save(ConfigurationParameters& params, QString prefix);
    double lambda;
};

class FARSA_NNFW_API ScaledSigmoidFunction : public OutputFunction {
public:
    ScaledSigmoidFunction( double l = 1.0, double min = -1.0, double max = +1.0 );
    virtual ~ScaledSigmoidFunction() { /* Nothing to do */ };
    virtual void apply( DoubleVector& inputs, DoubleVector& outputs );
    virtual bool derivate( const DoubleVector& x, const DoubleVector& y, DoubleVector& d ) const;
    virtual void configure(ConfigurationParameters& params, QString prefix);
    virtual void save(ConfigurationParameters& params, QString prefix);
    double lambda;
    double min;
    double max;
};

class FARSA_NNFW_API RampFunction : public OutputFunction {
public:
    RampFunction();
    RampFunction( double minX, double maxX, double minY = -1, double maxY = +1 );
    virtual ~RampFunction() { /* Nothing to do */ };
    virtual void apply( DoubleVector& inputs, DoubleVector& outputs );
    virtual bool derivate( const DoubleVector& x, const DoubleVector& y, DoubleVector& d ) const;
    virtual void configure(ConfigurationParameters& params, QString prefix);
    virtual void save(ConfigurationParameters& params, QString prefix);
    double min_x;
    double max_x;
    double min_y;
    double max_y;
};

class FARSA_NNFW_API LinearFunction : public OutputFunction {
public:
    LinearFunction();
    LinearFunction( double m, double b );
    virtual ~LinearFunction() { /* Nothing to do */ };
    virtual void apply( DoubleVector& inputs, DoubleVector& outputs );
    virtual bool derivate( const DoubleVector& x, const DoubleVector& y, DoubleVector& d ) const;
    virtual void configure(ConfigurationParameters& params, QString prefix);
    virtual void save(ConfigurationParameters& params, QString prefix);
    double m;
    double b;
};

class FARSA_NNFW_API StepFunction : public OutputFunction {
public:
    StepFunction( double min = 0.0f, double max = 1.0f, double threshold = 0.0f );
    virtual ~StepFunction() { /* Nothing to do */ };
    virtual void apply( DoubleVector& inputs, DoubleVector& outputs );
    virtual bool derivate( const DoubleVector& x, const DoubleVector& y, DoubleVector& d ) const;
    virtual void configure(ConfigurationParameters& params, QString prefix);
    virtual void save(ConfigurationParameters& params, QString prefix);
    double min;
    double max;
    double threshold;
};

class FARSA_NNFW_API LeakyIntegratorFunction : public OutputFunction {
public:
    LeakyIntegratorFunction();
    LeakyIntegratorFunction( const DoubleVector& deltas );
    virtual ~LeakyIntegratorFunction() { /* Nothing to do */ };
    void zeroingStatus();
    virtual void apply( DoubleVector& inputs, DoubleVector& outputs );
    virtual void clusterSetted();
    virtual void configure(ConfigurationParameters& params, QString prefix);
    virtual void save(ConfigurationParameters& params, QString prefix);
    DoubleVector delta;
    DoubleVector outprev;
};

class FARSA_NNFW_API LogLikeFunction : public OutputFunction {
public:
    LogLikeFunction( double A=1.0, double B=5.0 );
    virtual ~LogLikeFunction() { /* Nothing to do */ };
    virtual void apply( DoubleVector& inputs, DoubleVector& outputs );
    virtual void configure(ConfigurationParameters& params, QString prefix);
    virtual void save(ConfigurationParameters& params, QString prefix);
    double A;
    double B;
};

class FARSA_NNFW_API CompositeFunction : public OutputFunction {
public:
    CompositeFunction();
    CompositeFunction( OutputFunction *f, OutputFunction *g );
    virtual ~CompositeFunction();
    bool setFirstFunction( OutputFunction *f );
    OutputFunction* getFirstFunction();
    bool setSecondFunction( OutputFunction *g );
    OutputFunction* getSecondFunction();
    virtual void apply( DoubleVector& inputs, DoubleVector& outputs );
    virtual void clusterSetted();
    virtual void configure(ConfigurationParameters& params, QString prefix);
    virtual void save(ConfigurationParameters& params, QString prefix);
private:
    std::auto_ptr<OutputFunction> first;
    std::auto_ptr<OutputFunction> second;
    DoubleVector mid;
    CompositeFunction(const CompositeFunction&);
    CompositeFunction& operator=(const CompositeFunction&);
};

class FARSA_NNFW_API LinearComboFunction : public OutputFunction {
public:
    LinearComboFunction();
    LinearComboFunction( double w1, OutputFunction *f, double w2, OutputFunction *g );
    virtual ~LinearComboFunction();
    bool setFirstFunction( OutputFunction *f );
    OutputFunction* getFirstFunction();
    bool setFirstWeight( double v );
    double getFirstWeight();
    bool setSecondFunction( OutputFunction *g );
    OutputFunction* getSecondFunction();
    bool setSecondWeight( double v );
    double getSecondWeight();
    virtual void apply( DoubleVector& inputs, DoubleVector& outputs );
    virtual void clusterSetted();
    virtual void configure(ConfigurationParameters& params, QString prefix);
    virtual void save(ConfigurationParameters& params, QString prefix);
private:
    //--- functions
    std::auto_ptr<OutputFunction> first;
    std::auto_ptr<OutputFunction> second;
    //--- temporary result
    DoubleVector mid;
    //--- weights
    double w1, w2;
    // Copy constructor and copy operator (here to prevent usage)
    LinearComboFunction(const LinearComboFunction&);
    LinearComboFunction& operator=(const LinearComboFunction&);
};

}

#endif