Baillehache Pascal's personal website

LibCapy - neuralNetwork

Class implementing a neural network.

Macros:

#define CAPY_NEURALNETWORK_H

#define CapyNNActivationFunDef struct {   \
  struct CapyMathFunDef;                  \
  CapyNNActivationFunType type;           \
  CapyPad(CapyNNActivationFunType, type); \
  void (*destructCapyMathFun)(void);      \
  void (*exportToCFun)(                   \
          FILE* const stream,             \
    char const* const name);              \
  void (*exportToJavascript)(             \
          FILE* const stream,             \
    char const* const name);              \
}

Activation function class definition macro

#define CapyNNLayerDef_              \
  struct {                           \
    size_t nbNode;                   \
    CapyNNActivationFun* activation; \
  }

Macro of the definition of one layer Number of nodes size_t nbNode; Reference to the activation function for the nodes of this layer CapyMathFun* activation;

Enumerations:

typedef enum CapyNNActivationFunType {
  capyNNActivationFun_none,
  capyNNActivationFun_linear,
  capyNNActivationFun_step,
  capyNNActivationFun_sigmoid,
  capyNNActivationFun_hypertangent,
  capyNNActivationFun_relu,
  capyNNActivationFun_silu,
  capyNNActivationFun_nb,
} CapyNNActivationFunType;

Types of activation function

Typedefs:

typedef CapyNNActivationFunDef CapyNNActivationFun;

Activation function class

typedef CapyNNLayerDef_ CapyNNLayerDef;

Definition of one layer

Struct CapyNNLink :

Struct CapyNNLink's properties:

  size_t iLayer;

Index of the input layer

  size_t iNode;

Index of the input node in the layer

  size_t idxWeight;

Index of the weight of the link in the array of params

Struct CapyNNLink's methods:

None.

Struct CapyNNNode :

Struct CapyNNNode's properties:

  double valInput;

Value of the node before applying the activation function (i.e. w.x+b)

  double val;

Value of the node after applying the activation function (i.e. A(w.x+b))

  double prevVal;

Previous value of the node

  double propagatingDeriv;

Variable to memorise and reuse the propagating derivation during training

  size_t nbLink;

Number of input links

  CapyNNLink* links;

Input links

  size_t idxBias;

Index of the bias of the node in the array of params

Struct CapyNNNode's methods:

None.

Struct CapyNNLayer :

Struct CapyNNLayer's properties:

  CapyNNLayerDef_;

Layer definition

  size_t depth;

Depth of the layer

  CapyNNNode* nodes;

Nodes

Struct CapyNNLayer's methods:

None.

Struct CapyNNModel :

Struct CapyNNModel's properties:

  size_t nbLayer;

Number of layers

  CapyNNLayerDef* layers;

Number of node and activation function per layer

Struct CapyNNModel's methods:

None.

Struct CapyNeuralNetwork :

Struct CapyNeuralNetwork's properties:

  size_t nbInput;

Number of input

  size_t nbOutput;

Number of output

  size_t nbLayer;

Number of layers

  CapyNNLayer* layers;

Layers (including input and output layers)

  size_t nbParam;

Total number of params (weights and biases) in the model

  double* params;

Array of all weights and biases, ordered by layer and node

Struct CapyNeuralNetwork's methods:

  void (*destruct)(void);

Destructor

  void (*eval)(
    double const* const in,
          double* const out);

Evaluate the neural network

  void (*save)(FILE* const stream);

Save the neural network to a stream Input: stream: the stream on which to save Output: The neural network is saved on the stream

Struct CapyNNActivationLinear :

Struct CapyNNActivationLinear's properties:

  CapyNNActivationFunDef;

Struct CapyNNActivationLinear's methods:

None.

Struct CapyNNActivationStep :

Struct CapyNNActivationStep's properties:

  CapyNNActivationFunDef;

Struct CapyNNActivationStep's methods:

None.

Struct CapyNNActivationSigmoid :

Struct CapyNNActivationSigmoid's properties:

  CapyNNActivationFunDef;

Struct CapyNNActivationSigmoid's methods:

None.

Struct CapyNNActivationHyperTangent :

Struct CapyNNActivationHyperTangent's properties:

  CapyNNActivationFunDef;

Struct CapyNNActivationHyperTangent's methods:

None.

Struct CapyNNActivationReLU :

Struct CapyNNActivationReLU's properties:

  CapyNNActivationFunDef;

Struct CapyNNActivationReLU's methods:

None.

Struct CapyNNActivationSiLU :

Struct CapyNNActivationSiLU's properties:

  CapyNNActivationFunDef;

Struct CapyNNActivationSiLU's methods:

None.

Functions:

CapyNNModel CapyNNModelCopy(CapyNNModel const* const that);

Copy a CapyNNModel

Input argument(s):

that: the model to copy

Output and side effect(s):

Return a copy.

void CapyNNModelDestruct(CapyNNModel* const that);

Destruct a CapyNNModel

Input argument(s):

that: the model to destruct

Output and side effect(s):

The model is destructed.

CapyNeuralNetwork CapyNeuralNetworkCreateFullyConnected(
              size_t const nbInput,
  CapyNNModel const* const model,
              size_t const nbOutput);

Create a CapyNeuralNetwork

Input argument(s):

nbInput: size of the input vector
model: the layers model
nbOutput: size of the output vector

Output and side effect(s):

Return a CapyNeuralNetwork

CapyNeuralNetwork* CapyNeuralNetworkAllocFullyConnected(
              size_t const nbInput,
  CapyNNModel const* const model,
              size_t const nbOutput);

Allocate memory for a new CapyNeuralNetwork and create it

Input argument(s):

nbInput: size of the input vector
model: the layers model
nbOutput: size of the output vector

Output and side effect(s):

Return a CapyNeuralNetwork

Exception(s):

May raise CapyExc_MallocFailed.

void CapyNeuralNetworkFree(CapyNeuralNetwork** const that);

Free the memory used by a CapyNeuralNetwork* and reset '*that' to NULL

Input argument(s):

that: a pointer to the CapyNeuralNetwork to free

CapyNeuralNetwork* CapyNeuralNetworkLoad(
         FILE* const stream,
  CapyNNModel* const model);

Load a CapyNeuralNetwork from a stream

Input argument(s):

stream: the stream from which the NN is loaded
model: CapyNNModel updated with the model of the loaded NN

Output and side effect(s):

Return a CapyNeuralNetwork

CapyNNActivationLinear CapyNNActivationLinearCreate(void);

Create a step activation function

Output and side effect(s):