noodle.h

Go to the documentation of this file.

 
#pragma once
 
#include <stdint.h>
#ifdef ARDUINO
#include <Arduino.h>
#endif
 
#include "noodle_config.h"   // pooling mode & backend selection macros
#include "noodle_fs.h"       // NDL_File + NOODLE_FS wrappers
 
#ifndef ARDUINO
typedef unsigned char byte;    
#endif
// ============================================================================
 
enum Activation : uint8_t { ACT_NONE = 0, ACT_RELU = 1 , ACT_SOFTMAX = 2};
 
struct Conv {
  uint16_t K;        
  uint16_t P = 0;    
  uint16_t S = 1;    
 
  const char *weight_fn = nullptr;
  const char *bias_fn   = nullptr;
 
  Activation act = ACT_RELU;
};
 
struct ConvMem {
  uint16_t K;        
  uint16_t P = 0;    
  uint16_t S = 1;    
 
  const float *weight = nullptr;
  const float *bias   = nullptr;
 
  Activation act = ACT_RELU;
};
 
struct Pool {
  uint16_t M = 1;    
  uint16_t T = 1;    
};
 
typedef void (*CBFPtr)(float progress);
 
void   noodle_setup_temp_buffers(void *b1, void *b2);
 
void noodle_setup_temp_buffers(void *b2);
 
bool noodle_fs_init(uint8_t clk_pin, uint8_t cmd_pin, uint8_t d0_pin);
bool noodle_fs_init(uint8_t clk_pin, uint8_t cmd_pin, uint8_t d0_pin, uint8_t d1_pin, uint8_t d2_pin, uint8_t d3_pin);
bool noodle_fs_init();
bool noodle_fs_init(uint8_t cs_pin);
 
void noodle_read_top_line(const char* fn, char *line, size_t maxlen);
 
void noodle_delete_file(const char *fn);
 
size_t noodle_read_bytes_until(NDL_File &file, char terminator, char *buffer, size_t length);
 
void noodle_write_float(NDL_File &f, float d);
 
float noodle_read_float(NDL_File &f);
 
byte noodle_read_byte(NDL_File &f);
 
void noodle_write_byte(NDL_File &f, byte d);
 
float *noodle_create_buffer(uint16_t size);
 
void noodle_delete_buffer(float *buffer);
 
void noodle_reset_buffer(float *buffer, uint16_t n);
 
float* noodle_slice(float* flat, size_t W, size_t z);
 
void noodle_array_to_file(float *array, const char *fn, uint16_t n);
 
void noodle_array_to_file(float *array, NDL_File &fo, uint16_t n);
 
void noodle_grid_to_file(byte *grid, const char *fn, uint16_t n);
 
void noodle_grid_to_file(byte *grid, NDL_File &fo, uint16_t n);
 
void noodle_grid_to_file(float *grid, const char *fn, uint16_t n);
 
void noodle_grid_to_file(float *grid, NDL_File &fo, uint16_t n);
 
void noodle_array_from_file(const char *fn, float *buffer, uint16_t K);
 
void noodle_array_from_file(NDL_File &fi, float *buffer, uint16_t K);
 
void noodle_grid_from_file(const char *fn, byte *buffer, uint16_t K);
 
void noodle_grid_from_file(NDL_File &fi, byte *buffer, uint16_t K);
 
void noodle_grid_from_file(const char *fn, int8_t *buffer, uint16_t K);
 
void noodle_grid_from_file(NDL_File &fi, int8_t *buffer, uint16_t K);
 
void noodle_grid_from_file(const char *fn, float *buffer, uint16_t K);
 
void noodle_grid_from_file(NDL_File &fi, float *buffer, uint16_t K);
 
uint16_t noodle_do_pooling(const float *input, uint16_t W, uint16_t K, uint16_t S, const char *fn);
uint16_t noodle_do_pooling(const float *input, uint16_t W, uint16_t K, uint16_t S, NDL_File &fo);
uint16_t noodle_do_pooling(const float *input, uint16_t W, uint16_t K, uint16_t S, float *output);
 
uint16_t noodle_do_pooling1d(float *input, uint16_t W, uint16_t K, uint16_t S, const char *fn);
uint16_t noodle_do_pooling1d(float *input, uint16_t W, uint16_t K, uint16_t S, NDL_File &fo);
 
uint16_t noodle_conv_byte(const char *in_fn,
                          uint16_t n_inputs,
                          uint16_t n_outputs,
                          const char *out_fn,
                          uint16_t W,
                          const Conv &conv,
                          const Pool &pool,
                          CBFPtr progress_cb = NULL);
 
uint16_t noodle_conv_float(const char *in_fn,
                           uint16_t n_inputs,
                           uint16_t n_outputs,
                           const char *out_fn,
                           uint16_t W,
                           const Conv &conv,
                           const Pool &pool,
                           CBFPtr progress_cb = NULL);
 
uint16_t noodle_conv_float(const char *in_fn,
                           uint16_t n_inputs,
                           uint16_t n_outputs,
                           float *output,
                           uint16_t W,
                           const Conv &conv,
                           const Pool &pool,
                           CBFPtr progress_cb = NULL);
 
uint16_t noodle_conv_float(float *input,
                           uint16_t n_inputs,
                           uint16_t n_outputs,
                           const char *out_fn,
                           uint16_t W,
                           const Conv &conv,
                           const Pool &pool,
                           CBFPtr progress_cb = NULL);
 
uint16_t noodle_conv_float(float *input,
                           uint16_t n_inputs,
                           uint16_t n_outputs,
                           const char *out_fn,
                           uint16_t W,
                           const ConvMem &conv,
                           const Pool &pool,
                           CBFPtr progress_cb = NULL);
 
uint16_t noodle_conv_float(float *input,
                           uint16_t n_inputs,
                           uint16_t n_outputs,
                           float *output,
                           uint16_t W,
                           const Conv &conv,
                           const Pool &pool,
                           CBFPtr progress_cb = NULL);
 
uint16_t noodle_conv_float(float *input,
                           uint16_t n_inputs,
                           uint16_t n_outputs,
                           float *output,
                           uint16_t W,
                           const ConvMem &conv,
                           const Pool &pool,
                           CBFPtr progress_cb = NULL);
               
uint16_t noodle_conv1d(const char *in_fn,
                       uint16_t n_inputs,
                       const char *out_fn,
                       uint16_t n_outputs,
                       uint16_t W,
                       const Conv &conv,
                       const Pool &pool,
                       CBFPtr progress_cb=NULL);
 
uint16_t noodle_conv1d(const char *in_fn,
                       uint16_t n_inputs,
                       const char *out_fn,
                       uint16_t n_outputs,
                       uint16_t W,
                       const Conv &conv,
                       CBFPtr progress_cb=NULL);
 
uint16_t noodle_conv1d(const char *in_fn,
                       uint16_t n_inputs,
                       const char *out_fn,
                       uint16_t n_outputs,
                       uint16_t W,
                       const ConvMem &conv,
                       CBFPtr progress_cb);
                       
uint16_t noodle_conv1d(float *in,
                       uint16_t n_inputs,
                       float *out,
                       uint16_t n_outputs,
                       uint16_t W,
                       const ConvMem &conv,
                       CBFPtr progress_cb=NULL);
 
uint16_t noodle_conv1d(float *in,
                       uint16_t n_inputs,
                       const char *out_fn,
                       uint16_t n_outputs,
                       uint16_t W,
                       const ConvMem &conv,
                       CBFPtr progress_cb);
 
uint16_t noodle_conv1d(const char *in_fn,
                       uint16_t n_inputs,
                       float *out,              // packed output: [O][Vmax]
                       uint16_t n_outputs,
                       uint16_t W,
                       const ConvMem &conv,
                       CBFPtr progress_cb);
 
uint16_t noodle_do_conv1d(float *input, float *kernel, uint16_t W, uint16_t K,
                          float *output, uint16_t P, uint16_t S);
 
uint16_t noodle_do_conv(byte *grid, const float *kernel, uint16_t K, uint16_t W,
                        float *output, uint16_t P, uint16_t S);
uint16_t noodle_do_conv(float *grid, const float *kernel, uint16_t K, uint16_t W,
                        float *output, uint16_t P, uint16_t S);
 
uint16_t noodle_do_bias(float *output, float bias, uint16_t n);
 
uint16_t noodle_do_bias_act(float *output, float bias, uint16_t n, Activation act);
 
float noodle_get_padded_x(byte *grid, int16_t i, int16_t j, int16_t W, int16_t P);
 
float noodle_get_padded_x(float *grid, int16_t i, int16_t j, int16_t W, int16_t P);
 
 
uint16_t noodle_soft_max(float *input_output, uint16_t n);
uint16_t noodle_sigmoid(float *input_output, uint16_t n);
uint16_t noodle_relu(float *input_output, uint16_t n);
 
struct FCN {
  const char *weight_fn = nullptr;
  const char *bias_fn   = nullptr;
  Activation act = ACT_RELU;
};
 
struct FCNFile {
  const char *weight_fn = nullptr;
  const char *bias_fn   = nullptr;
  Activation act = ACT_RELU;
};
 
struct FCNMem {
  const float *weight = nullptr;
  const float *bias   = nullptr;
  Activation act = ACT_RELU;
};
 
uint16_t noodle_fcn(const int8_t *input, uint16_t n_inputs, uint16_t n_outputs,
                    const char *out_fn, const FCNFile &fcn,
                    CBFPtr progress_cb = NULL);
 
 
uint16_t noodle_fcn(const char *in_fn, uint16_t n_inputs, uint16_t n_outputs,
                    const char *out_fn, const FCNFile &fcn,
                    CBFPtr progress_cb = NULL);
 
 
uint16_t noodle_fcn(const float *input, uint16_t n_inputs, uint16_t n_outputs,
                    float *output, const FCNMem &fcn,
                    CBFPtr progress_cb = NULL);
 
 
uint16_t noodle_fcn(const byte *input, uint16_t n_inputs, uint16_t n_outputs,
                    float *output, const FCNFile &fcn,
                    CBFPtr progress_cb = NULL);
 
 
uint16_t noodle_fcn(const int8_t *input, uint16_t n_inputs, uint16_t n_outputs,
                    float *output, const FCNFile &fcn,
                    CBFPtr progress_cb = NULL);
 
 
uint16_t noodle_fcn(const char *in_fn, uint16_t n_inputs, uint16_t n_outputs,
                    float *output, const FCNFile &fcn,
                    CBFPtr progress_cb = NULL);
 
uint16_t noodle_fcn(const float *input, uint16_t n_inputs, uint16_t n_outputs,
                    float *output, const FCNFile &fcn,
                    CBFPtr progress_cb);
 
uint16_t noodle_fcn(const float *input, uint16_t n_inputs, uint16_t n_outputs,
                    const char *out_fn, const FCNFile &fcn,
                    CBFPtr progress_cb);
 
uint16_t noodle_flat(const char *in_fn, float *output, uint16_t V, uint16_t n_filters);
 
uint16_t noodle_flat(float *input, float *output, uint16_t V, uint16_t n_filters);
 
uint16_t noodle_gap(float *inout,
                    uint16_t C,
                    uint16_t W);
 
void noodle_find_max(float *input,
                     uint16_t n,
                     float &max_val,
                     uint16_t &max_idx);
 
uint16_t noodle_dwconv_float(const char *in_fn,
                             uint16_t n_channels,
                             const char *out_fn,
                             uint16_t W,
                             const Conv &conv,
                             const Pool &pool,
                             CBFPtr progress_cb);
 
 
uint16_t noodle_dwconv_float(float *input,
                             uint16_t n_channels,
                             float *output,
                             uint16_t W,
                             const Conv &conv,
                             const Pool &pool,
                             CBFPtr progress_cb);
uint16_t noodle_dwconv_float(float *input,
                             uint16_t n_channels,
                             float *output,
                             uint16_t W,
                             const ConvMem &conv,
                             const Pool &pool,
                             CBFPtr progress_cb);                            
 
void noodle_unpack_bn_params(const float *bn_params,
                             uint16_t C,
                             const float **gamma,
                             const float **beta,
                             const float **mean,
                             const float **var);
 
uint16_t noodle_bn(float *x,
                   uint16_t C,
                   uint16_t W,
                   const float *gamma,
                   const float *beta,
                   const float *mean,
                   const float *var,
                   float eps=1e-3);
 
uint16_t noodle_bn_relu(float *x,
                        uint16_t C,
                        uint16_t W,
                        const float *gamma,
                        const float *beta,
                        const float *mean,
                        const float *var,
                        float eps=1e-3);
 
uint16_t noodle_bn(float *x,
                   uint16_t C,
                   uint16_t W,
                   const float *bn_params,
                   float eps=1e-3);
 
/*
 *  Batch Normalization followed by ReLU for a channel-first tensor in memory.
 *  @param x Pointer to the input tensor in [C][W][W] layout.
 *  @param C Number of channels.
 *  @param W Width/height of each channel plane.
 *  @param bn_params Pointer to the packed batch normalization parameters.
 *  @param eps Small constant to avoid division by zero.
 */
uint16_t noodle_bn_relu(float *x,
                        uint16_t C,
                        uint16_t W,
                        const float *bn_params,
                        float eps=1e-3);