/Users/mlind/Coding/Github/mnist-dnn/dnn.h

Go to the documentation of this file.

#ifndef DNN_HEADER
#define DNN_HEADER

// Include project libraries
#include "util/mnist-utils.h"
#include "util/mnist-stats.h"

#define MAX_CONVOLUTIONAL_FILTER 10     // check mechanism to avoid users defining wrong conv models

typedef struct LayerDefinition LayerDefinition;
typedef struct Vector3D Vector3D;
typedef struct Value2D Value2D;
typedef struct Volume Volume;
typedef struct Network Network;
typedef struct Layer Layer;
typedef struct Column Column;
typedef struct Node Node;
typedef struct Connection Connection;

typedef double Weight;
typedef unsigned long ByteSize;

typedef enum LayerType {EMPTY, INPUT, CONVOLUTIONAL, FULLY_CONNECTED, OUTPUT} LayerType;
typedef enum ActFctType {SIGMOID, TANH, RELU, NONE} ActFctType;




struct Volume{
    int width;
    int height;
    int depth;
};




struct LayerDefinition{
    LayerType layerType;        // what kind of layer is this (INP,CONV,FC,OUT)
    ActFctType activationType;  // what activation function is applied
    Volume nodeMap;             // what is the width/height/depth of this layer
    int filter;                 // size of the filter window (conv layers only)
};




struct Connection{
    Node *nodePtr;              // pointer to the target node
    Weight *weightPtr;          // pointer to a weight that is applied to this connection
};




struct Node{
    ByteSize size;              // actual byte size of this structure in run-time
    Weight bias;                // value of the bias weight of this node
    double output;              // result of activation function applied to this node
    double errorSum;            // result of error back propagation applied to this node
    int backwardConnCount;      // number of connections to the previous layer
    int forwardConnCount;       // number of connections to the following layer
    Connection connections[];   // array of connections
};




struct Column{
    ByteSize size;              // actual byte size of this structure in run-time
    int maxConnCountPerNode;    // maximum number of connections per node in this layer
    int nodeCount;              // number of nodes in this column
    Node nodes[];               // array of nodes
};




struct Layer{
    int id;                         // index of this layer in the network
    ByteSize size;                  // actual byte size of this structure in run-time
    LayerDefinition *layerDef;      // pointer to the definition of this layer
    Weight *weightsPtr;             // pointer to the weights of this layer
    int columnCount;                // number of columns in this layer
    Column columns[];               // array of columns
};




struct Network{
    ByteSize size;                  // actual byte size of this structure in run-time
    double learningRate;            // factor by which connection weight changes are applied
    int weightCount;                // number of weights in the net's weight block
    Weight *weightsPtr;             // pointer to the start of the network's weights block
    Weight nullWeight;              // memory slot for a weight pointed to by dead connections
    int layerCount;                 // number of layers in the network
    Layer layers[];                 // array of layers (of different sizes)
};




int getLayerNodeCount(LayerDefinition *layerDef);




int getNodeBackwardConnectionCount(LayerDefinition *layerDef);




int getLayerWeightCount(LayerDefinition *layerDef);




ByteSize getLayerWeightBlockSize(LayerDefinition *layerDef);




ByteSize getLayerSize(LayerDefinition *layerDef);




int calcStride(int tgtWidth, int filter, int srcWidth);




void feedInput(Network *nn, Vector *v);




void feedForwardNetwork(Network *nn);




void backPropagateNetwork(Network *nn, int targetClassification);




int getNetworkClassification(Network *nn);




Network *createNetwork(int layerCount, LayerDefinition *layerDefs);




LayerDefinition *setLayerDefinitions(int layerCount, ...);




#endif