aidge-export-cpp 0.2.0__py3-none-any.whl

aidge_export_cpp/__init__.py

@@ -0,0 +1,16 @@
+r"""
+Aidge Export for CPP standalone projects
+
+"""
+from .export_registry import ExportLibCpp
+
+from .operators import *
+from collections import defaultdict
+import aidge_core
+
+from aidge_export_cpp.utils import ROOT
+
+from ._version import *
+
+from .export import *
+

aidge_export_cpp/_version.py

@@ -0,0 +1,4 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+__version__ = version = '0.2.0'
+__version_tuple__ = version_tuple = (0, 2, 0)

aidge_export_cpp/export.py

@@ -0,0 +1,131 @@
+import re
+import os
+import numpy as np
+
+import aidge_core
+
+from aidge_core.export_utils.code_generation import *
+from aidge_core.mem_info import compute_default_mem_info
+
+from aidge_export_cpp.utils import ROOT
+from aidge_export_cpp.utils.converter import numpy_dtype2ctype
+from aidge_export_cpp import ExportLibCpp
+from aidge_export_cpp.utils.generation import *
+# from aidge_export_cpp.memory import *
+
+
+def generate_input_file(export_folder:str,
+                        array_name:str,
+                        array: np.ndarray):
+
+    # If directory doesn't exist, create it
+    if not os.path.exists(export_folder):
+        os.makedirs(export_folder)
+
+    generate_file(
+        file_path=f"{export_folder}/{array_name}.h",
+        template_path=str(ROOT / "templates" / "data" / "inputs.jinja"),
+        dims = array.shape,
+        data_t = numpy_dtype2ctype(array.dtype),
+        name = array_name,
+        values = array.tolist()
+    )
+
+
+def export(export_folder_name, graphview, scheduler, mem_wrapping=False):
+    aidge_core.export_utils.scheduler_export(
+        scheduler,
+        export_folder_name,
+        ExportLibCpp,
+        memory_manager=compute_default_mem_info
+    )
+
+    # export_folder = Path().absolute() / export_folder_name
+
+    # os.makedirs(str(export_folder), exist_ok=True)
+
+    # dnn_folder = export_folder / "dnn"
+    # os.makedirs(str(dnn_folder), exist_ok=True)
+
+    # list_actions = []
+    # list_configs = []
+    # peak_mem, mem_info = compute_default_mem_info(scheduler)
+    # list_forward_nodes = scheduler.get_static_scheduling()
+
+    # for node in list_forward_nodes:
+    #     if ExportLibCpp.exportable(node):
+    #         op = ExportLibCpp.get_export_node(node)(node, mem_info[node])
+    #         # For configuration files
+    #         list_configs = op.export(dnn_folder, list_configs)
+
+    #         # For forward file
+    #         list_actions = op.forward(list_actions)
+    #     else:
+    #         raise RuntimeError(f"Operator not supported: {node.type()} !")
+
+    # # Memory management
+    # # stats_folder = export_folder / "statistics"
+    # # os.makedirs(str(stats_folder), exist_ok=True)
+    # # mem_size, mem_info = generate_optimized_memory_info(stats_folder, scheduler, mem_wrapping)
+    # # peak_mem, mem_info = compute_default_mem_info(scheduler)
+
+    # # Generate the memory file
+    # # generate_file(
+    # #     str(dnn_folder / "memory" / "mem_info.h"),
+    # #     str(ROOT / "templates" / "memory" / "mem_info.jinja"),
+    # #     mem_size = mem_size,
+    # #     mem_info_legends = MEMORY_INFO_TEMPLATE,
+    # #     mem_info = mem_info
+    # # )
+    # # list_configs.append("memory/mem_info.h")
+
+    # # Get entry nodes
+    # # Store the datatype & name
+    # list_inputs_name = []
+    # for node in graphview.get_input_nodes():
+    #     for idx, node_input_tuple in enumerate(node.inputs()):
+    #         node_input, _ = node_input_tuple
+    #         if node_input is None:
+    #             export_type = aidge2c(node.get_operator().get_output(0).dtype())
+    #             list_inputs_name.append((export_type, f"{node.name()}_input_{idx}"))
+    #         elif node_input not in graphview.get_nodes():
+    #             export_type = aidge2c(node_input.get_operator().get_output(0).dtype())
+    #             list_inputs_name.append((export_type, node_input.name()))
+
+
+    # # Get output nodes
+    # # Store the datatype & name, like entry nodes
+    # list_outputs_name = []
+    # for node in graphview.get_nodes():
+    #     if len(node.get_children()) == 0:
+    #         export_type = aidge2c(node.get_operator().get_output(0).dtype())
+    #         list_outputs_name.append((export_type, f"{node.name()}_output_0"))
+
+    # # Generate forward file
+    # # TODO: for now the mem type is bound for all intermediate results, should change.
+    # # Note that we may have all inputs constants, hence select output type
+    # assert len(list_outputs_name) >= 1, f"TODO: requires some output to determine mem type"
+    # mem_ctype = list_outputs_name[0][0]
+    # generate_file(
+    #     str(dnn_folder / "src" / "forward.cpp"),
+    #     str(ROOT / "templates" / "network" / "network_forward.jinja"),
+    #     headers=set(list_configs),
+    #     actions=list_actions,
+    #     inputs= list_inputs_name,
+    #     outputs=list_outputs_name,
+    #     mem_ctype=mem_ctype,
+    #     peak_mem=peak_mem
+    # )
+
+    # # Generate dnn API
+    # generate_file(
+    #     str(dnn_folder / "include" / "dnn.hpp"),
+    #     str(ROOT / "templates" / "network" / "dnn_header.jinja"),
+    #     libraries=[],
+    #     functions=get_functions_from_c_file(str(dnn_folder / "src" / "forward.cpp")),
+    # )
+
+    # # Copy all static files in the export
+    # shutil.copy(str(ROOT / "static" / "main.cpp"), str(export_folder))
+    # shutil.copy(str(ROOT / "static" / "Makefile"), str(export_folder))
+    # shutil.copytree(str(ROOT / "static" / "include"), str(dnn_folder / "include"), dirs_exist_ok=True)

aidge_export_cpp/export_registry.py

@@ -0,0 +1,10 @@
+from aidge_core.export_utils import ExportLib
+from aidge_export_cpp.utils import ROOT
+
+class ExportLibCpp(ExportLib):
+    _name="export_cpp"
+    static_files={
+        str(ROOT / "static" / "Makefile"): "",
+        str(ROOT / "static" / "include" / "network" / "typedefs.hpp"): "dnn/include/network",
+        str(ROOT / "static" / "include" / "network" / "utils.hpp"): "dnn/include/network",
+    }

aidge_export_cpp/kernels/activation.hpp

@@ -0,0 +1,77 @@
+#ifndef __AIDGE_EXPORT_CPP_KERNELS_ACTIVATION__
+#define __AIDGE_EXPORT_CPP_KERNELS_ACTIVATION__
+
+#include <type_traits>
+#include "network/typedefs.hpp"
+#include "network/utils.hpp"
+#include "kernels/rescaling.hpp"
+
+template<typename Output_T, typename T,
+         typename std::enable_if<std::is_floating_point<T>::value>::type* = nullptr>
+__attribute__((always_inline)) inline
+Output_T saturate (T value, int32_t /*sat*/)
+{
+    return value;
+}
+
+template<typename Output_T, typename T,
+         typename std::enable_if<!std::is_floating_point<T>::value>::type* = nullptr>
+__attribute__((always_inline)) inline
+Output_T saturate (T value, uint32_t sat)
+{
+    if (std::is_unsigned<Output_T>::value) {
+        return clamp(value, T(0), (T(1) << sat) - 1);
+    } else {
+        return clamp(value, -(T(1) << (sat - 1)), (T(1) << (sat - 1)) - 1);
+    }
+}
+
+template<typename Output_T,
+         typename Sum_T,
+         typename Rescaling_T>
+__attribute__((always_inline)) inline
+Output_T activation_forward_value (Sum_T weightedSum,
+                                   int output,
+                                   ActivationFunction_T func,
+                                   const Rescaling_T& __restrict rescaling)
+{
+    switch(func) {
+        case Linear:
+        case Saturation: {
+            break;
+        }
+        case Rectifier: {
+            if(weightedSum <= 0) weightedSum = 0;
+            break;
+        }
+        default:
+            // Unsupported activation function
+            break;
+    }
+
+    // Value fixed here for now but it should be generated by
+    // the export module or determined by the type of Output_T
+    // For now only works for int8_t and uint8_t
+    const uint32_t NB_BITS = 8;
+    return saturate<Output_T>(rescaling(weightedSum, output), NB_BITS);
+}
+
+
+template<int NB_DATA,
+         ActivationFunction_T ACTIVATION,
+         typename Input_T, typename Output_T, typename Rescaling_T>
+__attribute__((always_inline)) inline
+void activation_forward (
+    const Input_T* __restrict inputs,
+    Output_T* __restrict outputs,
+    const Rescaling_T& __restrict rescaling)
+{
+    for (int i = 0; i < NB_DATA; ++i)
+    {
+        outputs[i] = activation_forward_value<Output_T>(inputs[i], i, ACTIVATION, rescaling);
+    }
+
+}
+
+
+#endif  // __AIDGE_EXPORT_CPP_KERNELS_ACTIVATION__

aidge_export_cpp/kernels/batchnorm.hpp

@@ -0,0 +1,41 @@
+#ifndef __AIDGE_EXPORT_CPP_KERNELS_BATCHNORM__
+#define __AIDGE_EXPORT_CPP_KERNELS_BATCHNORM__
+
+#include "network/typedefs.hpp"
+#include "kernels/rescaling.hpp"
+#include <math.h>
+
+// WARNING: this kernel only works for 32-bits floating point values
+
+template<int NB_OUTPUTS,
+         int OUTPUTS_HEIGHT, int OUTPUTS_WIDTH,
+         ActivationFunction_T ACTIVATION,
+         typename Input_T, typename Output_T,
+         typename Param_T>
+__attribute__((always_inline)) inline
+void batchnorm_forward (
+    const Input_T* __restrict inputs,
+    Output_T* __restrict outputs,
+    const Param_T* __restrict biases,
+    const Param_T* __restrict variances,
+    const Param_T* __restrict means,
+    const Param_T* __restrict scales,
+    const double epsilon)
+{
+    for (unsigned int output = 0; output < NB_OUTPUTS; ++output) {
+        const Output_T var = sqrt(variances[output] + epsilon);
+
+        for (int oy = 0; oy < OUTPUTS_HEIGHT; ++oy) {
+            for (int ox = 0; ox < OUTPUTS_WIDTH; ++ox) {
+                const int outputOffset = OUTPUTS_HEIGHT * oy + ox;
+
+                const Output_T normalized = (inputs[outputOffset + output] - means[output]) / var;
+                const Output_T sAs = scales[output] * normalized + biases[output];
+                outputs[outputOffset + output] = sat<Output_T>(sAs, output, ACTIVATION, NoScaling);
+            }
+        }
+    }
+}
+
+
+#endif  // __AIDGE_EXPORT_CPP_KERNELS_BATCHNORM__

aidge_export_cpp/kernels/convolution.hpp

@@ -0,0 +1,119 @@
+#ifndef __AIDGE_EXPORT_CPP_KERNELS_CONVOLUTION__
+#define __AIDGE_EXPORT_CPP_KERNELS_CONVOLUTION__
+
+#include "network/typedefs.hpp"
+#include "kernels/rescaling.hpp"
+#include "network/utils.hpp"
+#include "kernels/macs.hpp"
+#include "kernels/activation.hpp"
+
+
+template<int NB_CHANNELS,
+         int CHANNELS_HEIGHT, int CHANNELS_WIDTH,
+         int NB_OUTPUTS,
+         int OUTPUTS_HEIGHT, int OUTPUTS_WIDTH,
+         int PADDING_Y, int PADDING_X,
+         int STRIDE_Y, int STRIDE_X,
+         int DILATION_Y, int DILATION_X,
+         int KERNEL_HEIGHT, int KERNEL_WIDTH,
+         ActivationFunction_T ACTIVATION,
+         typename Input_T, typename Output_T,
+         typename Weight_T, typename Bias_T,
+         typename Rescaling_T>
+__attribute__((always_inline)) inline
+void convolution_forward(
+    const Input_T* __restrict inputs,
+    Output_T* __restrict outputs,
+    const Weight_T* __restrict weights,
+    const Bias_T* __restrict biases,
+    const Rescaling_T& __restrict rescaling)
+{
+    constexpr int DILATED_KERNEL_HEIGHT
+            = KERNEL_HEIGHT + (DILATION_Y - 1) * (KERNEL_HEIGHT - 1);
+
+    constexpr int DILATED_KERNEL_WIDTH
+            = KERNEL_WIDTH + (DILATION_X - 1) * (KERNEL_WIDTH - 1);
+
+    constexpr int OUTPUTS_HEIGHT_NOPAD
+        = (CHANNELS_HEIGHT - DILATION_Y * (KERNEL_HEIGHT - 1) - 1 + STRIDE_Y) / STRIDE_Y;
+    constexpr int OUTPUTS_WIDTH_NOPAD
+        = (CHANNELS_WIDTH - DILATION_X * (KERNEL_WIDTH - 1) - 1 + STRIDE_X) / STRIDE_X;
+
+    for (int oy = 0; oy < OUTPUTS_HEIGHT; ++oy) {
+        const int syMin = (PADDING_Y == 0) ? 0
+            : max(PADDING_Y - (oy * STRIDE_Y), 0);
+        const int syMax = (PADDING_Y == 0
+                && OUTPUTS_HEIGHT == OUTPUTS_HEIGHT_NOPAD) ? DILATED_KERNEL_HEIGHT
+            : clamp(CHANNELS_HEIGHT + PADDING_Y - (oy * STRIDE_Y),
+                    0, DILATED_KERNEL_HEIGHT);
+        const int iy = (oy * STRIDE_Y) - PADDING_Y;
+
+#pragma omp parallel for collapse(2)
+        for (int ox = 0; ox < OUTPUTS_WIDTH; ++ox) {
+            for (int output = 0; output < NB_OUTPUTS; ++output) {
+                // moved to inner loop for collapsing -->
+                const int sxMin = (PADDING_X == 0) ? 0
+                    : max(PADDING_X - (ox * STRIDE_X), 0);
+                const int sxMax = (PADDING_X == 0
+                        && OUTPUTS_WIDTH == OUTPUTS_WIDTH_NOPAD)
+                            ? DILATED_KERNEL_WIDTH
+                    : clamp(CHANNELS_WIDTH + PADDING_X - (ox * STRIDE_X),
+                            0, DILATED_KERNEL_WIDTH);
+                const int ix = (ox * STRIDE_X) - PADDING_X;
+
+                const int oPos = (ox + OUTPUTS_WIDTH * oy);
+                int oOffset = NB_OUTPUTS * oPos;
+
+                // <--
+
+                Bias_T weightedSum = biases[output];
+
+                for (int sy = 0; sy < KERNEL_HEIGHT; ++sy) {
+                    if ((PADDING_Y != 0
+                            || OUTPUTS_HEIGHT != OUTPUTS_HEIGHT_NOPAD)
+                        && ((sy*DILATION_Y < syMin) || (sy*DILATION_Y >= syMax)))
+                    {
+                        continue;
+                    }
+
+                    const int iPos = ix + CHANNELS_WIDTH * (iy + sy*DILATION_Y);
+                    int iOffset = NB_CHANNELS * iPos;
+
+                    const int wOffset = (output*KERNEL_HEIGHT + sy) * KERNEL_WIDTH * NB_CHANNELS;
+
+                    if (DILATION_X == 1 && ((PADDING_X == 0 && OUTPUTS_WIDTH == OUTPUTS_WIDTH_NOPAD)
+                        || sxMax - sxMin == KERNEL_WIDTH))
+                    {
+                        macsOnRange<KERNEL_WIDTH * NB_CHANNELS>(
+                            inputs + iOffset,
+                            weights + wOffset,
+                            weightedSum);
+                    }
+                    else {
+                        for (int sx = 0; sx < KERNEL_WIDTH; ++sx) {
+                            if ((PADDING_X != 0
+                                    || OUTPUTS_WIDTH != OUTPUTS_WIDTH_NOPAD)
+                                && ((sx*DILATION_X < sxMin) || (sx*DILATION_X >= sxMax)))
+                            {
+                                continue;
+                            }
+
+                            int iOffsetInRange = iOffset
+                                + sx * DILATION_X * NB_CHANNELS;
+
+                            macsOnRange<NB_CHANNELS>(
+                                // same input line so no wrapping can occur
+                                inputs + iOffsetInRange,
+                                weights + wOffset + sx * NB_CHANNELS,
+                                weightedSum);
+                        }
+                    }
+                }
+
+                outputs[oOffset + output] = activation_forward_value<Output_T>(weightedSum, output, ACTIVATION, rescaling);
+            }
+        }
+    }
+}
+
+#endif  // __AIDGE_EXPORT_CPP_KERNELS_CONVOLUTION__

aidge_export_cpp/kernels/elemwise.hpp

@@ -0,0 +1,171 @@
+#ifndef __AIDGE_EXPORT_CPP_KERNELS_ELEMWISE__
+#define __AIDGE_EXPORT_CPP_KERNELS_ELEMWISE__
+
+#include "network/typedefs.hpp"
+#include "kernels/activation.hpp"
+
+// Generic function for two inputs
+
+template<int NB_ELTS,
+         ElemWise_T ELEM_OP,
+         ActivationFunction_T ACTIVATION,
+         typename Input_T, typename Output_T,
+         typename Rescaling_T>
+__attribute__((always_inline)) inline
+void elemwise_forward (
+    Output_T* __restrict outputs,
+    const Rescaling_T& __restrict rescaling,
+    const Input_T* __restrict inputs1,
+    const Input_T* __restrict inputs2)
+{
+    if (std::is_floating_point<Input_T>::value)
+    {
+        Input_T val = 0;
+
+        switch (ELEM_OP) {
+            case Add: {
+                for (int i = 0; i < NB_ELTS; ++i) {
+                    val = inputs1[i] + inputs2[i];
+                    outputs[i] = activation_forward_value<Output_T>(val, i, ACTIVATION, rescaling);
+                }
+                break;
+            }
+            case Sub: {
+                for (int i = 0; i < NB_ELTS; ++i) {
+                    val = inputs1[i] - inputs2[i];
+                    outputs[i] = activation_forward_value<Output_T>(val, i, ACTIVATION, rescaling);
+
+                }
+                break;
+            }
+            case Mul: {
+                for (int i = 0; i < NB_ELTS; ++i) {
+                    val = inputs1[i] * inputs2[i];
+                    outputs[i] = activation_forward_value<Output_T>(val, i, ACTIVATION, rescaling);
+                }
+                break;
+            }
+            default: {
+                // Copy inputs1 in outputs for default case
+                for (int i = 0; i < NB_ELTS; ++i) {
+                    val = inputs1[i];
+                    outputs[i] = activation_forward_value<Output_T>(val, i, ACTIVATION, rescaling);
+                }
+                break;
+            }
+        }
+    }
+    else
+    {
+        int32_t val = 0;
+
+        switch (ELEM_OP) {
+            case Add: {
+                for (int i = 0; i < NB_ELTS; ++i) {
+                    val = inputs1[i] + inputs2[i];
+                    outputs[i] = activation_forward_value<Output_T>(val, i, ACTIVATION, rescaling);
+                }
+                break;
+            }
+            case Sub: {
+                for (int i = 0; i < NB_ELTS; ++i) {
+                    val = inputs1[i] - inputs2[i];
+                    outputs[i] = activation_forward_value<Output_T>(val, i, ACTIVATION, rescaling);
+                }
+                break;
+            }
+            case Mul: {
+                for (int i = 0; i < NB_ELTS; ++i) {
+                    val = inputs1[i] * inputs2[i];
+                    outputs[i] = activation_forward_value<Output_T>(val, i, ACTIVATION, rescaling);
+                }
+                break;
+            }
+            default: {
+                // Copy inputs1 in outputs for default case
+                for (int i = 0; i < NB_ELTS; ++i) {
+                    val = inputs1[i];
+                    outputs[i] = activation_forward_value<Output_T>(val, i, ACTIVATION, rescaling);
+                }
+                break;
+            }
+        }
+    }
+}
+
+
+// Generic function for multiple inputs
+// Not working
+
+// template<ElemWise_T ELEM_OP, typename Output_T>
+// __attribute__((always_inline)) inline
+// Output_T elemWise (int /*pos*/, int /*ch*/)
+// {
+//     return 0;
+// }
+
+// template<ElemWise_T ELEM_OP,
+//          int NB_CHANNELS,
+//          // For next inputs
+//          int... ARGS,
+//          typename... INPUTS,
+//          // Types
+//          typename Input_T, typename Output_T>
+// __attribute__((always_inline)) inline
+// Output_T elemWise (int pos, int ch,
+//                    const Input_T* __restrict firstInputs,
+//                    INPUTS... inputs)
+// {
+//     int iOffset = NB_CHANNELS * pos;
+
+//     return firstInputs[iOffset + ch]
+//                 + elemWise<ELEM_OP, ARGS...>(pos, ch, inputs...);
+// }
+
+// template<// For all inputs
+//          int NB_CHANNELS,
+//          int CHANNELS_HEIGHT, int CHANNELS_WIDTH,
+//          int NB_ELTS,
+//          int OUTPUTS_HEIGHT, int OUTPUTS_WIDTH,
+//          ElemWise_T ELEM_OP,
+//          ActivationFunction_T ACTIVATION,
+//          // For next inputs
+//          int... ARGS,
+//          typename... INPUTS,
+//          // Types
+//          typename Input_T, typename Output_T,
+//          typename Rescaling_T>
+// __attribute__((always_inline)) inline
+// void elemWise_forward (
+//     Output_T* __restrict outputs,
+//     const Rescaling_T& __restrict rescaling,
+//     const Input_T* __restrict firstInputs,
+//     INPUTS... inputs)
+// {
+//     for (int oy = 0; oy < OUTPUTS_HEIGHT; oy++) {
+//         for (int ox = 0; ox < OUTPUTS_WIDTH; ox++) {
+//             const int pos = (ox + OUTPUTS_WIDTH * oy);
+//             int oOffset = NB_ELTS * pos;
+
+//             for (int ch = 0; ch < NB_ELTS; ++ch) {
+//                 const Add_T val = elemWise<ELEM_OP,
+//                                         INPUT_NB_CHANNELS,
+//                                         INPUT_MEM_CONT_OFFSET,
+//                                         INPUT_MEM_CONT_NB_ELTS,
+//                                         INPUT_MEM_WRAP_OFFSET,
+//                                         INPUT_MEM_WRAP_NB_ELTS,
+//                                         INPUT_MEM_STRIDE,
+//                                         ARGS...>(pos, ch, firstInputs, inputs...);
+
+//                 outputs[oOffset + ch]
+//                     = sat<Output_T>(val, ch, ACTIVATION, rescaling);
+//             }
+//         }
+//     }
+// }
+
+
+
+
+
+#endif  // __AIDGE_EXPORT_CPP_KERNELS_ELEMWISE__

aidge_export_cpp/kernels/fullyconnected.hpp

@@ -0,0 +1,72 @@
+#ifndef __AIDGE_EXPORT_CPP_KERNELS_FULLYCONNECTED__
+#define __AIDGE_EXPORT_CPP_KERNELS_FULLYCONNECTED__
+
+#include "network/typedefs.hpp"
+#include "kernels/rescaling.hpp"
+#include "network/utils.hpp"
+#include "kernels/macs.hpp"
+#include "kernels/activation.hpp"
+
+template<int NB_CHANNELS,
+         int CHANNELS_HEIGHT, int CHANNELS_WIDTH,
+         int NB_OUTPUTS,
+         int OUTPUTS_HEIGHT, int OUTPUTS_WIDTH,
+         ActivationFunction_T ACTIVATION,
+         typename Input_T, typename Output_T,
+         typename Weight_T, typename Bias_T,
+         typename Rescaling_T>
+__attribute__((always_inline)) inline
+void fullyconnected_forward (
+    const Input_T* __restrict inputs,
+    Output_T* __restrict outputs,
+    const Weight_T* __restrict weights,
+    const Bias_T* __restrict biases,
+    const Rescaling_T& __restrict rescaling)
+{
+    // Warning, there is a trick here !
+    // To use this kernel, the inputs have to be in NHWC and the weights are in NCHW
+    // It is only an issue if the FC was after a flatten layer.
+    // Otherwise it is not an issue for the other FC because CHANNELS_WIDTH = CHANNELS_HEIGHT = 1
+    // Solution: Add a system to check dataformat
+    for (int och = 0; och < NB_OUTPUTS; och++) {
+
+        Bias_T weightedSum = biases[och];
+
+        for (int iy = 0; iy < CHANNELS_HEIGHT; ++iy) {
+            for (int ix = 0; ix < CHANNELS_WIDTH; ++ix) {
+                for (int ch = 0; ch < NB_CHANNELS; ++ch) {
+                    weightedSum += inputs[CHANNELS_WIDTH*NB_CHANNELS*iy + NB_CHANNELS*ix + ch]
+                                * weights[CHANNELS_HEIGHT*CHANNELS_WIDTH*NB_CHANNELS*och + CHANNELS_HEIGHT*CHANNELS_WIDTH*ch + CHANNELS_HEIGHT*iy + ix];
+                }
+            }
+        }
+
+        outputs[och] = activation_forward_value<Output_T>(weightedSum, och, ACTIVATION, rescaling);
+    }
+/*
+Here the kernel to use with inputs in NHWC and weights in NHWC
+#pragma omp parallel for
+    for (int och = 0; och < NB_OUTPUTS; och++) {
+
+        Bias_T weightedSum = biases[och];
+
+        for (int iy = 0; iy < CHANNELS_HEIGHT; ++iy) {
+            const int iPos = (CHANNELS_WIDTH * iy);
+            int iOffset = NB_CHANNELS * iPos;
+
+            const int wOffset = NB_CHANNELS * CHANNELS_WIDTH
+                                    * (iy + CHANNELS_HEIGHT * och);
+
+            macsOnRange<NB_CHANNELS * CHANNELS_WIDTH>(
+                inputs + iOffset,
+                weights + wOffset,
+                weightedSum);
+        }
+
+        outputs[och] = activation_forward_value<Output_T>(weightedSum, och, ACTIVATION, rescaling);
+    }
+*/
+}
+
+
+#endif  // __AIDGE_EXPORT_CPP_KERNELS_FULLYCONNECTED__

aidge_export_cpp/kernels/leakyrelu.hpp

@@ -0,0 +1,25 @@
+#ifndef __AIDGE_EXPORT_CPP_KERNELS_LEAKYRELU__
+#define __AIDGE_EXPORT_CPP_KERNELS_LEAKYRELU__
+
+#include "network/typedefs.hpp"
+
+template<int NB_DATA,
+         typename Input_T, typename Output_T>
+__attribute__((always_inline)) inline 
+void leakyrelu_forward (
+    const Input_T* __restrict inputs,
+    Output_T* __restrict outputs,
+    const float negative_slope)
+{
+#pragma omp parallel for
+    for (int i = 0; i < NB_DATA; ++i) {
+        if (inputs[i] >= 0) {
+            outputs[i] = inputs[i];
+        } else {
+            outputs[i] = negative_slope * inputs[i];
+        }
+    }
+}
+
+
+#endif  // __AIDGE_EXPORT_CPP_KERNELS_LEAKYRELU__