FeedForwardNN.cpp

libcudann

* FeedForwardNN.cpp

* Created on: Nov 17, 2010

* Author: donati

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

#include <sys/time.h>

#include "FeedForwardNN.h"

FeedForwardNN::FeedForwardNN(){

numOfLayers=0;

numOfWeights=0;

layersSize=NULL;

actFuncts=NULL;

weights=NULL;

}

// constructor with int (number of layers), array (layer sizes), array (activation functions)

FeedForwardNN::FeedForwardNN(const int num, const int * siz, const int * funct) {

struct timeval tv;

gettimeofday(&tv, NULL);

srand(tv.tv_usec);

if(num<2){printf("BAD NETWORK INITIALIZATION\n");exit(1);}

numOfLayers=num;

layersSize = new int[numOfLayers];

for(int i=0;i<numOfLayers;i++){

layersSize[i]=siz[i];

}

actFuncts = new int[numOfLayers];

for(int i=0;i<numOfLayers;i++){

actFuncts[i]=funct[i];

}

numOfWeights = 0;

for(int i=0;i<numOfLayers-1;i++){

numOfWeights+=(layersSize[i]+1)*layersSize[i+1];

}

weights = new float[numOfWeights];

initWeights();

}

/* constructor from txt file

* format is:

* NUMBER_OF_LAYERS

* LAYER1_SIZE LAYER2_SIZE LAYER3_SIZE ...

* LAYER2_ACT_FUNC LAYER3_ACT_FUNC ...

* NUMBER_OF_WEIGHTS

* WEIGHT1

* WEIGHT2

* WEIGHT3

* .

* spaces or \n do not matter

FeedForwardNN::FeedForwardNN(const char * s){

struct timeval tv;

gettimeofday(&tv, NULL);

srand(tv.tv_usec);

FILE * f;

f=fopen(s,"r");

//file not found

if (f!=NULL){

//file wrong format

if(fscanf(f,"%d",&numOfLayers)<1){printf("WRONG NETWORK FILE FORMAT\n");exit(1);}

layersSize = new int[numOfLayers];

for(int i=0;i<numOfLayers;i++)

if(fscanf(f,"%d",&layersSize[i])<1){printf("WRONG NETWORK FILE FORMAT\n");exit(1);}

actFuncts = new int[numOfLayers];

for(int i=0;i<numOfLayers;i++)

if(fscanf(f,"%d",&actFuncts[i])<1){printf("WRONG NETWORK FILE FORMAT\n");exit(1);}

if(fscanf(f,"%d",&numOfWeights)<1){printf("WRONG NETWORK FILE FORMAT\n");exit(1);}

weights = new float[numOfWeights];

for(int i=0;i<numOfWeights;i++)

if(fscanf(f,"%f",&weights[i])<1){printf("WRONG NETWORK FILE FORMAT\n");exit(1);}

fclose(f);

}

else{printf("COULDN'T OPEN THE NETWORK FILE\n");exit(1);}

}

// copy constructor

FeedForwardNN::FeedForwardNN(const FeedForwardNN & oldNet){

struct timeval tv;

gettimeofday(&tv, NULL);

srand(tv.tv_usec);

numOfLayers=oldNet.numOfLayers;

layersSize = new int[numOfLayers];

for(int i=0;i<numOfLayers;i++){

layersSize[i]=oldNet.layersSize[i];

}

actFuncts = new int[numOfLayers];

for(int i=0;i<numOfLayers;i++){

actFuncts[i]=oldNet.actFuncts[i];

}

numOfWeights = oldNet.numOfWeights;

weights = new float[numOfWeights];

for(int i=0;i<numOfWeights;i++){

weights[i]=oldNet.weights[i];

}

// assignment operator

FeedForwardNN & FeedForwardNN::operator = (const FeedForwardNN & oldNet){

if (this != &oldNet){ // protect against invalid self-assignment

// 1: allocate new memory and copy the elements

int * new_layersSize = new int[oldNet.numOfLayers];

for(int i=0;i<oldNet.numOfLayers;i++){

new_layersSize[i]=oldNet.layersSize[i];

}

int * new_actFuncts = new int[oldNet.numOfLayers];

for(int i=0;i<oldNet.numOfLayers;i++){

new_actFuncts[i]=oldNet.actFuncts[i];

}

float * new_weights = new float[oldNet.numOfWeights];

for(int i=0;i<oldNet.numOfWeights;i++){

new_weights[i]=oldNet.weights[i];

}

// 2: deallocate old memory

delete [] layersSize;

delete [] actFuncts;

delete [] weights;

// 3: assign the new memory to the object

layersSize=new_layersSize;

actFuncts=new_actFuncts;

weights=new_weights;

numOfLayers=oldNet.numOfLayers;

numOfWeights = oldNet.numOfWeights;

}

// by convention, always return *this

return *this;

}

FeedForwardNN::~FeedForwardNN() {

delete[] layersSize;

delete[] actFuncts;

delete[] weights;

}

// initialize randomly the network weights between min and max

void FeedForwardNN::initWeights(float min, float max)

{

for(int i=0;i<numOfWeights;i++){

//TEST WEIGHTS

//weights[i]=2;

//weights[i]=(2*max*((float)rand()/RAND_MAX))-max;

weights[i]=(max-min)*((float)rand()/(RAND_MAX+1.0f))+min;

}

// initialize the network weights with Widrow Nguyen algorithm

void FeedForwardNN::initWidrowNguyen(LearningSet & set){

float min=set.getInputs()[0];

float max=set.getInputs()[0];

//finds the min and max value of inputs

for (int i=0;i<set.getNumOfInstances()*set.getNumOfInputsPerInstance();i++){

float val=set.getInputs()[i];

if(val<min)

min=val;

if(val>max)

max=val;

}

int nOfHid=0;

for(int i=1;i<numOfLayers-1;i++)

nOfHid+=layersSize[i];

float mult=(float)(pow((double)(0.7f*(double)nOfHid),(double)(1.0f/(double)layersSize[0]))/(double)(max-min));

int offsetWeights[numOfLayers];

for(int i=0;i<numOfLayers;i++){

offsetWeights[i] = 0;

for(int j=0;j<i;j++){

offsetWeights[i]+=(layersSize[j]+1)*layersSize[j+1];

}

for(int i=0;i<numOfLayers-1;i++)

for(int j=0;j<layersSize[i+1];j++)

for(int k=0;k<layersSize[i]+1;k++)

if(k<layersSize[i]){

weights[offsetWeights[i]+j*(layersSize[i]+1)+k]=mult*((float)rand()/(RAND_MAX+1.0f));

}

else

weights[offsetWeights[i]+j*(layersSize[i]+1)+k]=2*mult*((float)rand()/(RAND_MAX+1.0f))-mult;

}

// computes the net outputs

void FeedForwardNN::compute(const float * inputs, float * outputs){

int offset = 0;

float * in;

float * out;

//loads the inputs

in = new float[layersSize[0]+1];

for(int i=0;i<layersSize[0];i++)

in[i]=inputs[i];

out = new float[0];

//loops the layers

for(int i=0;i<numOfLayers-1;i++){

//bias

in[layersSize[i]]=1.0;

offset=0;

for(int j=0;j<i;j++){

offset+=(layersSize[j]+1)*layersSize[j+1];

}

delete[] out;

out = new float [layersSize[i+1]];

float tot=0;

//loops the outputs

for(int j=0;j<layersSize[i+1];j++){

tot=0;

//loops the inputs

for(int k=0;k<layersSize[i]+1;k++){

tot+=in[k]*weights[k+j*(layersSize[i]+1)+offset];

}

out[j]= actFunction(actFuncts[i+1],tot);

}

delete[] in;

in = new float[layersSize[i+1]+1];

for(int l=0;l<layersSize[i+1];l++){

in[l]=out[l];

}

delete[] in;

for(int i=0;i<layersSize[numOfLayers-1];i++)

outputs[i]=out[i];

delete[] out;

}

// computes the MSE on a set

float FeedForwardNN::computeMSE(LearningSet & set){

float mse=0;

int numOfInstances=set.getNumOfInstances();

int numOfInputsPerInstance=set.getNumOfInputsPerInstance();

int numOfOutputsPerInstance=set.getNumOfOutputsPerInstance();

float netOuts[numOfOutputsPerInstance];

//local variables for faster access

float * inputs=set.getInputs();

float * outputs=set.getOutputs();

for(int instance=0;instance<numOfInstances;instance++){

//compute using the inputs with an offset to point to each instance

compute(inputs+instance*numOfInputsPerInstance,netOuts);

for(int i=0;i<numOfOutputsPerInstance;i++){

float x=outputs[i+instance*numOfOutputsPerInstance]-netOuts[i];

mse+=x*x;

}

mse/=(numOfInstances*numOfOutputsPerInstance)*spanSize(actFuncts[numOfLayers-1])*spanSize(actFuncts[numOfLayers-1]);

return mse;

}

// returns the index of the most high output neuron (classification)

int FeedForwardNN::classificate(const float * inputs){

int outputsSize=layersSize[numOfLayers-1];

float max=0;

int indmax=0;

float outputs[outputsSize];

compute(inputs,outputs);

for(int j=0;j<outputsSize;j++){

if(outputs[j]>max){

indmax=j;

max=outputs[j];

}

return indmax;

}

// computes the fraction of correct classification on a set (0 to 1)

float FeedForwardNN::classificatePerc(LearningSet & set){

int cont=0;

int numOfInstances=set.getNumOfInstances();

int numOfInputsPerInstance=set.getNumOfInputsPerInstance();

int numOfOutputsPerInstance=set.getNumOfOutputsPerInstance();

for(int i=0;i<numOfInstances;i++){

if(set.getOutputs()[classificate(set.getInputs()+i*numOfInputsPerInstance)+i*numOfOutputsPerInstance]==1){

cont++;

}

return (float)cont/(float)numOfInstances;

}

// saves the network to a txt file

void FeedForwardNN::saveToTxt(const char * s){

FILE * f;

f=fopen(s,"w");

fprintf(f,"%d\n",numOfLayers);

for(int i=0;i<numOfLayers;i++)

fprintf(f,"%d ",layersSize[i]);

fprintf(f,"\n");

for(int i=0;i<numOfLayers;i++)

fprintf(f,"%d ",actFuncts[i]);

fprintf(f,"\n%d\n",numOfWeights);

for(int i=0;i<numOfWeights;i++)

fprintf(f,"%.20e\n",weights[i]);

fclose(f);

}

int *FeedForwardNN::getLayersSize() const

{

return layersSize;

}

int FeedForwardNN::getNumOfLayers() const

{

return numOfLayers;

}

int FeedForwardNN::getNumOfWeights() const

{

return numOfWeights;

}

float *FeedForwardNN::getWeights() const

{

return weights;

}

int *FeedForwardNN::getActFuncts() const

{

return actFuncts;

}

float FeedForwardNN::getWeight(int ind) const

{

return weights[ind];

}

void FeedForwardNN::setWeight(int ind, float weight)

{

weights[ind]=weight;

}