neural++.hpp

Go to the documentation of this file.

/**************************************************************************************************
 * LibNeural++ v.0.2 - All-purpose library for managing neural networks                           *
 * Copyright (C) 2009, BlackLight                                                                 *
 *                                                                                                *
 * 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 3 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, see <http://www.gnu.org/licenses/>.                                      *
 **************************************************************************************************/

//#ifndef __cplusplus
//#error "This is a C++ library, you know, so you'd better use a C++ compiler to compile it"
//#else

#ifndef __NEURALPP
#define __NEURALPP

#include <vector>
#include <string>
#include <cmath>

#include "neural++_exception.hpp"
using namespace std;

#define         RAND    (double) ( (rand() / (RAND_MAX/2)) - 1)

#define         BETA0   0.8

namespace neuralpp  {
        class Synapsis;
        class Neuron;
        class Layer;
        class NeuralNet;

        double df (double (*f)(double), double x);

        class NeuralNet  {
                int epochs;
                int ref_epochs;
                double l_rate;
                double ex;

                void updateWeights();

                void commitChanges (Layer *l);

                double error(double ex) const;
                
                double (*actv_f)(double);

        public:
                Layer* input;
                Layer* hidden;
                Layer* output;

                typedef enum  { file, str } source;

                NeuralNet()  {}

                NeuralNet (size_t in_size, size_t hidden_size, size_t out_size, double l, int e);

                NeuralNet (const string file) throw(NetworkFileNotFoundException);
                
                
                NeuralNet (size_t in_size, size_t hidden_size, size_t out_size,
                                double(*actv)(double), double l, int e);

                double getOutput() const;

                vector<double> getOutputs();

                double expected() const;

                void setExpected(double ex);

                void update();

                void propagate();

                void setInput (vector<double>& v);

                void link();

                void save(const char* fname) throw(NetworkFileWriteException);

                void train (string xml, source src) throw(InvalidXMLException);

                static void initXML (string& xml);

                static vector<double> split (char delim, string str);

                static string XMLFromSet (int id, string set);

                static void closeXML(string& xml);
        };

        class Synapsis  {
                double delta;
                double prev_delta;
                double weight;

                Neuron *in;
                Neuron *out;
                
                double (*actv_f)(double);

        public:
                Synapsis(Neuron* i, Neuron* o, double w, double d);

                Synapsis (Neuron* i, Neuron* o, double(*a)(double));
                
                Synapsis (Neuron* i, Neuron* o,
                                double w, double(*a)(double));
        
                Neuron* getIn();
                
                Neuron* getOut();

                void setWeight(double w) throw(InvalidSynapticalWeightException);
                
                void setDelta(double d) throw(InvalidSynapticalWeightException);

                double getWeight();
                
                double getDelta();
                
                double getPrevDelta();

                double momentum (int N, int x);
        };

        class Neuron  {
                double actv_val;
                double prop_val;

                vector< Synapsis > in;
                vector< Synapsis > out;

                double (*actv_f)(double);
        
        public:
                Neuron (double (*a)(double));

                Neuron (vector<Synapsis> in, vector<Synapsis> out,
                                double (*a)(double));

                Synapsis& synIn (size_t i);
                
                Synapsis& synOut (size_t i);

                void push_in (Synapsis& s);
                
                void push_out (Synapsis& s);

                void setActv (double a);

                void setProp (double p);

                double getActv();
                
                double getProp();

                double propagate();

                size_t nIn();
                
                size_t nOut();

                void synClear();
        };

        class Layer  {
                vector<Neuron> elements;

                void (*update_weights)();
                double (*actv_f)(double);

        public:
                Layer (size_t sz, double (*a)(double));

                Layer (vector<Neuron>& neurons, double(*a)(double));

                Neuron& operator[] (size_t i) throw(NetworkIndexOutOfBoundsException);

                void link (Layer& l);

                void setProp (vector<double>& v);
                 
                void setActv (vector<double>& v);

                void propagate();

                size_t size() const;
        };

        struct netrecord  {
                int input_size;
                int hidden_size;
                int output_size;

                int epochs;
                double l_rate;
                double ex;
        };

        struct neuronrecord  {
                double prop;
                double actv;
        };

        struct synrecord  {
                double w;
                double d;
        };
}

//#endif
#endif

---