Subversion Repositories artificial_neural_network

/*
 * ann.h
 *
 *  Description: This header file helps programmers to access correctly to ANN IP core weight and bias memories.
 *               User must edit ANN_BASEADDRESS, NLAYER, and definitions of layer inputs and neurons.
 *               MAX_MUL macro can be calculated manually, or relay on automated calculation if NLAYER<=4.
 *               A Wyb(x) macro must be declared on the code per layer of the ANN IP core.
 *               Those macro declare the 2D weight arrays and 1D bias arrays needed to access ANN IP core memories.
 *
 *  Created on: 17/05/2016
 *      Author: David A
 */
 
#ifndef ANN_H
#define ANN_H
 
/* Base address of weight and bias memories of the ANN IP core */
// Example for Xilinx's SDK using the example wrapper for Vivado. Correct user base address must be defined here:
#define ANN_BASEADDRESS XPAR_ANN_0_WYB_S_AXI_BASEADDR
 
/* Number of layers */
#define NLAYER 4
 
/* Number of inputs and neurons of each layer */
// Add or remove as many layers as needed:
#define NumIn0 16
#define NumN0 13
#define NumIn1 NumN0
#define NumN1 6
#define NumIn2 NumN1
#define NumN2 13
#define NumIn3 NumN2
#define NumN3 16
 
/* (optional) Redefine number of neurons in the last layer as number of outputs */
#define NumOut NumN3
 
/* Next-power-of-two of inputs and neurons of each layer */
// Define a next-power-of-two macro per parameter in the number of inputs and neurons of each layer list:
// NOTE: next_2power(x) macro function calculates the next-power-of-two of x for x<=256. If x>256 it still returns 256.
#define NumN0_b2  next_2power(NumN0)
#define NumIn0_b2  next_2power(NumIn0)
#define NumN1_b2  next_2power(NumN1)
#define NumIn1_b2  next_2power(NumIn1)
#define NumN2_b2  next_2power(NumN2)
#define NumIn2_b2  next_2power(NumIn2)
#define NumN3_b2  next_2power(NumN3)
#define NumIn3_b2  next_2power(NumIn3)
 
/* Maximum multiplication of the next-power-of-two of inputs by the next-power-of-two of neurons */
// MAX_MUL macro can be defined manually, or automatically if NLAYER<=4.
// To define it manually user must determine which layer has the maximum of these products, and edit MAX_MUL definition:
// In the example is layer 0 (or layer 3 with same MAX_MUL), 256 > 128
//    NumIn0 = 16 ==> NumIn0_b2 = 16
//    NumN0 = 13  ==> NumN0_b2 = 16
//          NumN0_b2*NumIn0_b2=16*16=256
//    NumIn1 = 13 ==> NumIn1_b2 = 16
//    NumN1 = 6   ==> NumN1_b2 = 8
//          NumN1_b2*NumIn1_b2=16*8=128
//    NumIn2 = 6  ==> NumIn2_b2 = 8
//    NumN2 = 13  ==> NumN2_b2 = 16
//          NumN2_b2*NumIn2_b2=8*16=128
//    NumIn3 = 13 ==> NumIn3_b2 = 16
//    NumN3 = 16  ==> NumN3_b2 = 16
//          NumN3_b2*NumIn3_b2=16*16=256
 
//#define MAX_MUL (NumN0_b2*NumIn0_b2) //Uncomment and edit this manual definition of MAX_MUL for manual definition of MAX_MUL
 
// Automated calculation of MAX_MUL for NLAYER<=4:
#ifndef MAX_MUL
#if NLAYER > 4
#error MAX_MUL cannot be automatically calculated if NLAYER>4. Define MAX_MUL manually or complete the automaed calculation of MAX_MUL preprocessor code.
#endif
#define max2(x,y)  ( ((x) < (y)) ? y : x )
#define MAX_0 (NumN0_b2*NumIn0_b2)
#if NLAYER > 1
    #define MAX_1 max2((NumN1_b2*NumIn1_b2),MAX_0)
    #if NLAYER > 2
        #define MAX_2 max2((NumN2_b2*NumIn2_b2),MAX_1)
        #if NLAYER == 4
            #define MAX_MUL max2((NumN3_b2*NumIn3_b2),MAX_2)
        #elif NLAYER == 3
            #define MAX_MUL MAX_2
        #endif //NLAYER == 4
    #elif NLAYER == 2
        #define MAX_MUL MAX_1
    #endif //NLAYER > 2
#else //NLAYER == 1
    #define MAX_MUL MAX_0
#endif //NLAYER > 1
#endif
 
/* Definition of the macro function next_2power(x) */
// It calculates the next-power-of-two of x for x<=256. If x>256 it still returns 256.
#define next_2power(x)  ( ((x) > 128) ? 256 : ((x) > 64) ? 128 : ((x) > 32) ? 64 : ((x) > 16) ? 32 : ((x) > 8) ? 16 : ((x) > 4) ? 8 : ((x) > 2) ? 4 : ((x) > 1) ? 2 : 1 )
 
/* When this macro is expanded for a particular layer x, it declares pointers to the weight 2D array, bias 1D array, and unused spaces; and initializes them with a proper address */
// Declare a Wvb(x) macro per layer on the user's ANN, each time with a different layer number x, from 0 to NLAYER-1.
// Example: For a two layer ANN (NLAYER 2)
//    Wvb(0)  // declares and initializes int (*W0)[NumN0][NumIn0_b2], (*b0)[NumN0];
//    Wyb(1)  // declares and initializes int (*W1)[NumN1][NumIn1_b2], (*b1)[NumN1];
// The unused spaces (*NOT_EXISTx0) and (*NOT_EXISTx1) are declared in order to prevent the use of these space address for other proposes. Although it does not assure it will not be used.
#define Wyb(x)  volatile int (*W##x)[NumN##x][NumIn##x##_b2] = (void *) ANN_BASEADDRESS + MAX_MUL*2*x*sizeof(int), \
(*NOT_EXIST##x##0)[MAX_MUL-NumN##x*NumIn##x##_b2] = (void *) ANN_BASEADDRESS + (NumN##x*NumIn##x##_b2 + MAX_MUL*2*x)*sizeof(int), \
(*b##x)[NumN##x] = (void *) ANN_BASEADDRESS + MAX_MUL*(2*x+1)*sizeof(int), \
(*NOT_EXIST##x##1)[MAX_MUL-NumN##x] = (void *) ANN_BASEADDRESS + (NumN##x + MAX_MUL*(2*x+1))*sizeof(int);
 
#endif // ANN_H