OCR-project/cnn_8h_source.html

#ifndef CNN_H

#define CNN_H


#include <stddef.h>


/* -------------------------------------------------------------------------

 * Architecture constants

 * ---------------------------------------------------------------------- */


#define CNN_IMG_H   56

#define CNN_IMG_W   56


#define CNN_N_FILTERS   16

#define CNN_KERNEL_H     3

#define CNN_KERNEL_W     3


#define CNN_CONV_H  (CNN_IMG_H - CNN_KERNEL_H + 1)   /* 26 */

#define CNN_CONV_W  (CNN_IMG_W - CNN_KERNEL_W + 1)   /* 26 */


#define CNN_POOL_H  4

#define CNN_POOL_W  4


#define CNN_POOL_OUT_H  (CNN_CONV_H / CNN_POOL_H)   /* 13 */

#define CNN_POOL_OUT_W  (CNN_CONV_W / CNN_POOL_W)   /* 13 */


#define CNN_FLAT_SIZE  (CNN_N_FILTERS * CNN_POOL_OUT_H * CNN_POOL_OUT_W)  /* 2704 */


#define CNN_HIDDEN_SIZE  128


#define CNN_N_CLASSES  26


/* -------------------------------------------------------------------------

 * Hyper-parameters

 * ---------------------------------------------------------------------- */


#define CNN_LR          0.001f


#define CNN_MOMENTUM    0.9f


#define CNN_BATCH_SIZE  32


/* -------------------------------------------------------------------------

 * Data structures

 * ---------------------------------------------------------------------- */


typedef struct {

    float kernels[CNN_N_FILTERS][CNN_KERNEL_H][CNN_KERNEL_W];

    float conv_bias[CNN_N_FILTERS];


    float W1[CNN_HIDDEN_SIZE][CNN_FLAT_SIZE];

    float b1[CNN_HIDDEN_SIZE];


    float W2[CNN_N_CLASSES][CNN_HIDDEN_SIZE];

    float b2[CNN_N_CLASSES];

} CNNWeights;


typedef struct {

    float input[CNN_IMG_H][CNN_IMG_W];


    float conv_out[CNN_N_FILTERS][CNN_CONV_H][CNN_CONV_W];


    float pool_out[CNN_N_FILTERS][CNN_POOL_OUT_H][CNN_POOL_OUT_W];


    int pool_max_r[CNN_N_FILTERS][CNN_POOL_OUT_H][CNN_POOL_OUT_W];

    int pool_max_c[CNN_N_FILTERS][CNN_POOL_OUT_H][CNN_POOL_OUT_W];


    float flat[CNN_FLAT_SIZE];


    float z1[CNN_HIDDEN_SIZE];

    float h1[CNN_HIDDEN_SIZE];


    float z2[CNN_N_CLASSES];

    float output[CNN_N_CLASSES];

} CNNActivations;


typedef struct {

    CNNWeights  weights;

    CNNWeights  grads;

    CNNWeights  velocity;

    CNNActivations act;

    int         batch_count;

} CNN;


/* -------------------------------------------------------------------------

 * Public API

 * ---------------------------------------------------------------------- */


CNN *cnn_create(void);


void cnn_free(CNN *net);


void cnn_forward(CNN *net, const float *image);


void cnn_backward(CNN *net, int label);


void cnn_update(CNN *net);


void cnn_zero_grads(CNN *net);


int cnn_predict(CNN *net, const float *image);


float cnn_loss(const CNN *net, int label);


#endif /* CNN_H */

CNN_POOL_OUT_H
#define CNN_POOL_OUT_H
Definition cnn.h:46

CNN_FLAT_SIZE
#define CNN_FLAT_SIZE
Definition cnn.h:50

cnn_backward
void cnn_backward(CNN *net, int label)
Compute gradients via backpropagation.
Definition cnn.c:294

CNN_POOL_OUT_W
#define CNN_POOL_OUT_W
Definition cnn.h:47

CNN_KERNEL_W
#define CNN_KERNEL_W
Definition cnn.h:35

cnn_predict
int cnn_predict(CNN *net, const float *image)
Predict the most likely class for a single image.
Definition cnn.c:449

CNN_HIDDEN_SIZE
#define CNN_HIDDEN_SIZE
Definition cnn.h:53

CNN_IMG_W
#define CNN_IMG_W
Definition cnn.h:30

CNN_IMG_H
#define CNN_IMG_H
Definition cnn.h:29

cnn_zero_grads
void cnn_zero_grads(CNN *net)
Zero all gradient accumulators in net->grads.
Definition cnn.c:385

cnn_loss
float cnn_loss(const CNN *net, int label)
Compute cross-entropy loss for the current forward-pass output.
Definition cnn.c:283

cnn_forward
void cnn_forward(CNN *net, const float *image)
Run a full forward pass and populate net->act.
Definition cnn.c:266

CNN_N_CLASSES
#define CNN_N_CLASSES
Definition cnn.h:56

cnn_update
void cnn_update(CNN *net)
Apply one SGD-with-momentum update step to the weights.
Definition cnn.c:412

cnn_free
void cnn_free(CNN *net)
Free all memory associated with a CNN.
Definition cnn.c:123

cnn_create
CNN * cnn_create(void)
Allocate and initialise a CNN with He-initialised weights.
Definition cnn.c:90

CNN_KERNEL_H
#define CNN_KERNEL_H
Definition cnn.h:34

CNN_CONV_H
#define CNN_CONV_H
Definition cnn.h:38

CNN_N_FILTERS
#define CNN_N_FILTERS
Definition cnn.h:33

CNN_CONV_W
#define CNN_CONV_W
Definition cnn.h:39

CNNActivations
Intermediate activations produced by the forward pass.
Definition cnn.h:103

CNNActivations::pool_max_c
int pool_max_c[CNN_N_FILTERS][CNN_POOL_OUT_H][CNN_POOL_OUT_W]
Definition cnn.h:118

CNNActivations::z1
float z1[CNN_HIDDEN_SIZE]
Definition cnn.h:124

CNNActivations::output
float output[CNN_N_CLASSES]
Definition cnn.h:131

CNNActivations::h1
float h1[CNN_HIDDEN_SIZE]
Definition cnn.h:126

CNNActivations::pool_out
float pool_out[CNN_N_FILTERS][CNN_POOL_OUT_H][CNN_POOL_OUT_W]
Definition cnn.h:111

CNNActivations::pool_max_r
int pool_max_r[CNN_N_FILTERS][CNN_POOL_OUT_H][CNN_POOL_OUT_W]
Definition cnn.h:117

CNNActivations::flat
float flat[CNN_FLAT_SIZE]
Definition cnn.h:121

CNNActivations::z2
float z2[CNN_N_CLASSES]
Definition cnn.h:129

CNNActivations::conv_out
float conv_out[CNN_N_FILTERS][CNN_CONV_H][CNN_CONV_W]
Definition cnn.h:108

CNNActivations::input
float input[CNN_IMG_H][CNN_IMG_W]
Definition cnn.h:105

CNNWeights
Learnable parameters of the CNN.
Definition cnn.h:81

CNNWeights::kernels
float kernels[CNN_N_FILTERS][CNN_KERNEL_H][CNN_KERNEL_W]
Definition cnn.h:83

CNNWeights::W1
float W1[CNN_HIDDEN_SIZE][CNN_FLAT_SIZE]
Definition cnn.h:88

CNNWeights::b1
float b1[CNN_HIDDEN_SIZE]
Definition cnn.h:90

CNNWeights::conv_bias
float conv_bias[CNN_N_FILTERS]
Definition cnn.h:85

CNNWeights::b2
float b2[CNN_N_CLASSES]
Definition cnn.h:95

CNNWeights::W2
float W2[CNN_N_CLASSES][CNN_HIDDEN_SIZE]
Definition cnn.h:93

CNN
Full CNN state: weights, gradients, momentum buffers, activations.
Definition cnn.h:137

CNN::act
CNNActivations act
Definition cnn.h:141

CNN::weights
CNNWeights weights
Definition cnn.h:138

CNN::velocity
CNNWeights velocity
Definition cnn.h:140

CNN::grads
CNNWeights grads
Definition cnn.h:139

CNN::batch_count
int batch_count
Definition cnn.h:142