neural++.hpp

Go to the documentation of this file.

/**************************************************************************************************
 * LibNeural++ v.0.4 - 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 __NEURALPP
#define __NEURALPP

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

#include "neural++_exception.hpp"

#define         RAND    (double) ( (rand() / 10.0) / ((double) RAND_MAX) )
#define         BETA0   0.8

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

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

        class NeuralNet  {
                int epochs;
                int ref_epochs;
                double l_rate;
                double threshold;
                std::vector<double> expect;

                void updateWeights();

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

                double expected() const;

                std::vector<double> getExpected() const;

                void setExpected(double ex);

                void setExpected(std::vector<double> ex);

                void update();

                void link();
                
        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, double th = 0.0, double (*a)(double) = __actv);

                NeuralNet (const std::string file) throw(NetworkFileNotFoundException);
                
                double getOutput() const;

                std::vector<double> getOutputs();

                double getThreshold() const;

                void propagate();

                void setInput (std::vector<double> v);

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

                void loadFromBinary (const std::string fname) throw(NetworkFileNotFoundException);

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

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

                static void initXML (std::string& xml);

                static std::string XMLFromSet (int& id, std::string set);

                static void closeXML(std::string& xml);
        };

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

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

        public:
                Synapsis()  {}

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

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

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

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

        class Neuron  {
                double actv_val;
                double prop_val;
                double threshold;

                std::vector< Synapsis > in;
                std::vector< Synapsis > out;

                double (*actv_f)(double);
        
        public:
                Neuron (double (*a)(double), double th = 0.0);

                Neuron (std::vector<Synapsis> in, std::vector<Synapsis> out,
                                double (*a)(double), double th = 0.0);

                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);

                void setSynIn  (size_t n);
                void setSynOut (size_t n);

                double getActv();
                
                double getProp();

                void propagate();

                size_t nIn();
                
                size_t nOut();

                void synClear();
        };

        class Layer  {
                std::vector<Neuron> elements;
                double threshold;

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

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

                Layer (std::vector<Neuron>& neurons, double(*a)(double), double th = 0.0);

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

                void link (Layer& l);

                void setInput (std::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;
        };

        namespace neuralutils  {
                std::vector<double> split (char delim, std::string str);

                std::vector<std::string> splitLines (std::string str);

                void toLower (std::string& str);

                void toUpper (std::string& str);
        }
}

#endif

---