NeuralNetwork.h

/*
 *====================================================================
 * HISTORY:
 * -------
 * $Log: NeuralNetwork.h,v $
 * Revision 1.1  2008/08/23 14:28:48  samit_ahlawat
 * Feed forward neural network library
 *
 * Revision 1.1  2007/11/06 10:06:30  samit_ahlawat
 * Checking in first version of basic neural net infrastructure
 *
 * 
 * ID:
 * --
 * static const char *CvsId = "@(#)$Id: NeuralNetwork.h,v 1.1 2008/08/23 14:28:48 samit_ahlawat Exp $";
 *====================================================================
 */

#ifndef _AIMAGIK_NEURAL_NETWORK_H_
#define _AIMAGIK_NEURAL_NETWORK_H_

#include <vector>
#include "Neuron.h"
#include "NeuralNetworkBuilder.h"
#include <iostream>
#include "TestData.h"


struct NeuronConnection
{
    int* pNeurons;

    NeuronConnection() : pNeurons(NULL) {}
    NeuronConnection(int num) : pNeurons((int*) new int[num]) {}
    void SetNumNeurons(int num) { pNeurons = (int*) new int[num]; }

    ~NeuronConnection() { if (pNeurons) delete[] pNeurons; pNeurons = NULL; }
};


class NeuralNetwork
{
        private:
        // This is the neuron network
                std::vector<Neuron*>* pNetworkVec;
        // vector containing number of neurons at each level
                std::vector<int>* pLevelVec;
        std::vector<NeuronConnection*>* pConnectionVec;
                NeuralNetworkBuilder mBuilder;
        /* vector containing input to the network */
        std::vector<double>* pInputVec;
        /* vector containing activation (response) of different neurons
         * to provided input. The activations of neurons are needed, they
         * are computed once and stored in this vector, one activation
         * for each neuron. */
        std::vector<double>* pActivationVec;

        TestData* pData;

        public:
                NeuralNetwork();
                NeuralNetwork(const NeuralNetwork& network);
                NeuralNetwork& operator= (const NeuralNetwork& network);

        void ConstructNetworkFromFile(const char* file) throw (std::invalid_argument);

        void DeserializeData(std::istream& strm) { mBuilder.DeserializeData(strm); }

                void AddNeuronLevel(int numNeurons);
                Neuron* GetNeuron(int indx) { return (*pNetworkVec)[indx]; }

                int GetNumNeurons() const { return pNetworkVec->size(); }

        int GetNumInputNeurons() const { return pLevelVec->front(); }

        int GetNumOutputNeurons() const { return pLevelVec->back(); }

        int GetNumLevels() const { return pLevelVec->size(); }

        int GetNumNeuronsAtLevel(int level) const { return (*pLevelVec)[level]; }

        TestData* GetTestData() { return pData; }

        void AddData(std::vector<double>& input, std::vector<double>& output, int index) throw (std::logic_error);

        void DefineTrainingData(int inFeatures, int outFeatures, int numSamples);

        void AddSampleData(std::vector<double>& input, std::vector<double>& output, int index) throw (std::logic_error);

        /* Get a list of posterior neuron indices that connect (send
         * an input to) this neuron. */
        int* GetConnectingNeurons(int indx) const { return (*pConnectionVec)[indx]->pNeurons; }

        void ConnectNeuron(int neuronIndex, const std::vector<double>& weightVec, const std::vector<int>& neuronFromVec);


                const NeuralNetworkBuilder& GetBuilder() const { return mBuilder; }
        
                void FeedInput(const std::vector<double>& input, std::vector<double>& output);

                void FeedInput(const double* input, double* output);        

                void FeedInput(const double* input, double* output, double* net_input);        

                bool DetectCycle();

        /* Calibrate the weights of feed forward neural network
         * using gradient descent approach.
         * @param
         * eeta: learning parameter
         * maxIter: maximum number of iterations (grad descent steps)
         * minResidual: Stop if the residual falls below this
         *              threshold residual
         * finalResidual: This is an output variable that holds 
         * the residual at the final iteration.
         * @return
         * true if the solution converged (residual fell below the
         * specified threshold). False otherwise.
         */
        bool CalibrateWeights(double eeta, int maxIter, double minResidual, double& finalResidual);

                void ClearNetwork();
                ~NeuralNetwork();
};

std::ostream& operator<< (std::ostream& os, const NeuralNetwork& network);
std::istream& operator>> (std::istream& is, NeuralNetwork& network);


#endif // _AIMAGIK_NEURAL_NETWORK_H_

---