aidge_core/aidge_export_aidge/operator_export/__init__.py

+"""
+Copyright (c) 2023 CEA-List
+
+This program and the accompanying materials are made available under the
+terms of the Eclipse Public License 2.0 which is available at
+http://www.eclipse.org/legal/epl-2.0.
+
+SPDX-License-Identifier: EPL-2.0
+"""
+from pathlib import Path
+
+DIR_PATH = Path(__file__).parent
+modules = [Path(module).stem for module in DIR_PATH.glob("*.py")]
+__all__ = [ f for f in modules if f != "__init__"]

aidge_core/aidge_export_aidge/operator_export/add.py

+from aidge_core.aidge_export_aidge.registry import ExportSerialize
+from aidge_core.aidge_export_aidge import ROOT_EXPORT
+from aidge_core.export_utils import ExportNodeCpp
+from aidge_core import ImplSpec, IOSpec, dtype
+
+@ExportSerialize.register("Add", ImplSpec(IOSpec(dtype.any)))
+class Add(ExportNodeCpp):
+    def __init__(self, node, mem_info):
+        super().__init__(node, mem_info)
+        self.config_template = ""
+        self.forward_template = str(
+            ROOT_EXPORT / "templates/graph_ctor/add.jinja")
+        self.include_list = ["aidge/operator/Add.hpp"]
+        self.kernels_to_copy = []

aidge_core/aidge_export_aidge/operator_export/conv.py

+from aidge_core.aidge_export_aidge.registry import ExportSerialize
+from aidge_core.aidge_export_aidge import ROOT_EXPORT
+from aidge_core.export_utils import ExportNodeCpp
+from aidge_core import ImplSpec, IOSpec, dtype
+
+@ExportSerialize.register(["Conv1D", "Conv2D"], ImplSpec(IOSpec(dtype.any)))
+class Conv(ExportNodeCpp):
+    def __init__(self, node, mem_info):
+        super().__init__(node, mem_info)
+        self.config_template = str(
+            ROOT_EXPORT / "templates/attributes/conv.jinja")
+        self.forward_template = str(
+            ROOT_EXPORT /"templates/graph_ctor/conv.jinja")
+        self.include_list = ["aidge/operator/Conv.hpp"]
+        self.kernels_to_copy = []
+        self.config_path = "include/attributes"
+        self.config_extension = "hpp"

aidge_core/aidge_export_aidge/operator_export/conv_depth_wise.py

+from aidge_core.aidge_export_aidge.registry import ExportSerialize
+from aidge_core.aidge_export_aidge import ROOT_EXPORT
+from aidge_core.export_utils import ExportNodeCpp
+from aidge_core import ImplSpec, IOSpec, dtype
+
+@ExportSerialize.register(["ConvDepthWise1D", "ConvDepthWise2D"], ImplSpec(IOSpec(dtype.any)))
+class ConvDepthWise(ExportNodeCpp):
+    def __init__(self, node, mem_info):
+        super().__init__(node, mem_info)
+        self.config_template = str(
+            ROOT_EXPORT / "templates/attributes/conv_depth_wise.jinja")
+        self.forward_template = str(
+            ROOT_EXPORT /"templates/graph_ctor/conv_depth_wise.jinja")
+        self.include_list = ["aidge/operator/ConvDepthWise.hpp"]
+        self.kernels_to_copy = []
+        self.config_path = "include/attributes"
+        self.config_extension = "hpp"

aidge_core/aidge_export_aidge/operator_export/fc.py

+from aidge_core.aidge_export_aidge.registry import ExportSerialize
+from aidge_core.aidge_export_aidge import ROOT_EXPORT
+from aidge_core.export_utils import ExportNodeCpp
+from aidge_core import ImplSpec, IOSpec, dtype
+
+
+@ExportSerialize.register("FC", ImplSpec(IOSpec(dtype.any)))
+class FC(ExportNodeCpp):
+    def __init__(self, node, mem_info):
+        super().__init__(node, mem_info)
+        self.config_template = str(
+            ROOT_EXPORT / "templates/attributes/fc.jinja")
+        self.forward_template = str(
+            ROOT_EXPORT / "templates/graph_ctor/fc.jinja")
+        self.include_list = ["aidge/operator/FC.hpp"]
+        self.kernels_to_copy = []
+        self.config_path = "include/attributes"
+        self.config_extension = "hpp"

aidge_core/aidge_export_aidge/operator_export/maxpooling.py

+from aidge_core.aidge_export_aidge.registry import ExportSerialize
+from aidge_core.aidge_export_aidge import ROOT_EXPORT
+from aidge_core.export_utils import ExportNodeCpp
+from aidge_core import ImplSpec, IOSpec, dtype
+
+@ExportSerialize.register(["MaxPooling1D", "MaxPooling2D", "MaxPooling3D"], ImplSpec(IOSpec(dtype.any)))
+class MaxPooling(ExportNodeCpp):
+    def __init__(self, node, mem_info):
+        super().__init__(node, mem_info)
+        self.config_template = str(
+            ROOT_EXPORT / "templates/attributes/maxpooling.jinja")
+        self.forward_template = str(
+            ROOT_EXPORT / "templates/graph_ctor/maxpooling.jinja")
+        self.include_list = ["aidge/operator/MaxPooling.hpp"]
+        self.kernels_to_copy = []
+        self.config_path = "include/attributes"
+        self.config_extension = "hpp"

aidge_core/aidge_export_aidge/operator_export/pad.py

+from aidge_core.aidge_export_aidge.registry import ExportSerialize
+from aidge_core.aidge_export_aidge import ROOT_EXPORT
+from aidge_core.export_utils import ExportNodeCpp
+from aidge_core import ImplSpec, IOSpec, dtype
+
+@ExportSerialize.register(["Pad1D", "Pad2D"], ImplSpec(IOSpec(dtype.any)))
+class Pad(ExportNodeCpp):
+    def __init__(self, node, mem_info):
+        super().__init__(node, mem_info)
+        self.config_template = str(
+            ROOT_EXPORT / "templates/attributes/pad.jinja")
+        self.forward_template = str(
+            ROOT_EXPORT /"templates/graph_ctor/pad.jinja")
+        self.include_list = ["aidge/operator/Pad.hpp"]
+        self.kernels_to_copy = []
+        self.config_path = "include/attributes"
+        self.config_extension = "hpp"

aidge_core/aidge_export_aidge/operator_export/producer.py

+import numpy as np
+
+from aidge_core.aidge_export_aidge.registry import ExportSerialize
+from aidge_core.aidge_export_aidge import ROOT_EXPORT
+from aidge_core.export_utils import ExportNodeCpp
+from aidge_core import ImplSpec, IOSpec, dtype
+
+@ExportSerialize.register("Producer", ImplSpec(IOSpec(dtype.any)))
+class Producer(ExportNodeCpp):
+    """
+    If there is a standardization of the export operators
+    then this class should be just a inheritance of ProducerCPP
+    """
+    def __init__(self, node, mem_info):
+        super().__init__(node, mem_info)
+        child, in_idx = self.node.output(0)[0]
+
+        self.values = np.array(self.operator.get_output(0))
+
+        self.config_template = str(
+            ROOT_EXPORT / "templates/parameter.jinja")
+        self.forward_template = str(
+            ROOT_EXPORT / "templates/graph_ctor/producer.jinja")
+        self.attributes["tensor_name"] = f"{child.name()}_{in_idx}"
+        self.attributes["values"] = str(self.operator.get_output(0))
+        self.include_list = ["aidge/operator/Producer.hpp"]
+        self.kernels_to_copy = []
+        self.config_path = "include/attributes"
+        self.config_extension = "hpp"
+

aidge_core/aidge_export_aidge/operator_export/relu.py

+from aidge_core.aidge_export_aidge.registry import ExportSerialize
+from aidge_core.aidge_export_aidge import ROOT_EXPORT
+from aidge_core.export_utils import ExportNodeCpp
+from aidge_core import ImplSpec, IOSpec, dtype
+
+@ExportSerialize.register("ReLU", ImplSpec(IOSpec(dtype.any)))
+class ReLU(ExportNodeCpp):
+    def __init__(self, node, mem_info):
+        super().__init__(node, mem_info)
+        self.config_template = ""
+        self.forward_template = str(
+            ROOT_EXPORT / "templates/graph_ctor/relu.jinja")
+        self.include_list = ["aidge/operator/ReLU.hpp"]
+        self.kernels_to_copy = []

aidge_core/aidge_export_aidge/operator_export/sub.py

+from aidge_core.aidge_export_aidge.registry import ExportSerialize
+from aidge_core.aidge_export_aidge import ROOT_EXPORT
+from aidge_core.export_utils import ExportNodeCpp
+from aidge_core import ImplSpec, IOSpec, dtype
+
+@ExportSerialize.register("Sub", ImplSpec(IOSpec(dtype.any)))
+class Sub(ExportNodeCpp):
+    def __init__(self, node, mem_info):
+        super().__init__(node, mem_info)
+        self.config_template = ""
+        self.forward_template = str(
+            ROOT_EXPORT / "templates/graph_ctor/sub.jinja")
+        self.include_list = ["aidge/operator/Sub.hpp"]
+        self.kernels_to_copy = []

aidge_core/aidge_export_aidge/registry.py

+from aidge_core.export_utils import ExportLib
+from . import ROOT_EXPORT
+import aidge_core
+
+
+class ExportSerialize(ExportLib):
+    _name="export_serialize"

aidge_core/aidge_export_aidge/static/CMakeLists.txt

+cmake_minimum_required(VERSION 3.18)
+set(CXX_STANDARD 14)
+
+file(STRINGS "${CMAKE_SOURCE_DIR}/project_name.txt" project_name)
+file(STRINGS "${CMAKE_SOURCE_DIR}/version.txt" version)
+
+project(${project_name}
+        VERSION ${version}
+        DESCRIPTION "Export of aidge"
+        LANGUAGES CXX)
+
+message(STATUS "Project name: ${CMAKE_PROJECT_NAME}")
+message(STATUS "Project version: ${version}")
+
+# Note : project name is ${CMAKE_PROJECT_NAME} and python module name is also ${CMAKE_PROJECT_NAME}
+set(module_name _${CMAKE_PROJECT_NAME}) # target name
+
+##############################################
+# Define options
+option(PYBIND "python binding" ON)
+option(STANDALONE "Build standalone executable" ON)
+option(WERROR "Warning as error" OFF)
+option(TEST "Enable tests" OFF)
+option(COVERAGE "Enable coverage" OFF)
+option(ENABLE_ASAN "Enable ASan (AddressSanitizer) for runtime analysis of memory use (over/underflow, memory leak, ...)" OFF)
+
+##############################################
+# Import utils CMakeLists
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake")
+
+if(CMAKE_COMPILER_IS_GNUCXX AND COVERAGE)
+    Include(CodeCoverage)
+endif()
+
+##############################################
+# FIND Dependencies
+if(NOT $ENV{AIDGE_INSTALL} STREQUAL "")
+    set(CMAKE_INSTALL_PREFIX $ENV{AIDGE_INSTALL})
+    list(APPEND CMAKE_PREFIX_PATH $ENV{AIDGE_INSTALL})
+    message(WARNING "Env var AIDGE_INSTALL detected : $ENV{AIDGE_INSTALL}. Set CMAKE_INSTALL_PREFIX to AIDGE_INSTALL & added to CMAKE_PREFIX_PATH"
+                    "\n\tCMAKE_INSTALL_PREFIX = ${CMAKE_INSTALL_PREFIX}"
+                    "\n\tCMAKE_PREFIX_PATH = ${CMAKE_PREFIX_PATH}")
+endif()
+find_package(aidge_core REQUIRED)
+# find_package(aidge_backend_cpu REQUIRED) # example if you want to add aidge_backend_cpu as dependency to your export
+
+##############################################
+# Create target and set properties
+file(GLOB_RECURSE src_files "src/*.cpp")
+file(GLOB_RECURSE inc_files "include/*.hpp")
+
+add_library(${module_name} ${src_files} ${inc_files})
+
+target_link_libraries(${module_name}
+    PUBLIC
+        _aidge_core # _ is added because we link the exported target and not the project
+        # _aidge_backend_cpu # example if you want to add aidge_backend_cpu as dependency to your export
+)
+
+#Set target properties
+set_property(TARGET ${module_name} PROPERTY POSITION_INDEPENDENT_CODE ON)
+
+# PYTHON BINDING
+if (PYBIND)
+    include(PybindModuleCreation)
+    generate_python_binding(${CMAKE_PROJECT_NAME} ${module_name})
+endif()
+
+if( ${ENABLE_ASAN} )
+    message("Building ${module_name} with ASAN.")
+    set(SANITIZE_FLAGS -fsanitize=address -fno-omit-frame-pointer)
+    target_link_libraries(${module_name}
+        PUBLIC
+            -fsanitize=address
+    )
+    target_compile_options(${module_name}
+        PRIVATE
+            ${SANITIZE_FLAGS}
+    )
+endif()
+
+target_include_directories(${module_name}
+    PUBLIC
+        $<INSTALL_INTERFACE:include>
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    PRIVATE
+        ${CMAKE_CURRENT_SOURCE_DIR}/src
+)
+
+target_compile_features(${module_name} PRIVATE cxx_std_14)
+
+target_compile_options(${module_name} PRIVATE
+    $<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>,$<CXX_COMPILER_ID:GNU>>:
+    -Wall -Wextra -Wold-style-cast -Winline -pedantic -Werror=narrowing -Wshadow $<$<BOOL:${WERROR}>:-Werror>>)
+target_compile_options(${module_name} PRIVATE
+    $<$<CXX_COMPILER_ID:MSVC>:
+    /W4>)
+
+if(CMAKE_COMPILER_IS_GNUCXX AND COVERAGE)
+    append_coverage_compiler_flags()
+endif()
+
+##############################################
+# Installation instructions
+include(GNUInstallDirs)
+set(INSTALL_CONFIGDIR ${CMAKE_INSTALL_LIBDIR}/cmake/${CMAKE_PROJECT_NAME})
+
+install(TARGETS ${module_name} EXPORT ${CMAKE_PROJECT_NAME}-targets
+  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+)
+install(DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+
+#Export the targets to a script
+install(EXPORT ${CMAKE_PROJECT_NAME}-targets
+ FILE "${CMAKE_PROJECT_NAME}-targets.cmake"
+ DESTINATION ${INSTALL_CONFIGDIR}
+ COMPONENT ${module_name}
+)
+
+#Create a ConfigVersion.cmake file
+include(CMakePackageConfigHelpers)
+write_basic_package_version_file(
+    "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_PROJECT_NAME}-config-version.cmake"
+    VERSION ${version}
+    COMPATIBILITY AnyNewerVersion
+)
+
+configure_package_config_file("${CMAKE_PROJECT_NAME}-config.cmake.in"
+    "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_PROJECT_NAME}-config.cmake"
+    INSTALL_DESTINATION ${INSTALL_CONFIGDIR}
+)
+
+#Install the config, configversion and custom find modules
+install(FILES
+    "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_PROJECT_NAME}-config.cmake"
+    "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_PROJECT_NAME}-config-version.cmake"
+    DESTINATION ${INSTALL_CONFIGDIR}
+)
+
+##############################################
+## Exporting from the build tree
+message(STATUS "Exporting created targets to use them in another build")
+export(EXPORT ${CMAKE_PROJECT_NAME}-targets
+    FILE "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_PROJECT_NAME}-targets.cmake")
+
+if(STANDALONE)
+    if(AIDGE_REQUIRES_PYTHON AND NOT AIDGE_PYTHON_HAS_EMBED)
+        message(WARNING "Skipping compilation of standalone executable: missing Python embedded interpreter")
+    else()
+        add_executable(main main.cpp)
+        target_link_libraries(main PRIVATE ${module_name})
+    endif()
+endif()

aidge_core/aidge_export_aidge/static/README.md

+To compile:
+
+> mkdir build && cd build
+> cmake -DCMAKE_INSTALL_PREFIX:PATH=/data1/is156025/cm264821/anaconda3/envs/aidge_demo/lib/libAidge ..
+> make all install

aidge_core/aidge_export_aidge/static/cmake/PybindModuleCreation.cmake

+function(generate_python_binding name target_to_bind)
+
+    find_package(Python COMPONENTS Interpreter Development.Module)
+
+    Include(FetchContent)
+    FetchContent_Declare(
+    PyBind11
+    GIT_REPOSITORY https://github.com/pybind/pybind11.git
+    GIT_TAG        v2.10.4 # or a later release
+    )
+    FetchContent_MakeAvailable(PyBind11)
+
+    message(STATUS "Creating binding for module ${name}")
+    file(GLOB_RECURSE pybind_src_files "python_binding/*.cpp")
+
+    pybind11_add_module(${name} MODULE ${pybind_src_files} "NO_EXTRAS") # NO EXTRA recquired for pip install
+    target_include_directories(${name} PRIVATE "python_binding")
+
+    # Link target library to bind
+    target_link_libraries(${name} PRIVATE ${target_to_bind})
+
+endfunction()

aidge_core/aidge_export_aidge/static/export-config.cmake.in

+@PACKAGE_INIT@
+
+include(CMakeFindDependencyMacro)
+find_dependency(aidge_core)
+
+include(${CMAKE_CURRENT_LIST_DIR}/aidge_backend_cpu-config-version.cmake)
+
+include(${CMAKE_CURRENT_LIST_DIR}/aidge_backend_cpu-targets.cmake)

aidge_core/aidge_export_aidge/static/include/dnn.hpp

+#ifndef DNN_HPP
+#define DNN_HPP
+#include <aidge/graph/GraphView.hpp>
+/**
+ * @brief This file contains all of what is related to the construction of the
+ * neural network
+ *
+ */
+
+/**
+ * @brief This function generate the exported Aidge::GraphView.
+ *
+ * @return std::shared_ptr<Aidge::GraphView>
+ */
+std::shared_ptr<Aidge::GraphView> generateModel();
+
+#endif /* DNN_HPP */

aidge_core/aidge_export_aidge/static/main.cpp

+#include <iostream>
+#include <aidge/backend/cpu.hpp>
+
+/* Register default cpu Tensor implementation */
+#include <aidge/backend/cpu/data/TensorImpl.hpp>
+
+/* Include model generator */
+#include "include/dnn.hpp"
+
+int main()
+{
+
+    std::cout << "BEGIN" << std::endl;
+
+    std::shared_ptr<Aidge::GraphView> graph = generateModel();
+
+    std::cout << "END" << std::endl;
+
+    return 0;
+}

aidge_core/aidge_export_aidge/static/project_name.txt

+export

aidge_core/aidge_export_aidge/static/python_binding/pybind.cpp

+#include <pybind11/pybind11.h>
+
+#include "dnn.hpp"
+
+namespace py = pybind11;
+
+
+void init_export(py::module& m){
+    m.def("generate_model", generateModel);
+}
+
+PYBIND11_MODULE(export, m) {
+    init_export(m);
+}

aidge_core/aidge_export_aidge/static/version.txt

+0.0.0