diff --git a/.gitignore b/.gitignore
index 306c9d2f5409bdf2a003e63b795885f268af391a..a14ac887e7f573d4e37d483bf9b33e7de42970e6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,10 +1,11 @@
-# general
+# general
.cache
# C++ Build
build*/
install*/
cppcheck-result.xml
+include/aidge/core_version.h
# VSCode
.vscode
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3a1dc22b43ce8326e295f2dce3db52c98c07d2d7..62051da26211a3dc54f12dc34bd14ab66a0883b2 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -3,17 +3,29 @@ set(CXX_STANDARD 14)
file(STRINGS "${CMAKE_SOURCE_DIR}/version.txt" version)
+# Parse version.txt to retrieve Major, Minor and Path
+string(REGEX MATCH "([0-9]+\\.[0-9]+\\.[0-9]+)" _ MATCHES ${version})
+set(PROJECT_VERSION_MAJOR ${CMAKE_MATCH_1})
+set(PROJECT_VERSION_MINOR ${CMAKE_MATCH_2})
+set(PROJECT_VERSION_PATCH ${CMAKE_MATCH_3})
+
+# Retrieve latest git commit
+execute_process(
+ COMMAND git rev-parse --short HEAD
+ WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+ OUTPUT_VARIABLE GIT_COMMIT_HASH
+ OUTPUT_STRIP_TRAILING_WHITESPACE
+ ERROR_QUIET
+)
+
project(aidge_core
VERSION ${version}
DESCRIPTION "Core algorithms for operators and graph of the AIDGE framework"
LANGUAGES CXX)
-message(STATUS "Project name: ${CMAKE_PROJECT_NAME}")
-message(STATUS "Project version: ${version}")
-add_definitions(-DPROJECT_VERSION="${version}")
message(STATUS "Project name: ${CMAKE_PROJECT_NAME}")
message(STATUS "Project version: ${version}")
-
+message(STATUS "Latest git commit: ${GIT_COMMIT_HASH}")
# helper for LSP users
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
@@ -29,7 +41,6 @@ option(TEST "Enable tests" ON)
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")
@@ -168,6 +179,13 @@ if(NOT $ENV{AIDGE_INSTALL} STREQUAL "")
message(WARNING "CMAKE_INSTALL_PREFIX set to env variable AIDGE_INSTALL by default = ${CMAKE_INSTALL_PREFIX}")
endif()
+message(STATUS "Creating ${CMAKE_CURRENT_SOURCE_DIR}/include/aidge/core_version.h")
+# Generate version.h file from config file version.h.in
+configure_file(
+ "${CMAKE_CURRENT_SOURCE_DIR}/include/aidge/version.h.in"
+ "${CMAKE_CURRENT_SOURCE_DIR}/include/aidge/core_version.h"
+)
+
include(GNUInstallDirs)
set(INSTALL_CONFIGDIR ${CMAKE_INSTALL_LIBDIR}/cmake/${CMAKE_PROJECT_NAME})
diff --git a/MANIFEST.in b/MANIFEST.in
index ed911dd75b59b65b8bfa023584aae8585de6325b..7d4d68c220e882a3aad520fff5980fc5cf758c18 100644
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -1,8 +1,10 @@
include README.md LICENSE
-recursive-include aidge_core *.py
+recursive-include aidge_core *.py
recursive-exclude aidge_core/unit_tests *.py
recursive-include aidge_core/aidge_export_aidge *
+recursive-include aidge_core/export_utils/templates *
+
recursive-include include *.hpp
recursive-include src *.cpp
recursive-include python_binding *.cpp
diff --git a/aidge_core/__init__.py b/aidge_core/__init__.py
index 32042125ed6ecb1d935e240837afe6516706dbcb..0832de2c472d15e2ce1667cae66e4f09303a5add 100644
--- a/aidge_core/__init__.py
+++ b/aidge_core/__init__.py
@@ -13,4 +13,3 @@ import aidge_core.utils
from aidge_core.aidge_export_aidge import serialize_to_cpp
from aidge_core.show_graphview import gview_to_json
from aidge_core.mem_info import *
-from ._version import *
diff --git a/aidge_core/export_utils/data_conversion.py b/aidge_core/export_utils/data_conversion.py
index 401fc39f2a70245a67719699b5f0cdc61108e0cf..6dba5b78cd7b8e79baddb160a1110c3e830c7cd7 100644
--- a/aidge_core/export_utils/data_conversion.py
+++ b/aidge_core/export_utils/data_conversion.py
@@ -1,8 +1,9 @@
import numpy as np
import aidge_core
+from typing import Dict
-datatype_converter_aide2c = {
+datatype_converter_aidge2c = {
aidge_core.dtype.float64 : "double",
aidge_core.dtype.float32 : "float",
aidge_core.dtype.float16 : "half_float::half",
@@ -19,12 +20,31 @@ datatype_converter_aide2c = {
def aidge2c(datatype):
"""Convert a aidge datatype to C type
+ If the type is not convertible to a C type (e.g. int4), return None and raise a warning.
+
:param datatype: Aidge datatype to convert
:type datatype: :py:object:`aidge_core.DataType`
:return: A string representing the C type
:rtype: string
"""
- if datatype in datatype_converter_aide2c:
- return datatype_converter_aide2c[datatype]
+ if datatype in datatype_converter_aidge2c:
+ return datatype_converter_aidge2c[datatype]
else:
raise ValueError(f"Unsupported {datatype} aidge datatype")
+
+def aidge2export_type(datatype: aidge_core.dtype, conversion_map: Dict[aidge_core.dtype, str] = datatype_converter_aidge2c) -> str:
+ """Convert a aidge datatype to the export type specified by the map passed in argument
+
+ If the aidge type is not convertible, that is to say, is not specified in the map, a value Error is raised.
+
+ :param datatype: Aidge datatype to convert
+ :type datatype: :py:object:`aidge_core.DataType`
+ :param conversion_map: Map that specify the conversion
+ :type conversion_map: Dict[:py:object:`aidge_core.DataType`, str]
+ :return: A string representing the export type
+ :rtype: string
+ """
+ if datatype in conversion_map:
+ return conversion_map[datatype]
+ else:
+ raise ValueError(f"Unsupported type conversion {datatype} aidge datatype for export")
diff --git a/aidge_core/export_utils/export_registry.py b/aidge_core/export_utils/export_registry.py
index e5b6b2098cd760c4d425b96caf7b41cc8e82c46e..8927ae5169978da81e39912ebd4e26e2655137ad 100644
--- a/aidge_core/export_utils/export_registry.py
+++ b/aidge_core/export_utils/export_registry.py
@@ -80,6 +80,14 @@ class ExportLib(aidge_core.OperatorImpl):
aidge_core.get_key_value_Tensor(["cpu", aidge_core.dtype.uint32]))
aidge_core.register_Tensor([self._name, aidge_core.dtype.uint64],
aidge_core.get_key_value_Tensor(["cpu", aidge_core.dtype.uint64]))
+ aidge_core.register_Tensor([self._name, aidge_core.dtype.int4],
+ aidge_core.get_key_value_Tensor(["cpu", aidge_core.dtype.int4]))
+ aidge_core.register_Tensor([self._name, aidge_core.dtype.uint4],
+ aidge_core.get_key_value_Tensor(["cpu", aidge_core.dtype.uint4]))
+ aidge_core.register_Tensor([self._name, aidge_core.dtype.dual_int4],
+ aidge_core.get_key_value_Tensor(["cpu", aidge_core.dtype.dual_int4]))
+ aidge_core.register_Tensor([self._name, aidge_core.dtype.dual_uint4],
+ aidge_core.get_key_value_Tensor(["cpu", aidge_core.dtype.dual_uint4]))
@classproperty
def _export_node_registry(cls) -> Dict[str, List['ExportNode']]:
diff --git a/aidge_core/export_utils/node_export.py b/aidge_core/export_utils/node_export.py
index 5777814a0b10c49d0f75245bdc4e9681027bdfb8..c24727adf11bb936cb99c1f40312c4da8c0705f3 100644
--- a/aidge_core/export_utils/node_export.py
+++ b/aidge_core/export_utils/node_export.py
@@ -3,7 +3,8 @@ from pathlib import Path
from aidge_core.export_utils import data_conversion, code_generation
from abc import ABC, abstractmethod
-from typing import List
+from typing import List, Dict
+
def get_chan(tensor: aidge_core.Tensor) -> int:
@@ -14,12 +15,19 @@ def get_chan(tensor: aidge_core.Tensor) -> int:
return dims[1]
elif len(dims) == 2: # Suppose NC
return dims[1]
+ elif len(dims) == 1: # Suppose C (for bias)
+ return dims[0]
else:
return None
elif dformat == aidge_core.dformat.nchw:
return dims[1]
elif dformat == aidge_core.dformat.nhwc:
- return dims[3]
+ if len(dims) == 4: # NHWC
+ return dims[3]
+ elif len(dims) == 2: # NC
+ return 1
+ elif len(dims) == 1: # C for bias
+ return 1
elif dformat == aidge_core.dformat.chwn:
return dims[0]
elif dformat == aidge_core.dformat.ncdhw:
@@ -40,12 +48,19 @@ def get_height(tensor: aidge_core.Tensor) -> int:
return dims[2]
elif len(dims) == 2: # Suppose NC
return 1
+ elif len(dims) == 1: # Suppose C for bias
+ return 1
else:
return None
elif dformat == aidge_core.dformat.nchw:
return dims[2]
elif dformat == aidge_core.dformat.nhwc:
- return dims[1]
+ if len(dims) == 4: # NHWC
+ return dims[1]
+ elif len(dims) == 2: # NC
+ return 1
+ elif len(dims) == 1: # C for bias
+ return 1
elif dformat == aidge_core.dformat.chwn:
return dims[1]
elif dformat == aidge_core.dformat.ncdhw:
@@ -66,12 +81,19 @@ def get_width(tensor: aidge_core.Tensor) -> int:
return dims[3]
elif len(dims) == 2: # Suppose NC
return 1
+ elif len(dims) == 1: # Suppose C for bias
+ return 1
else:
return None
elif dformat == aidge_core.dformat.nchw:
return dims[3]
elif dformat == aidge_core.dformat.nhwc:
- return dims[2]
+ if len(dims) == 4: # NHWC
+ return dims[2]
+ elif len(dims) == 2: # NC
+ return 1
+ elif len(dims) == 1: # C for bias
+ return 1
elif dformat == aidge_core.dformat.chwn:
return dims[2]
elif dformat == aidge_core.dformat.ncdhw:
@@ -162,7 +184,9 @@ class ExportNode(ABC):
"""
@abstractmethod
- def __init__(self, aidge_node: aidge_core.Node, mem_info: List[dict]=None) -> None:
+ def __init__(self, aidge_node: aidge_core.Node,
+ mem_info: List[dict]=None,
+ conversion_map: Dict[aidge_core.dtype, str] = data_conversion.datatype_converter_aidge2c) -> None:
"""Create ExportNode and retrieve attributes from ``aidge_node``:
"""
@@ -231,8 +255,8 @@ class ExportNode(ABC):
self.attributes["in_dformat"][idx] = tensor.dformat()
self.attributes["in_format"][idx] = aidge_core.format_as(tensor.dformat())
self.attributes["in_dtype"][idx] = tensor.dtype()
- self.attributes["in_cdtype"][idx] = data_conversion.aidge2c(
- tensor.dtype())
+ # self.attributes["in_cdtype"][idx] = data_conversion.aidge2c(tensor.dtype())
+ self.attributes["in_cdtype"][idx] = data_conversion.aidge2export_type(tensor.dtype(), conversion_map)
self.attributes["in_chan"][idx] = get_chan(tensor)
self.attributes["in_height"][idx] = get_height(tensor)
self.attributes["in_width"][idx] = get_width(tensor)
@@ -254,8 +278,8 @@ class ExportNode(ABC):
self.attributes["out_dformat"][idx] = tensor.dformat()
self.attributes["out_format"][idx] = aidge_core.format_as(tensor.dformat())
self.attributes["out_dtype"][idx] = tensor.dtype()
- self.attributes["out_cdtype"][idx] = data_conversion.aidge2c(
- tensor.dtype())
+ # self.attributes["out_cdtype"][idx] = data_conversion.aidge2c(tensor.dtype())
+ self.attributes["out_cdtype"][idx] = data_conversion.aidge2export_type(tensor.dtype(), conversion_map)
self.attributes["out_chan"][idx] = get_chan(tensor)
self.attributes["out_height"][idx] = get_height(tensor)
self.attributes["out_width"][idx] = get_width(tensor)
diff --git a/aidge_core/mem_info.py b/aidge_core/mem_info.py
index 5e36eb3ee56165b9ddd2422a8e0607f79871afe8..cabc2c72ee973babdf0342ba82057f7ab0769b52 100644
--- a/aidge_core/mem_info.py
+++ b/aidge_core/mem_info.py
@@ -5,6 +5,9 @@ from pathlib import Path
import aidge_core
from typing import Tuple, List
+import matplotlib.pyplot as plt
+import aidge_core.mem_info
+import numpy as np
# Default memory management, which can be used for development
def compute_default_mem_info(scheduler: aidge_core.Scheduler) -> Tuple[int, List]:
@@ -41,20 +44,72 @@ def compute_default_mem_info(scheduler: aidge_core.Scheduler) -> Tuple[int, List
mem_info[node] = [] # No meminfo for producer
return mem_size, mem_info
+def log_meminfo(mem_manager:aidge_core.MemoryManager, path: Path, diplay_names:bool):
+ """Generate a graph representing the memory allocation of each ouputs.
-def _gnuplot_installed():
- try:
- # Run gnuplot with the --version flag and capture the output
- subprocess.run(["gnuplot", "--version"])
- return True
- except FileNotFoundError:
- aidge_core.Log.warn("Gnuplot is not installed.")
- return False
- except subprocess.CalledProcessError:
- aidge_core.Log.warn("Gnuplot command found but failed to run.")
- return False
+ Block with the smae color correspond to the same memory plane.
-def generate_optimized_memory_info(scheduler: aidge_core.Scheduler, stats_folder: Path = None, wrapping: bool = False, auto_concat: bool = False) -> Tuple[int, List[dict]]:
+ :param mem_manager: Memory manager to log
+ :type mem_manager: aidge_core.memory_manager
+ :param path: Path where to save the figure
+ :type path: Path
+ :param diplay_names: If True Node names are diplayed alongside their block
+ :type diplay_names: bool
+ """
+
+ max_lifetime = mem_manager.get_max_lifetime()
+
+ # peak_usage in kwords
+ peak_usage = mem_manager.get_peak_usage() / 1024
+
+ # Set figure size 1920x1080 px
+ plt.figure(figsize=(19.20, 10.80))
+ # Same color for each planes
+ colors = plt.cm.viridis(np.linspace(0, 1, len(mem_manager.get_planes()) + 1))
+ color_id = 1
+ for node, planes in mem_manager.get_planes().items():
+ for plane in planes:
+ cont_offset = plane.get_contiguous_offset()
+ cont_size = plane.get_contiguous_size()
+ allocated = plane.mem_space.allocated
+ released = plane.mem_space.released
+ is_released = released >= 0 and not plane.mem_space.dependencies
+ x_start = allocated
+ y_start = cont_offset / 1024.0
+ y_end = (cont_offset + cont_size) / 1024.0
+ x_end = max_lifetime if not is_released else released
+
+ plt.fill_betweenx(
+ [y_start, y_end],
+ x_start,
+ x_end + 1,
+ color=colors[color_id % len(colors)]
+ )
+
+ if diplay_names:
+ # Rotation for lisibility!
+ plt.text(x_end,y_end, node.name(), rotation=45)
+ color_id += 1
+
+ plt.xlim(0, max_lifetime + 1)
+ plt.ylim(0, peak_usage)
+ plt.axhline(y=peak_usage, color='red', linestyle='--')
+ plt.text(0, peak_usage, f'Peak usage = {peak_usage} KWords', color='red')
+ plt.xlabel("Time")
+ plt.ylabel("Memory usage (KWords)")
+ plt.title("Memory Usage Over Time")
+ plt.grid(True)
+ ax = plt.gca()
+ ax.spines['top'].set_visible(False)
+ ax.spines['right'].set_visible(False)
+ folder_path = path.parent
+ folder_path.mkdir(parents=True, exist_ok=True)
+ plt.savefig(path)
+ plt.close()
+ aidge_core.Log.notice(f"Generated memory management info at: {path}")
+
+
+def generate_optimized_memory_info(scheduler: aidge_core.Scheduler, stats_folder: Path = None, wrapping: bool = False, auto_concat: bool = False, display_names: bool=True) -> Tuple[int, List[dict]]:
"""Generates optimized memory information for a computation graph managed by a scheduler.
This function analyzes the memory usage of a computation graph, determining the memory peak
@@ -73,6 +128,8 @@ def generate_optimized_memory_info(scheduler: aidge_core.Scheduler, stats_folder
:param auto_concat: Boolean flag to enable or disable auto-concatenation optimization.
Defaults to `False`.
:type auto_concat: bool, optional
+ :param diplay_names: If True Node names are diplayed in the memory plot alongside their block, defaults to False
+ :type diplay_names: bool, optional
:return: A tuple containing the peak memory size and a list of memory information for each
scheduled node. The memory information for each node includes details such as size,
offset, stride, length, count, and optional wrap-around details.
@@ -95,18 +152,8 @@ def generate_optimized_memory_info(scheduler: aidge_core.Scheduler, stats_folder
nodes_at_input = [n[0] for n in scheduler.graph_view().inputs()]
if stats_folder is not None:
- if _gnuplot_installed():
- # Use gnuplot to generate the log
- os.makedirs(str(Path(stats_folder) / "graph"), exist_ok=True)
- mem_manager.log("memory_info")
- os.chmod("memory_info_plot.gnu", 0o777)
- os.system("./memory_info_plot.gnu")
- shutil.move("memory_info", str(Path(stats_folder) / "graph" / "memory_info"))
- shutil.move("memory_info_plot.png", str(
- Path(stats_folder) / "graph" / "memory_info_plot.png"))
- os.remove("memory_info_plot.gnu")
- else:
- aidge_core.Log.warn("Warning: gnuplot is not installed, could not generate stat folder.")
+ log_meminfo(mem_manager, Path(stats_folder) / "memory_info.png", display_names)
+
# In the export, we currently use an unified memory buffer whose size
# is determined by the memory peak usage
mem_size = mem_manager.get_peak_usage()
diff --git a/include/aidge/aidge.hpp b/include/aidge/aidge.hpp
index a06202696951a888284f1e0a50b6c25b677fe7f3..d65a46378c01b070d998b72d5d2e272b7d8f7def 100644
--- a/include/aidge/aidge.hpp
+++ b/include/aidge/aidge.hpp
@@ -11,6 +11,7 @@
#ifndef AIDGE_IMPORTS_H_
#define AIDGE_IMPORTS_H_
+#include "aidge/core_version.h"
#include "aidge/backend/OperatorImpl.hpp"
#include "aidge/backend/TensorImpl.hpp"
@@ -92,5 +93,6 @@
#include "aidge/utils/Random.hpp"
#include "aidge/utils/Registrar.hpp"
#include "aidge/utils/Types.h"
+#include "aidge/utils/sys_info/CoreVersionInfo.hpp"
#endif /* AIDGE_IMPORTS_H_ */
diff --git a/include/aidge/backend/cpu/data/TensorImpl.hpp b/include/aidge/backend/cpu/data/TensorImpl.hpp
index d04624fc530a21730cc4dc1f4f1ac90a58e6590b..4f7079e59c4328885969e7dc7181395d1333d0af 100644
--- a/include/aidge/backend/cpu/data/TensorImpl.hpp
+++ b/include/aidge/backend/cpu/data/TensorImpl.hpp
@@ -55,7 +55,7 @@ public:
T* dstT = static_cast<T *>(rawPtr(offset));
AIDGE_ASSERT(dstT < srcT || dstT >= srcT + length, "TensorImpl_cpu<{}>::copy(): overlapping copy is not supported", typeid(T).name());
- std::copy(srcT, srcT + length, dstT);
+ std::copy_n(srcT, length, dstT);
}
void copyCast(const void *src, const DataType srcDt, NbElts_t length, NbElts_t offset = 0) override final;
@@ -126,6 +126,20 @@ REGISTRAR(Tensor, {"cpu", DataType::Int64}, Aidge::TensorImpl_cpu<int64_t>::crea
REGISTRAR(Tensor, {"cpu", DataType::Int32}, Aidge::TensorImpl_cpu<int32_t>::create);
REGISTRAR(Tensor, {"cpu", DataType::Int16}, Aidge::TensorImpl_cpu<int16_t>::create);
REGISTRAR(Tensor, {"cpu", DataType::Int8}, Aidge::TensorImpl_cpu<int8_t>::create);
+REGISTRAR(Tensor, {"cpu", DataType::Int4}, Aidge::TensorImpl_cpu<int8_t>::create);
+REGISTRAR(Tensor, {"cpu", DataType::UInt4}, Aidge::TensorImpl_cpu<uint8_t>::create);
+REGISTRAR(Tensor, {"cpu", DataType::Int3}, Aidge::TensorImpl_cpu<int8_t>::create);
+REGISTRAR(Tensor, {"cpu", DataType::UInt3}, Aidge::TensorImpl_cpu<uint8_t>::create);
+REGISTRAR(Tensor, {"cpu", DataType::Int2}, Aidge::TensorImpl_cpu<int8_t>::create);
+REGISTRAR(Tensor, {"cpu", DataType::UInt2}, Aidge::TensorImpl_cpu<uint8_t>::create);
+REGISTRAR(Tensor, {"cpu", DataType::Dual_Int4}, Aidge::TensorImpl_cpu<int8_t>::create);
+REGISTRAR(Tensor, {"cpu", DataType::Dual_UInt4}, Aidge::TensorImpl_cpu<uint8_t>::create);
+REGISTRAR(Tensor, {"cpu", DataType::Dual_Int3}, Aidge::TensorImpl_cpu<int8_t>::create);
+REGISTRAR(Tensor, {"cpu", DataType::Dual_UInt3}, Aidge::TensorImpl_cpu<uint8_t>::create);
+REGISTRAR(Tensor, {"cpu", DataType::Quad_Int2}, Aidge::TensorImpl_cpu<int8_t>::create);
+REGISTRAR(Tensor, {"cpu", DataType::Quad_UInt2}, Aidge::TensorImpl_cpu<uint8_t>::create);
+REGISTRAR(Tensor, {"cpu", DataType::Binary}, Aidge::TensorImpl_cpu<int8_t>::create);
+REGISTRAR(Tensor, {"cpu", DataType::Octo_Binary}, Aidge::TensorImpl_cpu<int8_t>::create);
REGISTRAR(Tensor, {"cpu", DataType::UInt64}, Aidge::TensorImpl_cpu<uint64_t>::create);
REGISTRAR(Tensor, {"cpu", DataType::UInt32}, Aidge::TensorImpl_cpu<uint32_t>::create);
REGISTRAR(Tensor, {"cpu", DataType::UInt16}, Aidge::TensorImpl_cpu<uint16_t>::create);
diff --git a/include/aidge/data/Data.hpp b/include/aidge/data/Data.hpp
index a34718296e4ccddbfca0b4eb0daf14b08124389a..35df9c0e0bf24ee175fe27eb7c831fcae7a700e7 100644
--- a/include/aidge/data/Data.hpp
+++ b/include/aidge/data/Data.hpp
@@ -29,10 +29,14 @@ enum class DataType {
Float16,
BFloat16,
Binary,
+ Octo_Binary,
Ternary,
Int2,
+ Quad_Int2,
Int3,
+ Dual_Int3,
Int4,
+ Dual_Int4,
Int5,
Int6,
Int7,
@@ -41,8 +45,11 @@ enum class DataType {
Int32,
Int64,
UInt2,
+ Quad_UInt2,
UInt3,
+ Dual_UInt3,
UInt4,
+ Dual_UInt4,
UInt5,
UInt6,
UInt7,
@@ -117,6 +124,17 @@ private:
}
namespace {
+
+template <Aidge::DataType D> struct WeightInterleavingType { static const Aidge::DataType type; };
+template <> const Aidge::DataType WeightInterleavingType<Aidge::DataType::Int4>::type = Aidge::DataType::Dual_Int4;
+template <> const Aidge::DataType WeightInterleavingType<Aidge::DataType::UInt4>::type = Aidge::DataType::Dual_UInt4;
+template <> const Aidge::DataType WeightInterleavingType<Aidge::DataType::Int3>::type = Aidge::DataType::Dual_Int3;
+template <> const Aidge::DataType WeightInterleavingType<Aidge::DataType::UInt3>::type = Aidge::DataType::Dual_UInt3;
+template <> const Aidge::DataType WeightInterleavingType<Aidge::DataType::Int2>::type = Aidge::DataType::Quad_Int2;
+template <> const Aidge::DataType WeightInterleavingType<Aidge::DataType::UInt2>::type = Aidge::DataType::Quad_UInt2;
+template <> const Aidge::DataType WeightInterleavingType<Aidge::DataType::Binary>::type = Aidge::DataType::Octo_Binary;
+
+
template <typename T> struct NativeType { static const Aidge::DataType type; };
template <> const Aidge::DataType NativeType<double>::type = Aidge::DataType::Float64;
template <> const Aidge::DataType NativeType<float>::type = Aidge::DataType::Float32;
@@ -132,9 +150,9 @@ template <> const Aidge::DataType NativeType<std::uint64_t>::type = Aidge::DataT
template <>
const char* const EnumStrings<Aidge::DataType>::data[]
- = {"Float64", "Float32", "Float16", "BFloat16", "Binary", "Ternary",
- "Int2", "Int3", "Int4", "Int5", "Int6", "Int7", "Int8", "Int16",
- "Int32", "Int64", "UInt2", "UInt3", "UInt4", "UInt5", "UInt6",
+ = {"Float64", "Float32", "Float16", "BFloat16", "Binary", "Octo_Binary", "Ternary",
+ "Int2", "Quad_Int2", "Int3", "Dual_Int3", "Int4", "Dual_Int4", "Int5", "Int6", "Int7", "Int8", "Int16",
+ "Int32", "Int64", "UInt2", "Quad_UInt2", "UInt3", "Dual_UInt3", "UInt4", "Dual_UInt4", "UInt5", "UInt6",
"UInt7", "UInt8", "UInt16", "UInt32", "UInt64", "Any"};
template <>
@@ -147,6 +165,20 @@ template <Aidge::DataType D> struct cpptype {
template <> struct cpptype<Aidge::DataType::Float16> { using type = half_float::half; };
template <> struct cpptype<Aidge::DataType::Float32> { using type = float; };
template <> struct cpptype<Aidge::DataType::Float64> { using type = double; };
+template <> struct cpptype<Aidge::DataType::Int4> { using type = std::int8_t; };
+template <> struct cpptype<Aidge::DataType::UInt4> { using type = std::int8_t; };
+template <> struct cpptype<Aidge::DataType::Int3> { using type = std::int8_t; };
+template <> struct cpptype<Aidge::DataType::UInt3> { using type = std::int8_t; };
+template <> struct cpptype<Aidge::DataType::Int2> { using type = std::int8_t; };
+template <> struct cpptype<Aidge::DataType::UInt2> { using type = std::int8_t; };
+template <> struct cpptype<Aidge::DataType::Dual_Int4> { using type = std::int8_t; };
+template <> struct cpptype<Aidge::DataType::Dual_UInt4> { using type = std::int8_t; };
+template <> struct cpptype<Aidge::DataType::Dual_Int3> { using type = std::int8_t; };
+template <> struct cpptype<Aidge::DataType::Dual_UInt3> { using type = std::int8_t; };
+template <> struct cpptype<Aidge::DataType::Quad_Int2> { using type = std::int8_t; };
+template <> struct cpptype<Aidge::DataType::Quad_UInt2> { using type = std::int8_t; };
+template <> struct cpptype<Aidge::DataType::Binary> { using type = std::int8_t; };
+template <> struct cpptype<Aidge::DataType::Octo_Binary> { using type = std::int8_t; };
template <> struct cpptype<Aidge::DataType::Int8> { using type = std::int8_t; };
template <> struct cpptype<Aidge::DataType::Int16> { using type = std::int16_t; };
template <> struct cpptype<Aidge::DataType::Int32> { using type = std::int32_t; };
@@ -157,6 +189,7 @@ template <> struct cpptype<Aidge::DataType::UInt32> { using type = std::uint32_t
template <> struct cpptype<Aidge::DataType::UInt64> { using type = std::uint64_t; };
template <Aidge::DataType D> using cpptype_t = typename cpptype<D>::type;
+
}
diff --git a/include/aidge/data/Tensor.hpp b/include/aidge/data/Tensor.hpp
index 627a5a4784b4e6546cdfc96b65acbe2a39ee119c..fdeef2a8e20c2cd04ad31ae18a0f9b1befd5373b 100644
--- a/include/aidge/data/Tensor.hpp
+++ b/include/aidge/data/Tensor.hpp
@@ -112,7 +112,7 @@ class Tensor : public Data,
* @tparam T datatype
*/
template <typename T>
- constexpr Tensor(Vector<T> &&arr)
+ Tensor(Vector<T> &&arr)
: Data(Type),
mDataType(NativeType<T>::type),
mDims({arr.data.size()}),
@@ -204,13 +204,13 @@ class Tensor : public Data,
* Tensor and the initial one.
* @param other
*/
- Tensor(const Tensor& other) = default;
+ Tensor(const Tensor& other);
/**
* @brief Move constructor.
* @param other
*/
- Tensor(Tensor&& other) = default;
+ Tensor(Tensor&& other);
/**
* @brief Copy dimensions, datatype and data from another Tensor.
@@ -219,8 +219,8 @@ class Tensor : public Data,
* @param other other Tensor object.
* @return Tensor&
*/
- Tensor &operator=(const Tensor& other) = default;
- Tensor &operator=(Tensor&& other) = default;
+ Tensor &operator=(const Tensor& other);
+ Tensor &operator=(Tensor&& other);
template <typename T>
constexpr Tensor &operator=(Vector<T> &&arr) {
diff --git a/include/aidge/graph/Connector.hpp b/include/aidge/graph/Connector.hpp
index 599ca7d6defd729b6e6536dcc95f326d345701d9..ec59e1b38c10cbe53eb667b724991ea8e5427a6e 100644
--- a/include/aidge/graph/Connector.hpp
+++ b/include/aidge/graph/Connector.hpp
@@ -11,10 +11,10 @@
#ifndef AIDGE_CORE_GRAPH_CONNECTOR_H_
#define AIDGE_CORE_GRAPH_CONNECTOR_H_
-#include <cassert>
#include <memory>
#include <vector>
+#include "aidge/utils/ErrorHandling.hpp"
#include "aidge/utils/Types.h"
namespace Aidge {
@@ -55,7 +55,7 @@ class Connector {
public:
Connector operator[](IOIndex_t index) {
- assert((size() > 1) && "Cannot refer a slice of the output.");
+ AIDGE_ASSERT((size() > 1), "Cannot refer a slice of the output.");
return Connector(mNode, index);
}
@@ -68,7 +68,7 @@ class Connector {
private:
Connector(std::shared_ptr<Node> node, IOIndex_t index) : mNode(node) {
- assert((index != gk_IODefaultIndex) && (index < size()) &&
+ AIDGE_ASSERT((index != gk_IODefaultIndex) && (index < size()),
"Non-valid output index.\n");
mOutputId = index;
}
diff --git a/include/aidge/graph/GraphView.hpp b/include/aidge/graph/GraphView.hpp
index 76f5dcdfc28e90a3f83435841af21048bcb2a9c0..e122aa446bde05abdce2a1fe0899c1fec52e4dba 100644
--- a/include/aidge/graph/GraphView.hpp
+++ b/include/aidge/graph/GraphView.hpp
@@ -424,21 +424,7 @@ public:
addChild(toOtherNode, mNodeRegistry.at(fromOutNodeName), fromTensor, toTensor);
}
- inline void updateNodeName(const std::shared_ptr<Node>& node, const std::string& newName){
- if (!newName.empty()) {
- auto itNew = mNodeRegistry.insert(std::make_pair(newName, node));
- if (!itNew.second) {
- Log::notice("Replacing existing node name in graph node name registry: {}", newName);
- (itNew.first)->second = node;
- }
- }
-
- if (!node->name().empty()) {
- const auto it = mNodeRegistry.find(node->name());
- AIDGE_ASSERT(it != mNodeRegistry.end(), "No node named {} in graph {}, the graph may be corrupted !", node->name(), name());
- mNodeRegistry.erase(it);
- }
- }
+ void updateNodeName(const std::shared_ptr<Node>& node, const std::string& newName);
/**
* @brief Include a GraphView content in the current GraphView and link
diff --git a/include/aidge/graph/Matching.hpp b/include/aidge/graph/Matching.hpp
index 3b0874580b112f4c219886a78677e6c9801b72b8..c8de86e90989a6313f47b1b06dea401d5ebd6600 100644
--- a/include/aidge/graph/Matching.hpp
+++ b/include/aidge/graph/Matching.hpp
@@ -12,9 +12,12 @@
#ifndef AIDGE_CORE_GRAPH_MATCHING_H_
#define AIDGE_CORE_GRAPH_MATCHING_H_
+#include <functional>
#include <map>
#include <memory>
#include <set>
+#include <string>
+
#include "aidge/graph/Node.hpp"
#include "aidge/graph/GraphView.hpp"
@@ -43,10 +46,10 @@ public:
bool singleOutput = true;
IOIndex_t edgeLeftIdx = 0;
IOIndex_t edgeRightIdx = 0;
- NodePtr startNode;
+ std::shared_ptr<Node> startNode;
// For check & debug purpose:
- size_t depth = 0;
+ std::size_t depth = 0;
std::set<std::string> anchors;
};
@@ -56,8 +59,8 @@ public:
// We use graph->rootNode() as the std::set key, which is guaranteed
// to never change after insertion!
mutable std::shared_ptr<GraphView> graph;
- mutable std::map<std::string, std::map<std::string, NodePtr>> anchors;
- mutable NodePtr startNode;
+ mutable std::map<std::string, std::map<std::string, std::shared_ptr<Node>>> anchors;
+ mutable std::shared_ptr<Node> startNode;
MatchingResult();
@@ -66,11 +69,14 @@ public:
~MatchingResult() noexcept;
};
+ SinglePassGraphMatching() = delete;
SinglePassGraphMatching(std::shared_ptr<GraphView> graph) : mGraph(graph) {}
SinglePassGraphMatching(const SinglePassGraphMatching& other);
- SinglePassGraphMatching& operator=(const SinglePassGraphMatching& other);
+
~SinglePassGraphMatching() noexcept;
+ SinglePassGraphMatching& operator=(const SinglePassGraphMatching& other);
+
/**
* Matches a query by direct, single pass parse and match.
* The returned matches are non-ordered and therefore stored in a std::set.
@@ -141,26 +147,26 @@ public:
/**
* @brief Same as match() but with a mandatory start node.
- *
+ *
* @param startNode Mandatory start node for the query.
* @param query The query to search.
* @return MatchingResult MatchingResult struct, with empty graph if query
* is not found, or the graph corresponding to the query.
*/
- MatchingResult matchFrom(NodePtr startNode, const std::string& query);
+ MatchingResult matchFrom(std::shared_ptr<Node> startNode, const std::string& query);
/**
* Filter to keep only the longest disjoint (non-overlapping) matches.
*/
std::set<MatchingResult> filterLonguestDisjoint(const std::set<MatchingResult>& matches);
- inline void addNodeLambda(const std::string& name, std::function<bool(const NodePtr&)> func) {
+ inline void addNodeLambda(const std::string& name, std::function<bool(const std::shared_ptr<Node>&)> func) {
mLambda[name] = func;
}
private:
std::shared_ptr<GraphView> mGraph;
- std::map<std::string, std::function<bool(const NodePtr&)>> mLambda;
+ std::map<std::string, std::function<bool(const std::shared_ptr<Node>&)>> mLambda;
/**
* QUANTIFIER = '?' | '*' | '+' | ('{' [0-9]+ '}')
@@ -205,13 +211,6 @@ private:
*/
bool matchNode(Context& ctx, std::set<MatchingResult>& matches);
- inline void removeWhiteSpace(std::string& str) {
- str.erase(str.begin(),
- std::find_if(str.begin(),
- str.end(),
- [](char c) { return !std::isspace(c); }));
- }
-
struct CompareMatchingResultSize {
bool operator()(const MatchingResult& lhs, const MatchingResult& rhs) const {
// Some matches size could be the same
@@ -225,10 +224,8 @@ private:
};
};
-inline bool operator<(const Aidge::SinglePassGraphMatching::MatchingResult& lhs, const Aidge::SinglePassGraphMatching::MatchingResult& rhs) {
- // Matches rootNode are guaranteed to be different!
- return lhs.graph->rootNode() < rhs.graph->rootNode();
-}
+bool operator<(const SinglePassGraphMatching::MatchingResult& lhs, const SinglePassGraphMatching::MatchingResult& rhs);
+
} // namespace Aidge
#endif /* AIDGE_CORE_GRAPH_MATCHING_H_ */
diff --git a/include/aidge/graph/Node.hpp b/include/aidge/graph/Node.hpp
index a16bbd63ecf52e8c97d5032c5c90a5f69186f995..a57ccc91f48ca3285eb8be6ff85a1dbb4aef6d52 100644
--- a/include/aidge/graph/Node.hpp
+++ b/include/aidge/graph/Node.hpp
@@ -12,13 +12,13 @@
#ifndef AIDGE_CORE_GRAPH_NODE_H_
#define AIDGE_CORE_GRAPH_NODE_H_
-#include <cassert>
+#include <deque>
+#include <functional>
#include <memory>
#include <set>
#include <string>
#include <vector>
-#include <deque>
-#include <utility>
+#include <utility> // std::pair
#ifdef PYBIND
#include <pybind11/pybind11.h>
@@ -27,7 +27,9 @@
#include "aidge/graph/Connector.hpp"
#include "aidge/operator/Operator.hpp"
+#include "aidge/utils/DynamicAttributes.hpp"
#include "aidge/utils/Types.h"
+#include "aidge/utils/ErrorHandling.hpp"
#ifdef PYBIND
namespace py = pybind11;
@@ -131,7 +133,7 @@ public:
* @brief Name of the Node.
* @return std::string
*/
- inline std::string name() const noexcept { return mAttrs->getAttr<std::string>("name"); }
+ std::string name() const noexcept { return mAttrs->getAttr<std::string>("name"); }
/**
* @brief Set the Node name.
@@ -175,7 +177,7 @@ public:
* @brief Get the Operator object of the Node.
* @return std::shared_ptr<Operator>
*/
- inline std::shared_ptr<Operator> getOperator() const { return (*mOperator)(mAttrs); }
+ inline std::shared_ptr<Operator> getOperator() const { return mOperator; }
// inline std::shared_ptr<Operator> getOperator() const { return mOperator; }
///////////////////////////////////////////////////////
@@ -212,7 +214,7 @@ public:
* @return std::pair<std::shared_ptr<Node>, IOIndex_t>
*/
inline std::pair<NodePtr, IOIndex_t> input(const IOIndex_t inID) const {
- assert((inID != gk_IODefaultIndex) && (inID < nbInputs()) && "Input index out of bound.");
+ AIDGE_ASSERT((inID != gk_IODefaultIndex) && (inID < nbInputs()), "Input index out of bound.");
return std::pair<NodePtr, IOIndex_t>(mParents[inID], mIdOutParents[inID]);
}
@@ -261,7 +263,7 @@ public:
* @details [data, data, weight, bias] => 4
* @return IOIndex_t
*/
- inline IOIndex_t nbInputs() const noexcept { return getOperator()->nbInputs(); }
+ inline IOIndex_t nbInputs() const noexcept { return mOperator->nbInputs(); }
/**
* @brief Category of a specific input (Data or Param, optional or not).
@@ -269,7 +271,7 @@ public:
* @return InputCategory
*/
inline InputCategory inputCategory(IOIndex_t idx) const {
- return getOperator()->inputCategory(idx);
+ return mOperator->inputCategory(idx);
}
/**
@@ -279,7 +281,7 @@ public:
* @return true if the operator defines it as a back edge
*/
inline bool parentIsBackEdge(IOIndex_t idx) const {
- return getOperator()->isBackEdge(idx);
+ return mOperator->isBackEdge(idx);
}
/**
@@ -292,7 +294,7 @@ public:
* @brief Getter for the number of Output Tensors of the Node.
* @return IOIndex_t
*/
- inline IOIndex_t nbOutputs() const noexcept { return getOperator()->nbOutputs(); }
+ inline IOIndex_t nbOutputs() const noexcept { return mOperator->nbOutputs(); }
IOIndex_t nbValidOutputs() const;
@@ -304,15 +306,7 @@ public:
* @brief Set of pointers to each GraphView containing this Node
* @return std::set<GraphView>
*/
- inline std::set<std::shared_ptr<GraphView>> views() const noexcept {
- std::set<std::shared_ptr<GraphView>> res;
- for (const auto &v : mViews) {
- if (auto p = v.lock()) {
- res.insert(p);
- }
- }
- return res;
- }
+ std::set<std::shared_ptr<GraphView>> views() const noexcept;
/**
* @brief Add a GraphView pointer to the list of GraphView containing
@@ -323,7 +317,7 @@ public:
mViews.insert(std::weak_ptr<GraphView>(graphPtr));
}
- inline void removeView(const std::shared_ptr<GraphView> &graphPtr) {
+ void removeView(const std::shared_ptr<GraphView> &graphPtr) {
mViews.erase(graphPtr);
}
@@ -368,7 +362,6 @@ public:
* @return std::shared_ptr<Node>&
*/
inline NodePtr &getParent(const IOIndex_t inId) {
- assert(inId != gk_IODefaultIndex);
return mParents.at(inId);
}
diff --git a/include/aidge/graph/StaticAnalysis.hpp b/include/aidge/graph/StaticAnalysis.hpp
index d3fe681749eeb69e4816a38f302d510f1c81381a..cc5532224ebd00f17aefbf5c2620a3ef15cfaa2a 100644
--- a/include/aidge/graph/StaticAnalysis.hpp
+++ b/include/aidge/graph/StaticAnalysis.hpp
@@ -13,13 +13,12 @@
#ifndef AIDGE_CORE_GRAPH_STATICANALYSIS_H_
#define AIDGE_CORE_GRAPH_STATICANALYSIS_H_
+#include <cstddef> // std::size_t
#include <memory>
+#include <string>
-#include "aidge/utils/Registrar.hpp"
-#include "aidge/graph/GraphView.hpp"
#include "aidge/data/Tensor.hpp"
-#include "aidge/operator/OperatorTensor.hpp"
-
+#include "aidge/graph/GraphView.hpp"
#include "aidge/operator/AvgPooling.hpp"
#include "aidge/operator/Producer.hpp"
#include "aidge/operator/Conv.hpp"
@@ -27,125 +26,131 @@
#include "aidge/operator/FC.hpp"
#include "aidge/operator/MatMul.hpp"
#include "aidge/operator/MaxPooling.hpp"
+#include "aidge/operator/Operator.hpp"
+#include "aidge/operator/OperatorTensor.hpp"
#include "aidge/operator/ReduceMean.hpp"
#include "aidge/operator/ReduceSum.hpp"
#include "aidge/operator/Softmax.hpp"
#include "aidge/operator/MetaOperator.hpp"
+#include "aidge/utils/Registrar.hpp"
namespace Aidge {
/**
* @brief Base class to compute statistics from an Operator.
- *
+ *
*/
class OperatorStats : public Registrable<OperatorStats, std::string, std::function<std::shared_ptr<OperatorStats>(const Operator&)>> {
public:
+ OperatorStats() = delete;
OperatorStats(const Operator& op);
- const Operator& getOperator() const noexcept { return mOp; }
+
+ virtual ~OperatorStats();
+
+ inline const Operator& getOperator() const noexcept { return mOp; }
/**
- * @brief Get the worst case total number of arithmetic operations for the
+ * @brief Get the worst case total number of arithmetic operations for the
* operator data flow. This includes base arithmetic operations: +, -, / and *.
- * Control flow operations (loop counters, index computation...) and memory
+ * Control flow operations (loop counters, index computation...) and memory
* accesses are not included.
- * A naive implementation is considered (more operations might be required
+ * A naive implementation is considered (more operations might be required
* for numerical stability in an actual implementation).
* Example of Operator with only arithmetic operations: Conv.
- *
- * @return size_t Number of arithmetic operations.
+ *
+ * @return std::size_t Number of arithmetic operations.
*/
- virtual size_t getNbArithmOps() const { return 2 * getNbMACOps(); };
+ virtual std::size_t getNbArithmOps() const { return 2 * getNbMACOps(); };
/**
- * @brief Get the worst case total number of logic operations for the
+ * @brief Get the worst case total number of logic operations for the
* operator data flow. This includes operations like logical shift, or, and...
- * Control flow operations (loop counters, index computation...) and memory
+ * Control flow operations (loop counters, index computation...) and memory
* accesses are not included.
- * A naive implementation is considered (more operations might be required
+ * A naive implementation is considered (more operations might be required
* for numerical stability in an actual implementation).
* Example of Operator with only logic operations: BitShift.
- *
- * @return size_t Number of logic operations.
+ *
+ * @return std::size_t Number of logic operations.
*/
- virtual size_t getNbLogicOps() const { return 0; };
+ virtual std::size_t getNbLogicOps() const { return 0; };
/**
- * @brief Get the worst case total number of comparison operations for the
+ * @brief Get the worst case total number of comparison operations for the
* operator data flow. This includes operations like <, >, =...
- * Control flow operations (loop counters, index computation...) and memory
+ * Control flow operations (loop counters, index computation...) and memory
* accesses are not included.
- * A naive implementation is considered (more operations might be required
+ * A naive implementation is considered (more operations might be required
* for numerical stability in an actual implementation).
* Example of Operator with only comparison operations: MaxPool.
- *
- * @return size_t Number of comparison operations.
+ *
+ * @return std::size_t Number of comparison operations.
*/
- virtual size_t getNbCompOps() const { return 0; };
+ virtual std::size_t getNbCompOps() const { return 0; };
/**
* @brief Get the worst case total number of non-linear (NL) operations for the
* operator data flow. This includes operations like calls to tanh(), erf(), cos()...
- * Control flow operations (loop counters, index computation...) and memory
+ * Control flow operations (loop counters, index computation...) and memory
* accesses are not included.
- * A naive implementation is considered (more operations might be required
+ * A naive implementation is considered (more operations might be required
* for numerical stability in an actual implementation).
* Example of Operator with only NL operations: Tanh.
* Non-linear operations are necessarily of floating-point type.
- *
- * @return size_t Number of non-linear (NL) operations.
+ *
+ * @return std::size_t Number of non-linear (NL) operations.
*/
- virtual size_t getNbNLOps() const { return 0; };
+ virtual std::size_t getNbNLOps() const { return 0; };
/**
* @brief Get the worst case total number of operations for the operator data flow.
* Total number of operations = arithmetic ops + logic ops + comp ops + NL ops.
- * Control flow operations (loop counters, index computation...) and memory
+ * Control flow operations (loop counters, index computation...) and memory
* accesses are not included.
- * A naive implementation is considered (more operations might be required
+ * A naive implementation is considered (more operations might be required
* for numerical stability in an actual implementation).
- *
- * @return size_t Number of operations.
+ *
+ * @return std::size_t Number of operations.
*/
- size_t getNbOps() const { return getNbArithmOps() + getNbLogicOps() + getNbCompOps() + getNbNLOps(); };
+ std::size_t getNbOps() const { return getNbArithmOps() + getNbLogicOps() + getNbCompOps() + getNbNLOps(); };
/**
* @brief Get the worst case total number of INT arithmetic operations for
* the operator data flow.
* Such that getNbArithmOps() = getNbArithmIntOps() + getNbArithmFpOps()
- * Control flow operations (loop counters, index computation...) and memory
+ * Control flow operations (loop counters, index computation...) and memory
* accesses are not included.
- * A naive implementation is considered (more operations might be required
+ * A naive implementation is considered (more operations might be required
* for numerical stability in an actual implementation).
- *
- * @return size_t Number of INT arithmetic operations.
+ *
+ * @return std::size_t Number of INT arithmetic operations.
*/
- virtual size_t getNbArithmIntOps() const;
+ virtual std::size_t getNbArithmIntOps() const;
/**
- * @brief Get the worst case total number of FP arithmetic operations for
+ * @brief Get the worst case total number of FP arithmetic operations for
* the operator data flow.
* Such that getNbArithmOps() = getNbArithmIntOps() + getNbArithmFpOps()
- * Control flow operations (loop counters, index computation...) and memory
+ * Control flow operations (loop counters, index computation...) and memory
* accesses are not included.
- * A naive implementation is considered (more operations might be required
+ * A naive implementation is considered (more operations might be required
* for numerical stability in an actual implementation).
- *
- * @return size_t Number of FP arithmetic operations.
+ *
+ * @return std::size_t Number of FP arithmetic operations.
*/
- size_t getNbArithmFpOps() const { return getNbArithmOps() - getNbArithmIntOps(); };
+ std::size_t getNbArithmFpOps() const { return getNbArithmOps() - getNbArithmIntOps(); };
/**
* @brief Get the worst case total number of MAC operations for the operator
- * data flow. MAC operations are included in getNbArithmOps(), with 1 MAC
+ * data flow. MAC operations are included in getNbArithmOps(), with 1 MAC
* operation counted as 2 arithmetic operations. MAC can be INT of FP.
- * Control flow operations (loop counters, index computation...) and memory
+ * Control flow operations (loop counters, index computation...) and memory
* accesses are not included.
- * A naive implementation is considered (more operations might be required
+ * A naive implementation is considered (more operations might be required
* for numerical stability in an actual implementation).
- *
- * @return size_t Number of MAC operations.
+ *
+ * @return std::size_t Number of MAC operations.
*/
- virtual size_t getNbMACOps() const { return 0; };
- virtual ~OperatorStats() = default;
+ virtual std::size_t getNbMACOps() const { return 0; };
protected:
const Operator &mOp;
@@ -153,16 +158,20 @@ protected:
/**
* @brief Base class to compute statistics from a GraphView
- *
+ *
*/
class StaticAnalysis : public std::enable_shared_from_this<StaticAnalysis> {
public:
+ StaticAnalysis() = delete;
StaticAnalysis(std::shared_ptr<GraphView> graph);
- const std::shared_ptr<GraphView> getGraph() const noexcept { return mGraph; }
+
+ virtual ~StaticAnalysis();
+
+ inline const std::shared_ptr<GraphView> getGraph() const noexcept { return mGraph; }
/**
* @brief Get the Operator Stats object corresponding to the given node.
- *
+ *
* @param node Node
* @return std::shared_ptr<OperatorStats> Node's Operator stats
*/
@@ -172,65 +181,67 @@ public:
* @brief Get the number of parameters associated to a node. This includes
* all Producers directly connected to the node's inputs as well as all
* internal Producers (in case of a meta operator).
- *
+ *
* Note: this function does not check if parameters are shared between
* several nodes or not. This means that simply adding parameters count from
* several nodes may lead to a higher number of parameters than in reality
* if some of them are shared.
- *
+ *
* @param node Node
- * @return size_t Number of parameters
+ * @return std::size_t Number of parameters
*/
- virtual size_t getNbParams(std::shared_ptr<Node> node) const;
+ virtual std::size_t getNbParams(std::shared_ptr<Node> node) const;
/**
* @brief Get the total parameters memory size, in bits, associated to a node.
- * This includes all Producers directly connected to the node's inputs as
+ * This includes all Producers directly connected to the node's inputs as
* well as all internal Producers (in case of a meta operator).
- *
+ *
* Note: this function does not check if parameters are shared between
* several nodes or not. This means that simply adding parameters size from
* several nodes may lead to a higher parameter size than in reality
* if some of them are shared.
- *
+ *
* @param node Node
- * @return size_t Total parameters memory, in bits
+ * @return std::size_t Total parameters memory, in bits
*/
- virtual size_t getParamsSize(std::shared_ptr<Node> node) const;
-
- size_t getNbArithmOps() const { return accumulate(&OperatorStats::getNbArithmOps); }
- size_t getNbLogicOps() const { return accumulate(&OperatorStats::getNbLogicOps); }
- size_t getNbCompOps() const { return accumulate(&OperatorStats::getNbCompOps); }
- size_t getNbNLOps() const { return accumulate(&OperatorStats::getNbNLOps); }
- size_t getNbOps() const { return accumulate(&OperatorStats::getNbOps); }
- size_t getNbArithmIntOps() const { return accumulate(&OperatorStats::getNbArithmIntOps); }
- size_t getNbArithmFpOps() const { return accumulate(&OperatorStats::getNbArithmFpOps); }
- size_t getNbMACOps() const { return accumulate(&OperatorStats::getNbMACOps); }
+ virtual std::size_t getParamsSize(std::shared_ptr<Node> node) const;
+
+ std::size_t getNbArithmOps() const;
+ std::size_t getNbLogicOps() const;
+ std::size_t getNbCompOps() const;
+ std::size_t getNbNLOps() const;
+ std::size_t getNbOps() const;
+ std::size_t getNbArithmIntOps() const;
+ std::size_t getNbArithmFpOps() const;
+ std::size_t getNbMACOps() const;
virtual void summary(bool incProducers = false) const;
- virtual ~StaticAnalysis() = default;
protected:
const std::shared_ptr<GraphView> mGraph;
- size_t accumulate(size_t (OperatorStats::*func)() const) const;
+ std::size_t accumulate(std::size_t (OperatorStats::*func)() const) const;
};
////////////////////////////////////////////////////////////////////////////////
class MetaOpStats : public OperatorStats {
public:
+ MetaOpStats() = delete;
MetaOpStats(const Operator& op) : OperatorStats(op) {}
+ ~MetaOpStats();
+
static std::unique_ptr<MetaOpStats> create(const Operator& op) {
return std::make_unique<MetaOpStats>(op);
}
- size_t getNbArithmOps() const override { return StaticAnalysis(dynamic_cast<const MetaOperator_Op&>(mOp).getMicroGraph()).getNbArithmOps(); }
- size_t getNbLogicOps() const override { return StaticAnalysis(dynamic_cast<const MetaOperator_Op&>(mOp).getMicroGraph()).getNbLogicOps(); }
- size_t getNbCompOps() const override { return StaticAnalysis(dynamic_cast<const MetaOperator_Op&>(mOp).getMicroGraph()).getNbCompOps(); }
- size_t getNbNLOps() const override { return StaticAnalysis(dynamic_cast<const MetaOperator_Op&>(mOp).getMicroGraph()).getNbNLOps(); }
- size_t getNbArithmIntOps() const override { return StaticAnalysis(dynamic_cast<const MetaOperator_Op&>(mOp).getMicroGraph()).getNbArithmIntOps(); }
- size_t getNbMACOps() const override { return StaticAnalysis(dynamic_cast<const MetaOperator_Op&>(mOp).getMicroGraph()).getNbMACOps(); }
+ std::size_t getNbArithmOps() const override;
+ std::size_t getNbLogicOps() const override;
+ std::size_t getNbCompOps() const override;
+ std::size_t getNbNLOps() const override;
+ std::size_t getNbArithmIntOps() const override;
+ std::size_t getNbMACOps() const override;
};
template <class OP>
@@ -242,7 +253,7 @@ public:
return std::make_unique<ConvStats<OP>>(op);
}
- size_t getNbMACOps() const override {
+ std::size_t getNbMACOps() const override {
const OP& op_ = dynamic_cast<const OP&>(mOp);
AIDGE_ASSERT(op_.dimsForwarded(), "Dims must be forwarded for static analysis");
const std::size_t weightsSize = op_.getInput(1)->size();
@@ -250,7 +261,7 @@ public:
= std::accumulate(op_.getOutput(0)->dims().cbegin() + 2,
op_.getOutput(0)->dims().cend(),
1,
- std::multiplies<size_t>()); // NCHW...
+ std::multiplies<std::size_t>()); // NCHW...
const std::size_t batchSize = op_.getInput(0)->dims()[0]; // NCHW
return batchSize * (weightsSize * outputSize);
}
@@ -271,19 +282,19 @@ public:
return std::make_unique<MaxPoolingStats<OP>>(op);
}
- size_t getNbCompOps() const override {
+ std::size_t getNbCompOps() const override {
const OP& op_ = dynamic_cast<const OP&>(mOp);
AIDGE_ASSERT(op_.dimsForwarded(), "Dims must be forwarded for static analysis");
const std::size_t poolSize
= std::accumulate(op_.kernelDims().cbegin(),
op_.kernelDims().cend(),
1,
- std::multiplies<size_t>());
+ std::multiplies<std::size_t>());
const std::size_t outputSize
= std::accumulate(op_.getOutput(0)->dims().cbegin() + 2,
op_.getOutput(0)->dims().cend(),
1,
- std::multiplies<size_t>()); // NCHW...
+ std::multiplies<std::size_t>()); // NCHW...
const std::size_t batchSize = op_.getInput(0)->dims()[0]; // NCHW
return batchSize * ((poolSize - 1) * outputSize);
}
@@ -302,19 +313,19 @@ public:
return std::make_unique<AvgPoolingStats<OP>>(op);
}
- size_t getNbArithmOps() const override {
+ std::size_t getNbArithmOps() const override {
const OP& op_ = dynamic_cast<const OP&>(mOp);
AIDGE_ASSERT(op_.dimsForwarded(), "Dims must be forwarded for static analysis");
const std::size_t poolSize
= std::accumulate(op_.kernelDims().cbegin(),
op_.kernelDims().cend(),
1,
- std::multiplies<size_t>());
+ std::multiplies<std::size_t>());
const std::size_t outputSize
= std::accumulate(op_.getOutput(0)->dims().cbegin() + 2,
op_.getOutput(0)->dims().cend(),
1,
- std::multiplies<size_t>()); // NCHW...
+ std::multiplies<std::size_t>()); // NCHW...
const std::size_t batchSize = op_.getInput(0)->dims()[0]; // NCHW
// (poolSize - 1) additions + 1 division for each output
return batchSize * (poolSize * outputSize);
@@ -334,7 +345,7 @@ public:
return std::make_unique<FCStats>(op);
}
- size_t getNbMACOps() const override {
+ std::size_t getNbMACOps() const override {
const FC_Op& op_ = dynamic_cast<const FC_Op&>(mOp);
AIDGE_ASSERT(op_.dimsForwarded(), "Dims must be forwarded for static analysis");
const std::size_t weightsSize = op_.getInput(1)->size();
@@ -353,20 +364,20 @@ public:
return std::make_unique<MatMulStats>(op);
}
- size_t getNbMACOps() const override {
+ std::size_t getNbMACOps() const override {
const MatMul_Op& op_ = dynamic_cast<const MatMul_Op&>(mOp);
AIDGE_ASSERT(op_.dimsForwarded(), "Dims must be forwarded for static analysis");
- const size_t n = (op_.getInput(0)->dims().size() > 1)
+ const std::size_t n = (op_.getInput(0)->dims().size() > 1)
? op_.getInput(0)->dims().end()[-2] : 1;
- const size_t k = op_.getInput(0)->dims().back();
- const size_t m = (op_.getInput(1)->dims().size() > 1)
+ const std::size_t k = op_.getInput(0)->dims().back();
+ const std::size_t m = (op_.getInput(1)->dims().size() > 1)
? op_.getInput(1)->dims().back() : 1;
- const size_t nb = (op_.getInput(0)->dims().size() > 2)
+ const std::size_t nb = (op_.getInput(0)->dims().size() > 2)
? std::accumulate(op_.getInput(0)->dims().cbegin(),
op_.getInput(0)->dims().cend() - 2,
1,
- std::multiplies<size_t>())
- : 1;
+ std::multiplies<std::size_t>())
+ : 1;
return nb * n * m * k;
}
@@ -382,7 +393,7 @@ public:
return std::make_unique<ReLUStats>(op);
}
- size_t getNbCompOps() const override {
+ std::size_t getNbCompOps() const override {
const OperatorTensor& op_ = dynamic_cast<const OperatorTensor&>(mOp);
AIDGE_ASSERT(op_.dimsForwarded(), "Dims must be forwarded for static analysis");
return op_.getOutput(0)->size();
@@ -399,14 +410,14 @@ public:
return std::make_unique<AbsStats>(op);
}
- size_t getNbCompOps() const override {
+ std::size_t getNbCompOps() const override {
const OperatorTensor& op_ = dynamic_cast<const OperatorTensor&>(mOp);
AIDGE_ASSERT(op_.dimsForwarded(), "Dims must be forwarded for static analysis");
return op_.getOutput(0)->size();
}
// This is in the worst case (all values are negative)
- size_t getNbArithmOps() const override {
+ std::size_t getNbArithmOps() const override {
const OperatorTensor& op_ = dynamic_cast<const OperatorTensor&>(mOp);
AIDGE_ASSERT(op_.dimsForwarded(), "Dims must be forwarded for static analysis");
return op_.getOutput(0)->size();
@@ -423,12 +434,12 @@ public:
return std::make_unique<ReduceMeanStats>(op);
}
- size_t getNbArithmOps() const override {
+ std::size_t getNbArithmOps() const override {
const ReduceMean_Op& op_ = dynamic_cast<const ReduceMean_Op&>(mOp);
AIDGE_ASSERT(op_.dimsForwarded(), "Dims must be forwarded for static analysis");
- const size_t nbIn = op_.getInput(0)->size();
- const size_t nbOut = op_.getOutput(0)->size();
- const size_t nbReduce = nbIn / nbOut;
+ const std::size_t nbIn = op_.getInput(0)->size();
+ const std::size_t nbOut = op_.getOutput(0)->size();
+ const std::size_t nbReduce = nbIn / nbOut;
// (nbReduce - 1) additions + 1 division for each output
return nbOut * nbReduce;
}
@@ -444,12 +455,12 @@ public:
return std::make_unique<ReduceSumStats>(op);
}
- size_t getNbArithmOps() const override {
+ std::size_t getNbArithmOps() const override {
const ReduceSum_Op& op_ = dynamic_cast<const ReduceSum_Op&>(mOp);
AIDGE_ASSERT(op_.dimsForwarded(), "Dims must be forwarded for static analysis");
- const size_t nbIn = op_.getInput(0)->size();
- const size_t nbOut = op_.getOutput(0)->size();
- const size_t nbReduce = nbIn / nbOut;
+ const std::size_t nbIn = op_.getInput(0)->size();
+ const std::size_t nbOut = op_.getOutput(0)->size();
+ const std::size_t nbReduce = nbIn / nbOut;
// (nbReduce - 1) additions for each output
return nbOut * (nbReduce - 1);
}
@@ -465,22 +476,22 @@ public:
return std::make_unique<SoftmaxStats>(op);
}
- size_t getNbArithmOps() const override {
+ std::size_t getNbArithmOps() const override {
const Softmax_Op& op_ = dynamic_cast<const Softmax_Op&>(mOp);
AIDGE_ASSERT(op_.dimsForwarded(), "Dims must be forwarded for static analysis");
- const size_t axis = (op_.axis() >= 0) ? op_.axis() : op_.getInput(0)->nbDims() + op_.axis();
- const size_t nbReduce = op_.getInput(0)->dims()[axis];
- const size_t nbOut = op_.getOutput(0)->size();
+ const std::size_t axis = (op_.axis() >= 0) ? op_.axis() : op_.getInput(0)->nbDims() + op_.axis();
+ const std::size_t nbReduce = op_.getInput(0)->dims()[axis];
+ const std::size_t nbOut = op_.getOutput(0)->size();
// nbOut divisions + (nbReduce - 1) additions
return nbOut + (nbReduce - 1);
}
- size_t getNbNLOps() const override {
+ std::size_t getNbNLOps() const override {
const Softmax_Op& op_ = dynamic_cast<const Softmax_Op&>(mOp);
AIDGE_ASSERT(op_.dimsForwarded(), "Dims must be forwarded for static analysis");
- const size_t axis = (op_.axis() >= 0) ? op_.axis() : op_.getInput(0)->nbDims() + op_.axis();
- const size_t nbReduce = op_.getInput(0)->dims()[axis];
- const size_t nbOut = op_.getOutput(0)->size();
+ const std::size_t axis = (op_.axis() >= 0) ? op_.axis() : op_.getInput(0)->nbDims() + op_.axis();
+ const std::size_t nbReduce = op_.getInput(0)->dims()[axis];
+ const std::size_t nbOut = op_.getOutput(0)->size();
// nbOut exp + nbReduce exp
return nbOut + nbReduce;
}
@@ -515,7 +526,7 @@ public:
return std::make_unique<ElemWiseOpStats>(op);
}
- size_t getNbArithmOps() const override {
+ std::size_t getNbArithmOps() const override {
const OperatorTensor& op_ = dynamic_cast<const OperatorTensor&>(mOp);
AIDGE_ASSERT(op_.dimsForwarded(), "Dims must be forwarded for static analysis");
return op_.getOutput(0)->size();
@@ -535,7 +546,7 @@ public:
return std::make_unique<ElemWiseLogicOpStats>(op);
}
- size_t getNbArithmOps() const override {
+ std::size_t getNbArithmOps() const override {
const OperatorTensor& op_ = dynamic_cast<const OperatorTensor&>(mOp);
AIDGE_ASSERT(op_.dimsForwarded(), "Dims must be forwarded for static analysis");
return op_.getOutput(0)->size();
@@ -552,7 +563,7 @@ public:
return std::make_unique<ElemWiseNLOpStats>(op);
}
- size_t getNbNLOps() const override {
+ std::size_t getNbNLOps() const override {
const OperatorTensor& op_ = dynamic_cast<const OperatorTensor&>(mOp);
AIDGE_ASSERT(op_.dimsForwarded(), "Dims must be forwarded for static analysis");
return op_.getOutput(0)->size();
diff --git a/include/aidge/operator/ArgMax.hpp b/include/aidge/operator/ArgMax.hpp
index 13f63ce98c526f0c57a363ada4e7f50ccdbfb83b..a2d344cba3dd7af3b6f0b2b4078852afcd0ae8cf 100644
--- a/include/aidge/operator/ArgMax.hpp
+++ b/include/aidge/operator/ArgMax.hpp
@@ -52,12 +52,12 @@ public:
/**
* @brief constructor for ArgMax op
* @param[in] axis around which perform the operation
- * @param[in] keep_dims if true we set a dimension of 1 in the place of the reduced axis and
+ * @param[in] keep_dims if true we set a dimension of 1 in the place of the reduced axis and
* if false we remove the dimension completely
- * @param[in] select_last_index in case we have many maximum, if true the last index is returned
- * if false the first index is returned.
+ * @param[in] select_last_index in case we have many maximum, if true the last index is returned
+ * if false the first index is returned.
*/
- ArgMax_Op(std::int32_t axis, bool keep_dims, bool select_last_index)
+ ArgMax_Op(std::int32_t axis = 0, bool keep_dims = true, bool select_last_index = false)
: OperatorTensor(Type, {InputCategory::Data}, 1),
mAttributes(std::make_shared<Attributes_>(
attr<ArgMaxAttr::Axis>(axis),
@@ -69,24 +69,13 @@ public:
* @brief Copy-constructor. Copy the operator attributes and its output tensor(s), but not its input tensors (the new operator has no input associated).
* @param op Operator to copy.
*/
- ArgMax_Op(const ArgMax_Op& op)
- : OperatorTensor(op),
- mAttributes(op.mAttributes)
- {
- if (op.mImpl){
- SET_IMPL_MACRO(ArgMax_Op, *this, op.backend());
- } else {
- mImpl = nullptr;
- }
- }
+ ArgMax_Op(const ArgMax_Op& op);
/**
* @brief Clone the operator using its copy-constructor.
* @see Operator::ArgMax_Op
*/
- std::shared_ptr<Operator> clone() const override {
- return std::make_shared<ArgMax_Op>(*this);
- }
+ std::shared_ptr<Operator> clone() const override;
bool forwardDims(bool allowDataDependency = false) override final;
@@ -114,17 +103,14 @@ public:
* @param axis Dimension over which data max should be computed.
* @param keep_dims Whether or not reduced dimensions are to be erased.
* @param select_last_index Whether to select the last index of max elements in case there are many maximums.
- * By default the first max element index is
+ * By default the first max element index is
* @param name Name of the Operator.
* @return std::shared_ptr<Node> Node containing the Operator.
*/
-inline std::shared_ptr<Node> ArgMax(std::int32_t axis=0,
- bool keep_dims=true,
- bool select_last_index=false,
- const std::string& name = "") {
- return std::make_shared<Node>(std::make_shared<ArgMax_Op>(axis, keep_dims, select_last_index), name);
-
-}
+std::shared_ptr<Node> ArgMax(std::int32_t axis = 0,
+ bool keep_dims = true,
+ bool select_last_index = false,
+ const std::string& name = "");
} // namespace Aidge
diff --git a/include/aidge/operator/Operator.hpp b/include/aidge/operator/Operator.hpp
index 95698b751a9f0f4c0cc8e716eb5140ee74e21a3f..5f148e126b889c422392923fa33ea1cffbbd654e 100644
--- a/include/aidge/operator/Operator.hpp
+++ b/include/aidge/operator/Operator.hpp
@@ -12,11 +12,11 @@
#ifndef AIDGE_CORE_OPERATOR_OPERATOR_H_
#define AIDGE_CORE_OPERATOR_OPERATOR_H_
+#include <cstddef>
#include <memory>
#include <string>
#include <vector>
#include <utility>
-#include <cstddef>
#ifdef PYBIND
#include <pybind11/pybind11.h>
@@ -49,11 +49,19 @@ enum class InputCategory {
class Operator : public std::enable_shared_from_this<Operator> {
protected:
- std::shared_ptr<OperatorImpl> mImpl; // implementation of the operator
- std::shared_ptr<DynamicAttributes> mInheritedAttrs;
+ /** Implementation of the operator. */
+ std::shared_ptr<OperatorImpl> mImpl;
+ /** Attributes of the associated Node.
+ *
+ * Default to empty vector for copy construction because two Operator cannot
+ * be associated to the same Node.
+ */
+ std::vector<std::shared_ptr<DynamicAttributes>> mInheritedAttrs{};
private:
+ /** Type of Operator. */
std::string mType;
+ /** Type of data the Operator should handle. */
const OperatorType mOperatorType;
const std::vector<InputCategory> mInputsCategory;
const IOIndex_t mNbOut;
@@ -82,18 +90,34 @@ public:
// Implementation is never cloned. It is up to the non-abstract Operator copy-constructor to create a new implementation matching the copied Operator implementation.
// See https://gitlab.eclipse.org/eclipse/aidge/aidge_core/-/merge_requests/8#note_1214050 for the discussion.
}
- std::shared_ptr<Operator> operator()(std::shared_ptr<DynamicAttributes> attrs) {
- mInheritedAttrs = attrs;
- return shared_from_this();
- }
+ // std::shared_ptr<Operator> operator()(std::shared_ptr<DynamicAttributes> attrs) {
+ // mInheritedAttrs = attrs;
+ // return shared_from_this();
+ // }
virtual ~Operator() noexcept;
public:
+ void setInheritedAttrs(std::shared_ptr<DynamicAttributes>& attr) {
+ mInheritedAttrs.push_back(attr);
+ }
virtual std::shared_ptr<Operator> clone() const = 0;
virtual std::shared_ptr<Attributes> attributes() const { return nullptr; };
- virtual std::shared_ptr<DynamicAttributes> inheritedAttributes() const { return mInheritedAttrs; };
+
+ /**
+ * @brief Get the currently associated Node's attributes.
+ * @return Shared pointer to the Attributes of the associated Node.
+ *
+ * If no Node as be associated to the Operator, returns a `nullptr`.
+ * @note As Operators have only been tested with a single associated Node,
+ * only attributes of the first associated Node are returned. This should be
+ * updated.
+ */
+ virtual std::shared_ptr<DynamicAttributes> inheritedAttributes() const {
+ return mInheritedAttrs.empty() ? nullptr : mInheritedAttrs[0];
+ }
+
/**
* @brief Set the specified input with a shallow copy.
* @param inputIdx Index of the input to set.
diff --git a/include/aidge/operator/OperatorTensor.hpp b/include/aidge/operator/OperatorTensor.hpp
index 19e2f13e4ff39fee181c6ad0cf2fbab510f22c3e..5a4fcb5f492bb60899f00e11f35793df0e65789f 100644
--- a/include/aidge/operator/OperatorTensor.hpp
+++ b/include/aidge/operator/OperatorTensor.hpp
@@ -43,7 +43,7 @@ public:
/**
* @brief Operator tensor constructor. This function is not meant to be called directly but by a derived class constructor
* every operator class derive from this class.
- *
+ *
* @param[in] type : type of operator (i.e. "Add", "AveragePool",...)
* @param[in] inputsCategory : describes the type of each input.
* @param[in] nbOut : Number of tensors this operator will output
@@ -67,11 +67,14 @@ public:
// input management
void setInput(const IOIndex_t inputIdx, const std::shared_ptr<Data>& data) override;
const std::shared_ptr<Tensor>& getInput(const IOIndex_t inputIdx) const;
+ virtual const std::vector<std::shared_ptr<Tensor>>& getInputs() const;
std::shared_ptr<Data> getRawInput(const IOIndex_t inputIdx) const override final;
// output management
void setOutput(const IOIndex_t outputIdx, const std::shared_ptr<Data>& data) const override;
virtual const std::shared_ptr<Tensor>& getOutput(const IOIndex_t outputIdx) const;
+ virtual const std::vector<std::shared_ptr<Tensor>>& getOutputs() const;
+
std::shared_ptr<Aidge::Data> getRawOutput(const Aidge::IOIndex_t outputIdx) const override final;
///////////////////////////////////////////////////
@@ -94,7 +97,7 @@ public:
* - TOKEN mode means that forwarddims will only ensure that all inputs and outputs of the graph the node is within are connected.
* @param[in] allowDataDependency if set to true, this means that this operator output dimensions depends on the dimensions of optional parameter tensors.
* @return true if dims have been properly forwarded. false otherwise. If set to false, then forwardDims will enter in token mode.
- *
+ *
*/
virtual bool forwardDims(bool allowDataDependency = false);
virtual bool dimsForwarded() const;
@@ -110,4 +113,4 @@ protected:
};
} // namespace Aidge
-#endif // AIDGE_CORE_OPERATOR_OPERATORTENSOR_H_
\ No newline at end of file
+#endif // AIDGE_CORE_OPERATOR_OPERATORTENSOR_H_
diff --git a/include/aidge/operator/Slice.hpp b/include/aidge/operator/Slice.hpp
index 5bb07ae01d8f076891a803698d2b3f489d90b462..bf98736f0cab95b4ad618d1bee0850520144428d 100644
--- a/include/aidge/operator/Slice.hpp
+++ b/include/aidge/operator/Slice.hpp
@@ -31,6 +31,10 @@ public:
void forward() override;
};
+// Implementation note:
+// If start or end are out of bound then it takes the max value for the given axe.
+// Example Slice with start=1, end=1000, axes=0 for tensor [0, 1, 2, 3]
+// Will return [1, 2, 3]
enum class SliceAttr { Starts, Ends, Axes, Steps };
class Slice_Op
diff --git a/include/aidge/operator/WeightInterleaving.hpp b/include/aidge/operator/WeightInterleaving.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..e9e51441aab7772ca5cbb26195c94a0a837d7157
--- /dev/null
+++ b/include/aidge/operator/WeightInterleaving.hpp
@@ -0,0 +1,83 @@
+/********************************************************************************
+ * 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
+ *
+ ********************************************************************************/
+
+#ifndef AIDGE_CORE_OPERATOR_WEIGHTINTERLEAVING_H_
+#define AIDGE_CORE_OPERATOR_WEIGHTINTERLEAVING_H_
+
+#include <cassert>
+#include <memory>
+#include <vector>
+
+#include "aidge/backend/OperatorImpl.hpp"
+#include "aidge/graph/Node.hpp"
+#include "aidge/operator/OperatorTensor.hpp"
+#include "aidge/utils/ErrorHandling.hpp"
+#include "aidge/utils/Registrar.hpp"
+#include "aidge/utils/Types.h"
+
+
+namespace Aidge {
+
+class WeightInterleaving_Op :
+ public OperatorTensor,
+ public Registrable<WeightInterleaving_Op, // <Op, backend, implementation creation function>
+ std::string,
+ std::function<std::shared_ptr<OperatorImpl>(const WeightInterleaving_Op&)>>
+{
+public:
+ static const std::string Type;
+
+ WeightInterleaving_Op() : OperatorTensor(Type, {InputCategory::Data}, 1) {}
+
+ /**
+ * @brief Copy-constructor.
+ * @param op WeightInterleaving_Op to copy.
+ * @details Copies the operator attributes and its output tensor(s), but not
+ * its input tensors. The new operator has no associated input.
+ */
+ WeightInterleaving_Op(const WeightInterleaving_Op& op);
+
+ /**
+ * @brief Clone the operator using its copy-constructor.
+ * @see Operator::WeightInterleaving_Op
+ */
+ std::shared_ptr<Operator> clone() const override;
+
+ bool forwardDims(bool allowDataDependency = false) override final;
+
+ void setBackend(const std::string& name, DeviceIdx_t device = 0) override final;
+ std::set<std::string> getAvailableBackends() const override;
+
+ static const std::vector<std::string> getInputsName(){
+ return {"data_input"};
+ }
+ static const std::vector<std::string> getOutputsName(){
+ return {"data_output"};
+ }
+
+ /**
+ * @brief Calculates the required size for the 8-bits`compactData` vector.
+ *
+ * This function determines the minimum number of bytes needed in `compactData`
+ * to store `dataSize` elements compacted to `nb_bits` bits each.
+ *
+ * @param dataSize The total number of elements in the input data array.
+ * @param nb_bits The number of bits to use for each compacted element (from 1 to 7).
+ * @return std::size_t The required size in bytes for `compactData`.
+ */
+ std::size_t compactDataSize(std::size_t dataSize, std::uint8_t nb_bits);
+
+};
+
+std::shared_ptr<Node> WeightInterleaving(const std::string& name = "");
+}
+
+#endif /* AIDGE_CORE_OPERATOR_RELU_H_ */
diff --git a/include/aidge/recipes/Recipes.hpp b/include/aidge/recipes/Recipes.hpp
index aa4d3ae1b79d3feb04eb1db7623633174a15c7ce..0a3f5dc4d0ea00ddb5c8d0b8885269c882f7f705 100644
--- a/include/aidge/recipes/Recipes.hpp
+++ b/include/aidge/recipes/Recipes.hpp
@@ -186,19 +186,24 @@ size_t convToMatMul(std::shared_ptr<GraphView> graph);
*/
void adaptToBackend(std::shared_ptr<GraphView> graph);
-// /**
-// * @brief The node passed contains an operator which input of index 1 is supposed be be weights of type Int4, Int3, Int2, binary.
-// * This recipie only operates memory transformations on the weight tensor.
-// * First, permutes the dimensions to match the dataformat NHWC
-// * Second, compact the last dimension (Channel dimension) into int8_t
-// *
-// * @param node Node
-// */
-// void applyWeightInterleaving(std::shared_ptr<Node> node);
-
+/**
+ * @brief Create a GenericOp from an Operator and replace it
+ *
+ * @param node Node which Operator will be changed into a generic Operator
+ */
void toGenericOp(std::shared_ptr<Node> node);
+/**
+ * @brief The node passed contains an operator which input of index 1 is supposed be be weights of type Int4, Int3, Int2, binary.
+ * This recipie only operates memory transformations on the weight tensor.
+ * First, permutes the dimensions to match the dataformat NHWC
+ * Second, compact the last dimension of the weights (Channel dimension) into 8bits
+ *
+ * @param node Node
+ */
+void applyWeightInterleaving(std::shared_ptr<Node> node);
+
} // namespace Aidge
#endif /* AIDGE_CORE_UTILS_RECIPES_H_ */
diff --git a/include/aidge/utils/DynamicAttributes.hpp b/include/aidge/utils/DynamicAttributes.hpp
index 0fc350f1a10227e417f3b09baf2c7bebeb84d875..6ac76c138e2a835f8e74c5ede26e449c537d61d2 100644
--- a/include/aidge/utils/DynamicAttributes.hpp
+++ b/include/aidge/utils/DynamicAttributes.hpp
@@ -365,7 +365,7 @@ public:
static inline typename std::enable_if<!has_less_than_operator<T>::value, void>::type makeTypeConditionallyAvailable() {}
template<typename T>
- static inline typename std::enable_if<has_less_than_operator<T>::value, void>::type makeTypeConditionallyAvailable() {
+ static typename std::enable_if<has_less_than_operator<T>::value, void>::type makeTypeConditionallyAvailable() {
mAnyUtils.emplace(typeid(T), std::unique_ptr<AnyUtils<T>>(new AnyUtils<T>()));
}
@@ -388,7 +388,7 @@ struct DynamicAttributes::AnyUtils<py::object> : public DynamicAttributes::AnyUt
size_t hash(const future_std::any& attr) const override final {
// Here we are mixing Python and C++ hashes... if both are
- // well implemented, this should not increase the collision
+ // well implemented, this should not increase the collision
// probability for the same number of stored hashes.
return py::hash(future_std::any_cast<py::object>(attr));
}
diff --git a/include/aidge/utils/Log.hpp b/include/aidge/utils/Log.hpp
index d6851f1e42233f9d8af88d10da9046f73f94b8c4..bc99ab7c0362f5bfa4c2f1bbc01f3089d28d699f 100644
--- a/include/aidge/utils/Log.hpp
+++ b/include/aidge/utils/Log.hpp
@@ -19,7 +19,6 @@
#include <fmt/ranges.h>
#include "aidge/data/half_fmt.hpp"
-
#include "aidge/utils/Attributes.hpp"
namespace Aidge {
diff --git a/include/aidge/utils/sys_info/CoreVersionInfo.hpp b/include/aidge/utils/sys_info/CoreVersionInfo.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..648998ede84a886315be9f26dfde68e7abddd345
--- /dev/null
+++ b/include/aidge/utils/sys_info/CoreVersionInfo.hpp
@@ -0,0 +1,37 @@
+#ifndef AIDGE_UTILS_SYS_INFO_CORE_VERSION_INFO_H
+#define AIDGE_UTILS_SYS_INFO_CORE_VERSION_INFO_H
+
+#include "aidge/utils/Log.hpp"
+#include "aidge/core_version.h"
+
+namespace Aidge {
+
+constexpr inline const char * getCoreProjectVersion(){
+ return PROJECT_VERSION;
+}
+
+constexpr inline const char * getCoreGitHash(){
+ return PROJECT_GIT_HASH;
+}
+
+void showCoreVersion() {
+ Log::info("Aidge core: {} ({}), {} {}", getCoreProjectVersion(), getCoreGitHash(), __DATE__, __TIME__);
+ // Compiler version
+ #if defined(__clang__)
+ /* Clang/LLVM. ---------------------------------------------- */
+ Log::info("Clang/LLVM compiler version: {}.{}.{}\n", __clang_major__ , __clang_minor__, __clang_patchlevel__);
+ #elif defined(__ICC) || defined(__INTEL_COMPILER)
+ /* Intel ICC/ICPC. ------------------------------------------ */
+ Log::info("Intel ICC/ICPC compiler version: {}\n", __INTEL_COMPILER);
+ #elif defined(__GNUC__) || defined(__GNUG__)
+ /* GNU GCC/G++. --------------------------------------------- */
+ Log::info("GNU GCC/G++ compiler version: {}.{}.{}", __GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__);
+ #elif defined(_MSC_VER)
+ /* Microsoft Visual Studio. --------------------------------- */
+ Log::info("Microsoft Visual Studio compiler version: {}\n", _MSC_VER);
+ #else
+ Log::info("Unknown compiler\n");
+ #endif
+}
+} // namespace Aidge
+#endif // AIDGE_UTILS_SYS_INFO_CORE_VERSION_INFO_H
diff --git a/include/aidge/version.h.in b/include/aidge/version.h.in
new file mode 100644
index 0000000000000000000000000000000000000000..4b876f63002972c1f8f1340b70cdecdace911012
--- /dev/null
+++ b/include/aidge/version.h.in
@@ -0,0 +1,11 @@
+#ifndef VERSION_H
+#define VERSION_H
+
+namespace Aidge {
+static constexpr const int PROJECT_VERSION_MAJOR = @PROJECT_VERSION_MAJOR@;
+static constexpr const int PROJECT_VERSION_MINOR = @PROJECT_VERSION_MINOR@;
+static constexpr const int PROJECT_VERSION_PATCH = @PROJECT_VERSION_PATCH@;
+static constexpr const char * PROJECT_VERSION = "@PROJECT_VERSION_MAJOR@.@PROJECT_VERSION_MINOR@.@PROJECT_VERSION_PATCH@";
+static constexpr const char * PROJECT_GIT_HASH = "@GIT_COMMIT_HASH@";
+}
+#endif // VERSION_H
diff --git a/pyproject.toml b/pyproject.toml
index b838aca5ee100d182ba88b79f23f3a2ebff9acf3..610b5f8c226fcf2f040a6d6c22cffcb0498a0f8d 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,18 +1,27 @@
[project]
-name = "aidge_core"
+name="aidge_core"
+
description="Core algorithms for operators and graph of the AIDGE framework"
dependencies = [
"numpy>=1.21.6",
- "Jinja2>=3.1.2"
+ "Jinja2>=3.1.2",
+ "matplotlib"
]
requires-python = ">= 3.7"
readme = "README.md"
license = { file = "LICENSE" }
-classifiers = [
+classifiers = [
"Development Status :: 2 - Pre-Alpha",
"Programming Language :: Python :: 3"
]
-dynamic = ["version"] # defined in tool.setuptools_scm
+dynamic = ["version"] # defined by pbr
+
+[project.urls]
+Homepage = "https://www.deepgreen.ai/en/platform"
+Documentation = "https://eclipse-aidge.readthedocs.io/en/latest/"
+Repository = "https://gitlab.eclipse.org/eclipse/aidge/aidge_core"
+Issues = "https://gitlab.eclipse.org/eclipse/aidge/aidge_core/-/issues/"
+Changelog = "https://gitlab.eclipse.org/eclipse/aidge/aidge_core/-/releases"
[project.optional-dependencies]
test = [
@@ -22,8 +31,8 @@ test = [
[build-system]
requires = [
"setuptools>=64",
- "setuptools_scm[toml]==7.1.0",
- "cmake>=3.18.4.post1"
+ "cmake>=3.18.4.post1",
+ "pbr"
]
build-backend = "setuptools.build_meta"
@@ -40,11 +49,7 @@ exclude = [ # exclude packages matching these glob patterns (empty by default)
".unit_tests.static",
".aidge_export_aidge.__pycache__",
".aidge_export_aidge.utils.__pycache__",
-]
-
-# SETUPTOOLS_SCM
-[tool.setuptools_scm]
-write_to = "aidge_core/_version.py"
+]
#####################################################
# CIBUILDWHEEL
diff --git a/python_binding/data/pybind_Tensor.cpp b/python_binding/data/pybind_Tensor.cpp
index 0d4ed716ca6c65c2e8a0153a729ebecef771ea9e..35e60e1589ce5599affbc2b466171acc6bf4ef01 100644
--- a/python_binding/data/pybind_Tensor.cpp
+++ b/python_binding/data/pybind_Tensor.cpp
@@ -226,6 +226,8 @@ static T castToNativeType(const py::object val_obj) {
DataType dtype;
getConservativeNativeVal(val_obj, &val, &dtype);
switch (dtype) {
+ case DataType::Int4:
+ return (T)val.i8;
case DataType::Int8:
return (T)val.i8;
case DataType::Int16:
@@ -353,6 +355,22 @@ void init_Tensor(py::module& m){
return py::cast(b.get<float>(idx));
case DataType::Int8:
return py::cast(b.get<std::int8_t>(idx));
+ case DataType::Int4:
+ return py::cast(b.get<std::int8_t>(idx));
+ case DataType::Dual_Int4:
+ return py::cast(b.get<std::int8_t>(idx));
+ case DataType::Int3:
+ return py::cast(b.get<std::int8_t>(idx));
+ case DataType::Dual_Int3:
+ return py::cast(b.get<std::int8_t>(idx));
+ case DataType::Int2:
+ return py::cast(b.get<std::int8_t>(idx));
+ case DataType::Quad_Int2:
+ return py::cast(b.get<std::int8_t>(idx));
+ case DataType::Binary:
+ return py::cast(b.get<std::int8_t>(idx));
+ case DataType::Octo_Binary:
+ return py::cast(b.get<std::int8_t>(idx));
case DataType::Int16:
return py::cast(b.get<std::int16_t>(idx));
case DataType::Int32:
@@ -361,6 +379,18 @@ void init_Tensor(py::module& m){
return py::cast(b.get<std::int64_t>(idx));
case DataType::UInt8:
return py::cast(b.get<std::uint8_t>(idx));
+ case DataType::UInt4:
+ return py::cast(b.get<std::uint8_t>(idx));
+ case DataType::Dual_UInt4:
+ return py::cast(b.get<std::uint8_t>(idx));
+ case DataType::UInt3:
+ return py::cast(b.get<std::uint8_t>(idx));
+ case DataType::Dual_UInt3:
+ return py::cast(b.get<std::uint8_t>(idx));
+ case DataType::UInt2:
+ return py::cast(b.get<std::uint8_t>(idx));
+ case DataType::Quad_UInt2:
+ return py::cast(b.get<std::uint8_t>(idx));
case DataType::UInt16:
return py::cast(b.get<std::uint16_t>(idx));
case DataType::UInt32:
@@ -380,6 +410,22 @@ void init_Tensor(py::module& m){
return py::cast(b.get<float>(coordIdx));
case DataType::Int8:
return py::cast(b.get<std::int8_t>(coordIdx));
+ case DataType::Int4:
+ return py::cast(b.get<std::int8_t>(coordIdx));
+ case DataType::Dual_Int4:
+ return py::cast(b.get<std::int8_t>(coordIdx));
+ case DataType::Int3:
+ return py::cast(b.get<std::int8_t>(coordIdx));
+ case DataType::Dual_Int3:
+ return py::cast(b.get<std::int8_t>(coordIdx));
+ case DataType::Int2:
+ return py::cast(b.get<std::int8_t>(coordIdx));
+ case DataType::Quad_Int2:
+ return py::cast(b.get<std::int8_t>(coordIdx));
+ case DataType::Binary:
+ return py::cast(b.get<std::int8_t>(coordIdx));
+ case DataType::Octo_Binary:
+ return py::cast(b.get<std::int8_t>(coordIdx));
case DataType::Int16:
return py::cast(b.get<std::int16_t>(coordIdx));
case DataType::Int32:
@@ -388,6 +434,18 @@ void init_Tensor(py::module& m){
return py::cast(b.get<std::int64_t>(coordIdx));
case DataType::UInt8:
return py::cast(b.get<std::uint8_t>(coordIdx));
+ case DataType::UInt4:
+ return py::cast(b.get<std::uint8_t>(coordIdx));
+ case DataType::Dual_UInt4:
+ return py::cast(b.get<std::uint8_t>(coordIdx));
+ case DataType::UInt3:
+ return py::cast(b.get<std::uint8_t>(coordIdx));
+ case DataType::Dual_UInt3:
+ return py::cast(b.get<std::uint8_t>(coordIdx));
+ case DataType::UInt2:
+ return py::cast(b.get<std::uint8_t>(coordIdx));
+ case DataType::Quad_UInt2:
+ return py::cast(b.get<std::uint8_t>(coordIdx));
case DataType::UInt16:
return py::cast(b.get<std::uint16_t>(coordIdx));
case DataType::UInt32:
@@ -410,6 +468,30 @@ void init_Tensor(py::module& m){
case DataType::Int8:
b.set(idx, castToNativeType<std::int8_t>(val));
break;
+ case DataType::Int4:
+ b.set(idx, castToNativeType<std::int8_t>(val));
+ break;
+ case DataType::Dual_Int4:
+ b.set(idx, castToNativeType<std::int8_t>(val));
+ break;
+ case DataType::Int3:
+ b.set(idx, castToNativeType<std::int8_t>(val));
+ break;
+ case DataType::Dual_Int3:
+ b.set(idx, castToNativeType<std::int8_t>(val));
+ break;
+ case DataType::Int2:
+ b.set(idx, castToNativeType<std::int8_t>(val));
+ break;
+ case DataType::Quad_Int2:
+ b.set(idx, castToNativeType<std::int8_t>(val));
+ break;
+ case DataType::Binary:
+ b.set(idx, castToNativeType<std::int8_t>(val));
+ break;
+ case DataType::Octo_Binary:
+ b.set(idx, castToNativeType<std::int8_t>(val));
+ break;
case DataType::Int16:
b.set(idx, castToNativeType<std::int16_t>(val));
break;
@@ -422,6 +504,24 @@ void init_Tensor(py::module& m){
case DataType::UInt8:
b.set(idx, castToNativeType<std::uint8_t>(val));
break;
+ case DataType::UInt4:
+ b.set(idx, castToNativeType<std::uint8_t>(val));
+ break;
+ case DataType::Dual_UInt4:
+ b.set(idx, castToNativeType<std::uint8_t>(val));
+ break;
+ case DataType::UInt3:
+ b.set(idx, castToNativeType<std::uint8_t>(val));
+ break;
+ case DataType::Dual_UInt3:
+ b.set(idx, castToNativeType<std::uint8_t>(val));
+ break;
+ case DataType::UInt2:
+ b.set(idx, castToNativeType<std::uint8_t>(val));
+ break;
+ case DataType::Quad_UInt2:
+ b.set(idx, castToNativeType<std::uint8_t>(val));
+ break;
case DataType::UInt16:
b.set(idx, castToNativeType<std::uint16_t>(val));
break;
@@ -448,6 +548,30 @@ void init_Tensor(py::module& m){
case DataType::Int8:
b.set(coordIdx, castToNativeType<std::int8_t>(val));
break;
+ case DataType::Int4:
+ b.set(coordIdx, castToNativeType<std::int8_t>(val));
+ break;
+ case DataType::Dual_Int4:
+ b.set(coordIdx, castToNativeType<std::int8_t>(val));
+ break;
+ case DataType::Int3:
+ b.set(coordIdx, castToNativeType<std::int8_t>(val));
+ break;
+ case DataType::Dual_Int3:
+ b.set(coordIdx, castToNativeType<std::int8_t>(val));
+ break;
+ case DataType::Int2:
+ b.set(coordIdx, castToNativeType<std::int8_t>(val));
+ break;
+ case DataType::Quad_Int2:
+ b.set(coordIdx, castToNativeType<std::int8_t>(val));
+ break;
+ case DataType::Binary:
+ b.set(coordIdx, castToNativeType<std::int8_t>(val));
+ break;
+ case DataType::Octo_Binary:
+ b.set(coordIdx, castToNativeType<std::int8_t>(val));
+ break;
case DataType::Int16:
b.set(coordIdx, castToNativeType<std::int16_t>(val));
break;
@@ -460,6 +584,24 @@ void init_Tensor(py::module& m){
case DataType::UInt8:
b.set(coordIdx, castToNativeType<std::uint8_t>(val));
break;
+ case DataType::UInt4:
+ b.set(coordIdx, castToNativeType<std::uint8_t>(val));
+ break;
+ case DataType::Dual_UInt4:
+ b.set(coordIdx, castToNativeType<std::uint8_t>(val));
+ break;
+ case DataType::UInt3:
+ b.set(coordIdx, castToNativeType<std::uint8_t>(val));
+ break;
+ case DataType::Dual_UInt3:
+ b.set(coordIdx, castToNativeType<std::uint8_t>(val));
+ break;
+ case DataType::UInt2:
+ b.set(coordIdx, castToNativeType<std::uint8_t>(val));
+ break;
+ case DataType::Quad_UInt2:
+ b.set(coordIdx, castToNativeType<std::uint8_t>(val));
+ break;
case DataType::UInt16:
b.set(coordIdx, castToNativeType<std::uint16_t>(val));
break;
@@ -497,6 +639,48 @@ void init_Tensor(py::module& m){
case DataType::Float32:
dataFormatDescriptor = py::format_descriptor<float>::format();
break;;
+ case DataType::Int4:
+ dataFormatDescriptor = py::format_descriptor<std::int8_t>::format();
+ break;
+ case DataType::UInt4:
+ dataFormatDescriptor = py::format_descriptor<std::uint8_t>::format();
+ break;
+ case DataType::Int3:
+ dataFormatDescriptor = py::format_descriptor<std::int8_t>::format();
+ break;
+ case DataType::UInt3:
+ dataFormatDescriptor = py::format_descriptor<std::uint8_t>::format();
+ break;
+ case DataType::Int2:
+ dataFormatDescriptor = py::format_descriptor<std::int8_t>::format();
+ break;
+ case DataType::UInt2:
+ dataFormatDescriptor = py::format_descriptor<std::uint8_t>::format();
+ break;
+ case DataType::Dual_Int4:
+ dataFormatDescriptor = py::format_descriptor<std::int8_t>::format();
+ break;
+ case DataType::Dual_UInt4:
+ dataFormatDescriptor = py::format_descriptor<std::uint8_t>::format();
+ break;
+ case DataType::Dual_Int3:
+ dataFormatDescriptor = py::format_descriptor<std::int8_t>::format();
+ break;
+ case DataType::Dual_UInt3:
+ dataFormatDescriptor = py::format_descriptor<std::uint8_t>::format();
+ break;
+ case DataType::Quad_Int2:
+ dataFormatDescriptor = py::format_descriptor<std::int8_t>::format();
+ break;
+ case DataType::Quad_UInt2:
+ dataFormatDescriptor = py::format_descriptor<std::uint8_t>::format();
+ break;
+ case DataType::Binary:
+ dataFormatDescriptor = py::format_descriptor<std::int8_t>::format();
+ break;
+ case DataType::Octo_Binary:
+ dataFormatDescriptor = py::format_descriptor<std::int8_t>::format();
+ break;
case DataType::Int8:
dataFormatDescriptor = py::format_descriptor<std::int8_t>::format();
break;
diff --git a/python_binding/operator/pybind_Operator.cpp b/python_binding/operator/pybind_Operator.cpp
index ded3b54088e6d1ed473ed614e23fc08cd89a0346..2191d866f2a2b1f1d490b2016de97afd8ec8157b 100644
--- a/python_binding/operator/pybind_Operator.cpp
+++ b/python_binding/operator/pybind_Operator.cpp
@@ -61,6 +61,7 @@ void init_Operator(py::module& m){
)mydelimiter")
.def("associate_input", &Operator::associateInput, py::arg("inputIdx"), py::arg("data"))
.def("set_datatype", &Operator::setDataType, py::arg("dataType"))
+ .def("set_dataformat", &Operator::setDataFormat, py::arg("dataFormat"))
.def("set_backend", py::overload_cast<const std::string&, DeviceIdx_t>(&Operator::setBackend), py::arg("name"), py::arg("device") = 0)
.def("set_backend", py::overload_cast<const std::vector<std::pair<std::string, DeviceIdx_t>>&>(&Operator::setBackend), py::arg("backends"))
.def("forward", &Operator::forward)
diff --git a/python_binding/operator/pybind_OperatorTensor.cpp b/python_binding/operator/pybind_OperatorTensor.cpp
index 8c515e321207605c20acc9e5b02271906c9707d1..2602e115d43d805451aa9f0836c8151b2cd4b109 100644
--- a/python_binding/operator/pybind_OperatorTensor.cpp
+++ b/python_binding/operator/pybind_OperatorTensor.cpp
@@ -26,7 +26,9 @@ namespace Aidge {
void init_OperatorTensor(py::module& m){
py::class_<OperatorTensor, std::shared_ptr<OperatorTensor>, Operator>(m, "OperatorTensor")
.def("get_output", &OperatorTensor::getOutput, py::arg("outputIdx"))
+ .def("get_outputs", &OperatorTensor::getOutputs)
.def("get_input", &OperatorTensor::getInput, py::arg("inputIdx"))
+ .def("get_inputs", &OperatorTensor::getInputs)
.def("set_output", (void (OperatorTensor::*)(const IOIndex_t, const std::shared_ptr<Data>&) const) &OperatorTensor::setOutput, py::arg("outputIdx"), py::arg("data"))
.def("set_input", (void (OperatorTensor::*)(const IOIndex_t, const std::shared_ptr<Data>&)) &OperatorTensor::setInput, py::arg("outputIdx"), py::arg("data"))
diff --git a/python_binding/operator/pybind_WeightInterleaving.cpp b/python_binding/operator/pybind_WeightInterleaving.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..25b423bd66503b39f031695121cf673c45c34bbe
--- /dev/null
+++ b/python_binding/operator/pybind_WeightInterleaving.cpp
@@ -0,0 +1,39 @@
+/********************************************************************************
+ * 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
+ *
+ ********************************************************************************/
+
+#include <pybind11/pybind11.h>
+#include "aidge/operator/WeightInterleaving.hpp"
+
+namespace py = pybind11;
+
+namespace Aidge {
+
+void declare_WeightInterleaving(py::module &m) {
+ py::class_<WeightInterleaving_Op, std::shared_ptr<WeightInterleaving_Op>, OperatorTensor>(m, "WeightInterleavingOp", py::multiple_inheritance())
+ .def(py::init<>())
+ .def_static("get_inputs_name", &WeightInterleaving_Op::getInputsName)
+ .def_static("get_outputs_name", &WeightInterleaving_Op::getOutputsName)
+ .def_readonly_static("Type", &WeightInterleaving_Op::Type)
+
+ .def("__repr__", [](WeightInterleaving_Op& b) {
+ return fmt::format("Operator(type='{}')", b.Type);
+ });
+
+ declare_registrable<WeightInterleaving_Op>(m, "WeightInterleavingOp");
+
+ m.def("WeightInterleaving", &WeightInterleaving, py::arg("name") = "");
+}
+
+void init_WeightInterleaving(py::module &m) {
+ declare_WeightInterleaving(m);
+}
+
+} // namespace Aidge
diff --git a/python_binding/pybind_core.cpp b/python_binding/pybind_core.cpp
index 006eeb289f25570ddf337f048b05816102624028..eccbebd2f0db7fd45484f114e4ae3dea8b2e5451 100644
--- a/python_binding/pybind_core.cpp
+++ b/python_binding/pybind_core.cpp
@@ -16,6 +16,7 @@
namespace py = pybind11;
namespace Aidge {
+void init_CoreSysInfo(py::module&);
void init_Random(py::module&);
void init_Data(py::module&);
void init_Database(py::module&);
@@ -83,6 +84,7 @@ void init_Sub(py::module&);
void init_Tanh(py::module&);
void init_Transpose(py::module&);
void init_Unsqueeze(py::module&);
+void init_WeightInterleaving(py::module&);
void init_Node(py::module&);
void init_GraphView(py::module&);
@@ -103,6 +105,7 @@ void init_TensorUtils(py::module&);
void init_Filler(py::module&);
void init_Aidge(py::module& m) {
+ init_CoreSysInfo(m);
init_Random(m);
init_Data(m);
@@ -177,6 +180,7 @@ void init_Aidge(py::module& m) {
init_Tanh(m);
init_Transpose(m);
init_Unsqueeze(m);
+ init_WeightInterleaving(m);
init_Producer(m);
diff --git a/python_binding/recipes/pybind_Recipes.cpp b/python_binding/recipes/pybind_Recipes.cpp
index f656af70dfa05678875afd4b4748f358437852a8..21478a5b14d609801f232b20cda25e7e1c0d9475 100644
--- a/python_binding/recipes/pybind_Recipes.cpp
+++ b/python_binding/recipes/pybind_Recipes.cpp
@@ -151,6 +151,14 @@ void init_Recipes(py::module &m)
:param node: Node which Operator will turn into a Generic Operator
:type graph_view: :py:class:`aidge_core.Node`
)mydelimiter");
+
+ m.def("apply_weightinterleaving", applyWeightInterleaving, py::arg("node"), R"mydelimiter(
+ Replace weight Producer linked to the given node with a weight producer with interleaving and format NHWC.
+ This recipe is specific to the ARM cortex-m export for low bit integer support.
+
+ :param node: Node which linked weights will recieve interleaving
+ :type graph_view: :py:class:`aidge_core.Node`
+ )mydelimiter");
}
} // namespace Aidge
diff --git a/python_binding/scheduler/pybind_MemoryManager.cpp b/python_binding/scheduler/pybind_MemoryManager.cpp
index 0f18db405bec0aee9637f2e5f2ecc7b71e502cc5..3fce92349f28e3c6a897356dee60359c1797d9ca 100644
--- a/python_binding/scheduler/pybind_MemoryManager.cpp
+++ b/python_binding/scheduler/pybind_MemoryManager.cpp
@@ -36,10 +36,10 @@ void init_MemoryManager(py::module& m)
.def_readwrite("released", &MemoryManager::MemorySpace::released);
py::class_<MemoryManager::MemoryPlane, std::shared_ptr<MemoryManager::MemoryPlane>>(m, "MemoryPlane")
- .def(py::init<std::shared_ptr<MemoryManager::MemorySpace>,
+ .def(py::init<std::shared_ptr<MemoryManager::MemorySpace>,
MemoryManager::Clock_T, unsigned int, unsigned int,
unsigned int, unsigned int, unsigned int>(),
- py::arg("mem_space"), py::arg("clock"), py::arg("offset"),
+ py::arg("mem_space"), py::arg("clock"), py::arg("offset"),
py::arg("size"), py::arg("stride"), py::arg("length"), py::arg("count"))
.def_readwrite("mem_space", &MemoryManager::MemoryPlane::memSpace)
.def_readwrite("allocated", &MemoryManager::MemoryPlane::allocated)
@@ -101,7 +101,6 @@ void init_MemoryManager(py::module& m)
.def("get_nb_planes", (unsigned int (MemoryManager::*)(std::shared_ptr<MemoryManager::MemorySpace>) const) &MemoryManager::getNbPlanes, py::arg("mem_space"))
.def("get_current_tick", &MemoryManager::getCurrentTick)
.def("tick", &MemoryManager::tick)
- .def("log", &MemoryManager::log, py::arg("file_name"))
;
}
diff --git a/python_binding/utils/sys_info/pybind_CoreVersionInfo.cpp b/python_binding/utils/sys_info/pybind_CoreVersionInfo.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b498e86ed31adad57de4dbd57fa8f358b188f499
--- /dev/null
+++ b/python_binding/utils/sys_info/pybind_CoreVersionInfo.cpp
@@ -0,0 +1,11 @@
+#include <pybind11/pybind11.h>
+#include "aidge/utils/sys_info/CoreVersionInfo.hpp"
+
+namespace py = pybind11;
+namespace Aidge {
+void init_CoreSysInfo(py::module& m){
+ m.def("show_version", &showCoreVersion);
+ m.def("get_project_version", &getCoreProjectVersion);
+ m.def("get_git_hash", &getCoreGitHash);
+}
+}
diff --git a/setup.cfg b/setup.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..bd90e50b282a1e1c08e0b2acaaddae940b0b4ac5
--- /dev/null
+++ b/setup.cfg
@@ -0,0 +1,4 @@
+# pbr file
+[metadata]
+name = file: project_name.txt
+version = file: version.txt
diff --git a/setup.py b/setup.py
index 4f2e21711f193eb7d5c37ace7b5ad83ac63d3635..2fb84a991e416c41da709845f44c1cd6042a278d 100644
--- a/setup.py
+++ b/setup.py
@@ -10,7 +10,11 @@ from setuptools import setup, Extension
from setuptools.command.build_ext import build_ext
-PROJECT_NAME = "aidge_core"
+def get_project_name() -> str:
+ return open(pathlib.Path().absolute() / "project_name.txt", "r").read().strip()
+
+
+PROJECT_NAME = get_project_name()
SETUP_DIR = pathlib.Path(__file__).parent
diff --git a/src/backend/cpu/data/TensorImpl.cpp b/src/backend/cpu/data/TensorImpl.cpp
index 506287a0c520915e6426f1f0b64d9c562c754d33..236e5bb8e1e867d5a0dad85571d754bc9e2a2a22 100644
--- a/src/backend/cpu/data/TensorImpl.cpp
+++ b/src/backend/cpu/data/TensorImpl.cpp
@@ -95,6 +95,62 @@ void Aidge::TensorImpl_cpu<T>::copyCast(const void *src, const Aidge::DataType s
std::copy(static_cast<const uint8_t*>(src), static_cast<const uint8_t*>(src) + length,
dstT);
break;
+ case DataType::Int4:
+ std::copy(static_cast<const int8_t*>(src), static_cast<const int8_t*>(src) + length,
+ dstT);
+ break;
+ case DataType::UInt4:
+ std::copy(static_cast<const uint8_t*>(src), static_cast<const uint8_t*>(src) + length,
+ dstT);
+ break;
+ case DataType::Dual_Int4:
+ std::copy(static_cast<const int8_t*>(src), static_cast<const int8_t*>(src) + length,
+ dstT);
+ break;
+ case DataType::Dual_UInt4:
+ std::copy(static_cast<const uint8_t*>(src), static_cast<const uint8_t*>(src) + length,
+ dstT);
+ break;
+ case DataType::Int3:
+ std::copy(static_cast<const int8_t*>(src), static_cast<const int8_t*>(src) + length,
+ dstT);
+ break;
+ case DataType::UInt3:
+ std::copy(static_cast<const uint8_t*>(src), static_cast<const uint8_t*>(src) + length,
+ dstT);
+ break;
+ case DataType::Dual_Int3:
+ std::copy(static_cast<const int8_t*>(src), static_cast<const int8_t*>(src) + length,
+ dstT);
+ break;
+ case DataType::Dual_UInt3:
+ std::copy(static_cast<const uint8_t*>(src), static_cast<const uint8_t*>(src) + length,
+ dstT);
+ break;
+ case DataType::Int2:
+ std::copy(static_cast<const int8_t*>(src), static_cast<const int8_t*>(src) + length,
+ dstT);
+ break;
+ case DataType::UInt2:
+ std::copy(static_cast<const uint8_t*>(src), static_cast<const uint8_t*>(src) + length,
+ dstT);
+ break;
+ case DataType::Quad_Int2:
+ std::copy(static_cast<const int8_t*>(src), static_cast<const int8_t*>(src) + length,
+ dstT);
+ break;
+ case DataType::Quad_UInt2:
+ std::copy(static_cast<const uint8_t*>(src), static_cast<const uint8_t*>(src) + length,
+ dstT);
+ break;
+ case DataType::Binary:
+ std::copy(static_cast<const int8_t*>(src), static_cast<const int8_t*>(src) + length,
+ dstT);
+ break;
+ case DataType::Octo_Binary:
+ std::copy(static_cast<const int8_t*>(src), static_cast<const int8_t*>(src) + length,
+ dstT);
+ break;
default:
AIDGE_THROW_OR_ABORT(std::runtime_error, "Unsupported data type.");
break;
diff --git a/src/data/Tensor.cpp b/src/data/Tensor.cpp
index e8a0e9edee29ae56447ecc41e41d1db321d40058..a14ae4187707490cfb70681fc418daf961cb053b 100644
--- a/src/data/Tensor.cpp
+++ b/src/data/Tensor.cpp
@@ -28,6 +28,12 @@
namespace Aidge {
+Tensor::Tensor(const Tensor& other) = default;
+Tensor::Tensor(Tensor&& other) = default;
+
+Tensor& Tensor::operator=(const Tensor& other) = default;
+Tensor& Tensor::operator=(Tensor&& other) = default;
+
Tensor::~Tensor() noexcept = default;
@@ -322,6 +328,34 @@ std::string Tensor::toString() const {
return std::to_string(static_cast<float*>(ptr)[idx]);
case DataType::Float16:
return std::to_string(static_cast<half_float::half*>(ptr)[idx]);
+ case DataType::Binary:
+ return std::to_string(static_cast<int8_t*>(ptr)[idx]);
+ case DataType::Octo_Binary:
+ return std::to_string(static_cast<int8_t*>(ptr)[idx]);
+ case DataType::Dual_Int4:
+ return std::to_string(static_cast<int8_t*>(ptr)[idx]);
+ case DataType::Dual_UInt4:
+ return std::to_string(static_cast<uint8_t*>(ptr)[idx]);
+ case DataType::Dual_Int3:
+ return std::to_string(static_cast<int8_t*>(ptr)[idx]);
+ case DataType::Dual_UInt3:
+ return std::to_string(static_cast<uint8_t*>(ptr)[idx]);
+ case DataType::Quad_Int2:
+ return std::to_string(static_cast<int8_t*>(ptr)[idx]);
+ case DataType::Quad_UInt2:
+ return std::to_string(static_cast<uint8_t*>(ptr)[idx]);
+ case DataType::Int4:
+ return std::to_string(static_cast<int8_t*>(ptr)[idx]);
+ case DataType::UInt4:
+ return std::to_string(static_cast<uint8_t*>(ptr)[idx]);
+ case DataType::Int3:
+ return std::to_string(static_cast<int8_t*>(ptr)[idx]);
+ case DataType::UInt3:
+ return std::to_string(static_cast<uint8_t*>(ptr)[idx]);
+ case DataType::Int2:
+ return std::to_string(static_cast<int8_t*>(ptr)[idx]);
+ case DataType::UInt2:
+ return std::to_string(static_cast<uint8_t*>(ptr)[idx]);
case DataType::Int8:
return std::to_string(static_cast<int8_t*>(ptr)[idx]);
case DataType::Int16:
diff --git a/src/graph/GraphView.cpp b/src/graph/GraphView.cpp
index 465359757eadd2799aa7f272e2d85b032a60cfdd..4c6f6ada8fdf069c308398f7b978e1d44fde8f65 100644
--- a/src/graph/GraphView.cpp
+++ b/src/graph/GraphView.cpp
@@ -940,6 +940,22 @@ void Aidge::GraphView::addChild(
add(toOtherView);
}
+void Aidge::GraphView::updateNodeName(const std::shared_ptr<Node>& node, const std::string& newName) {
+ if (!newName.empty()) {
+ auto itNew = mNodeRegistry.insert(std::make_pair(newName, node));
+ if (!itNew.second) {
+ Log::notice("Replacing existing node name in graph node name registry: {}", newName);
+ (itNew.first)->second = node;
+ }
+ }
+
+ if (!node->name().empty()) {
+ const auto it = mNodeRegistry.find(node->name());
+ AIDGE_ASSERT(it != mNodeRegistry.end(), "No node named {} in graph {}, the graph may be corrupted !", node->name(), name());
+ mNodeRegistry.erase(it);
+ }
+}
+
std::set<std::shared_ptr<Aidge::Node>> Aidge::GraphView::getParents() const {
// TODO: choose if we return a set or a vector
std::set<std::shared_ptr<Node>> parents;
diff --git a/src/graph/Matching.cpp b/src/graph/Matching.cpp
index 4a62019a7aa044ebcf2089d91f3ba097d85218e7..ddf9bcbf946b6fe8e86c9a14679b951ebd88323f 100644
--- a/src/graph/Matching.cpp
+++ b/src/graph/Matching.cpp
@@ -1,11 +1,43 @@
+/********************************************************************************
+ * 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
+ *
+ ********************************************************************************/
+
#include "aidge/graph/Matching.hpp"
+#include <algorithm> // std::find_if
+#include <cctype> // std::isspace
+#include <cstddef> // std::size_t
+#include <memory>
+#include <set>
+#include <string> // std::stoi
+#include <utility> // std::pair
+#include <vector>
+
#include <fmt/color.h>
+#include "aidge/graph/GraphView.hpp"
+#include "aidge/graph/Node.hpp"
+
+static void removeLeadingWhitespace(std::string& str) {
+ str.erase(str.begin(),
+ std::find_if(str.cbegin(),
+ str.cend(),
+ [](char c) { return !std::isspace(c); }));
+}
+
+////////////////////////////////////////////////////////////
+
Aidge::SinglePassGraphMatching::Context::Context() = default;
Aidge::SinglePassGraphMatching::Context::Context(const Context& other) = default;
Aidge::SinglePassGraphMatching::Context& Aidge::SinglePassGraphMatching::Context::operator=(const Context& other) = default;
-Aidge::SinglePassGraphMatching::Context::~Context() = default;
+Aidge::SinglePassGraphMatching::Context::~Context() noexcept = default;
////////////////////////////////////////////////////////////
@@ -35,7 +67,7 @@ std::set<Aidge::SinglePassGraphMatching::MatchingResult> Aidge::SinglePassGraphM
std::set<MatchingResult> matches;
while (matchSequence(ctx, matches) || matchNodeOrBlock(ctx, matches)) {
- removeWhiteSpace(ctx.query);
+ removeLeadingWhitespace(ctx.query);
if (!ctx.query.empty() && ctx.query[0] == ';') {
ctx.query.erase(0, 1);
}
@@ -44,7 +76,7 @@ std::set<Aidge::SinglePassGraphMatching::MatchingResult> Aidge::SinglePassGraphM
}
}
- removeWhiteSpace(ctx.query);
+ removeLeadingWhitespace(ctx.query);
if (!ctx.query.empty()) {
Log::warn("Syntax error, unable to parse remaining query: {}", ctx.query);
}
@@ -56,14 +88,14 @@ std::set<Aidge::SinglePassGraphMatching::MatchingResult> Aidge::SinglePassGraphM
return matches;
}
-Aidge::SinglePassGraphMatching::MatchingResult Aidge::SinglePassGraphMatching::matchFrom(NodePtr startNode, const std::string& query) {
+Aidge::SinglePassGraphMatching::MatchingResult Aidge::SinglePassGraphMatching::matchFrom(std::shared_ptr<Node> startNode, const std::string& query) {
Context ctx;
ctx.query = query;
ctx.startNode = startNode;
std::set<MatchingResult> matches;
while (matchSequence(ctx, matches) || matchNodeOrBlock(ctx, matches)) {
- removeWhiteSpace(ctx.query);
+ removeLeadingWhitespace(ctx.query);
if (!ctx.query.empty() && ctx.query[0] == ';') {
ctx.query.erase(0, 1);
}
@@ -72,7 +104,7 @@ Aidge::SinglePassGraphMatching::MatchingResult Aidge::SinglePassGraphMatching::m
}
}
- removeWhiteSpace(ctx.query);
+ removeLeadingWhitespace(ctx.query);
if (!ctx.query.empty()) {
Log::warn("Syntax error, unable to parse remaining query: {}", ctx.query);
}
@@ -123,8 +155,8 @@ bool Aidge::SinglePassGraphMatching::matchNodeOrBlock(Context& ctx, std::set<Mat
// QUANTIFIER?
bool matchMore = false;
- size_t matchQuantity = 0;
- removeWhiteSpace(newCtx.query);
+ std::size_t matchQuantity = 0;
+ removeLeadingWhitespace(newCtx.query);
if (!newCtx.query.empty() && (newCtx.query[0] == '?' || newCtx.query[0] == '*')) {
AIDGE_ASSERT(!(ctx.firstSequence && ctx.firstNode),
"Ill-formed query; the root node cannot be optional in query at: {}", ctx.query);
@@ -155,7 +187,7 @@ bool Aidge::SinglePassGraphMatching::matchNodeOrBlock(Context& ctx, std::set<Mat
else if (!newCtx.query.empty() && newCtx.query[0] == '{') {
newCtx.query.erase(0, 1);
- removeWhiteSpace(newCtx.query);
+ removeLeadingWhitespace(newCtx.query);
const auto endQuantity = std::find_if(newCtx.query.begin(), newCtx.query.end(),
[](char c) { return !isdigit(c); });
if (endQuantity != newCtx.query.begin()) {
@@ -172,7 +204,7 @@ bool Aidge::SinglePassGraphMatching::matchNodeOrBlock(Context& ctx, std::set<Mat
return false;
}
- removeWhiteSpace(newCtx.query);
+ removeLeadingWhitespace(newCtx.query);
if (!newCtx.query.empty() && newCtx.query[0] == '}') {
newCtx.query.erase(0, 1);
}
@@ -231,7 +263,7 @@ bool Aidge::SinglePassGraphMatching::matchBlock(Context& ctx, std::set<MatchingR
++newCtx.depth;
// '('
- removeWhiteSpace(newCtx.query);
+ removeLeadingWhitespace(newCtx.query);
if (!newCtx.query.empty() && newCtx.query[0] == '(') {
newCtx.query.erase(0, 1);
}
@@ -252,7 +284,7 @@ bool Aidge::SinglePassGraphMatching::matchBlock(Context& ctx, std::set<MatchingR
}
// ')'
- removeWhiteSpace(newCtx.query);
+ removeLeadingWhitespace(newCtx.query);
if (!newCtx.query.empty() && newCtx.query[0] == ')') {
newCtx.query.erase(0, 1);
}
@@ -337,7 +369,7 @@ bool Aidge::SinglePassGraphMatching::matchParallel(Context& ctx, std::set<Matchi
while (true) {
// ('&' NODE_OR_BLOCK)+
// '&'
- removeWhiteSpace(newCtx.query);
+ removeLeadingWhitespace(newCtx.query);
if (!newCtx.query.empty() && newCtx.query[0] == '&') {
newCtx.query.erase(0, 1);
found = true;
@@ -402,7 +434,7 @@ bool Aidge::SinglePassGraphMatching::matchAlternative(Context& ctx, std::set<Mat
while (true) {
// ('|' NODE_OR_BLOCK)+
// '|'
- removeWhiteSpace(newCtx.query);
+ removeLeadingWhitespace(newCtx.query);
if (!newCtx.query.empty() && newCtx.query[0] == '|') {
newCtx.query.erase(0, 1);
found = true;
@@ -446,7 +478,7 @@ bool Aidge::SinglePassGraphMatching::matchEdge(Context& ctx, std::set<MatchingRe
Log::debug("{}edge", std::string(2*newCtx.depth, ' '));
// ('-' | '~') or '<'
- removeWhiteSpace(newCtx.query);
+ removeLeadingWhitespace(newCtx.query);
if (!newCtx.query.empty() && (newCtx.query[0] == '-' || newCtx.query[0] == '~')) {
newCtx.singleOutput = (newCtx.query[0] == '-');
newCtx.query.erase(0, 1); // drop '-'
@@ -550,7 +582,7 @@ bool Aidge::SinglePassGraphMatching::matchNode(Context& ctx, std::set<MatchingRe
auto newMatches = matches;
// (TYPE | '.' | '$')
- removeWhiteSpace(newCtx.query);
+ removeLeadingWhitespace(newCtx.query);
if (newCtx.query.empty()) {
Log::debug("{}{}", std::string(2*ctx.depth, ' '), fmt::styled("×", fmt::fg(fmt::color::red)));
return false;
@@ -833,3 +865,8 @@ bool Aidge::SinglePassGraphMatching::matchNode(Context& ctx, std::set<MatchingRe
matches = newMatches;
return true;
}
+
+bool Aidge::operator<(const Aidge::SinglePassGraphMatching::MatchingResult& lhs, const Aidge::SinglePassGraphMatching::MatchingResult& rhs) {
+ // Matching rootNode are guaranteed to be different!
+ return lhs.graph->rootNode() < rhs.graph->rootNode();
+}
\ No newline at end of file
diff --git a/src/graph/Node.cpp b/src/graph/Node.cpp
index 92ae463085a3583dfe894a1b9f6119fa0b099287..384e946c674641f7d498d8c5745dcc745f34d751 100644
--- a/src/graph/Node.cpp
+++ b/src/graph/Node.cpp
@@ -35,6 +35,7 @@ Aidge::Node::Node(std::shared_ptr<Operator> op, std::shared_ptr<DynamicAttribute
mForward.push_back([this](){ this->mOperator->forward(); return true; });
// mForward.push_back(std::bind(&Operator::forward, mOperator.get()));
mBackward.push_back([this](){ this->mOperator->backward(); return true; });
+ op->setInheritedAttrs(attrs);
}
// Aidge::Node::Node(std::shared_ptr<Operator> op, const DynamicAttributes& attrs)
@@ -225,6 +226,16 @@ Aidge::IOIndex_t Aidge::Node::nbValidOutputs() const {
return counter;
}
+std::set<std::shared_ptr<Aidge::GraphView>> Aidge::Node::views() const noexcept {
+ std::set<std::shared_ptr<GraphView>> res;
+ for (const auto &v : mViews) {
+ if (auto p = v.lock()) {
+ res.insert(p);
+ }
+ }
+ return res;
+}
+
void Aidge::Node::setInputId(const IOIndex_t inId, const IOIndex_t newNodeoutId) {
AIDGE_ASSERT(inId != gk_IODefaultIndex && inId < nbInputs(),
"Input index ({}) is out of bound ({}) for node {} (of type {})",
diff --git a/src/graph/StaticAnalysis.cpp b/src/graph/StaticAnalysis.cpp
index 033e51022842983caacba9385248c9f02c1e5568..4309c5c37b72dea9f07f8e5a2e7ce7678090b2e2 100644
--- a/src/graph/StaticAnalysis.cpp
+++ b/src/graph/StaticAnalysis.cpp
@@ -11,13 +11,31 @@
#include "aidge/graph/StaticAnalysis.hpp"
+#include <cstddef> // std::size_t
+#include <memory>
+#include <numeric> // std::accumulate
+#include <set>
+
+#include <fmt/core.h> // fmt::println
+#include <fmt/format.h>
+#include <fmt/ranges.h>
+
+#include "aidge/data/Data.hpp" // Aidge::isDataTypeFloatingPoint
+#include "aidge/data/Tensor.hpp"
+#include "aidge/graph/GraphView.hpp"
+#include "aidge/graph/Node.hpp"
+#include "aidge/operator/Operator.hpp"
+#include "aidge/operator/OperatorTensor.hpp"
+
Aidge::OperatorStats::OperatorStats(const Operator& op)
: mOp(op)
{
//ctor
}
-size_t Aidge::OperatorStats::getNbArithmIntOps() const {
+Aidge::OperatorStats::~OperatorStats() = default;
+
+std::size_t Aidge::OperatorStats::getNbArithmIntOps() const {
const auto opTensor = dynamic_cast<const OperatorTensor*>(&mOp);
if (opTensor) {
if (!isDataTypeFloatingPoint(opTensor->getOutput(0)->dataType())) {
@@ -27,23 +45,27 @@ size_t Aidge::OperatorStats::getNbArithmIntOps() const {
return 0;
}
+////////////////////////////////////////////////////////////////////////////////
+
Aidge::StaticAnalysis::StaticAnalysis(std::shared_ptr<GraphView> graph)
: mGraph(graph)
{
//ctor
}
+Aidge::StaticAnalysis::~StaticAnalysis() = default;
+
void Aidge::StaticAnalysis::summary(bool incProducers) const {
fmt::println("--------------------------------------------------------------------------------");
fmt::println(" Layer (type) Output Shape Param #");
fmt::println("================================================================================");
- size_t nbParams = 0;
- size_t paramsSize = 0; // Size in bits
- size_t fwdBwdSize = 0; // Size in bits
+ std::size_t nbParams = 0;
+ std::size_t paramsSize = 0; // Size in bits
+ std::size_t fwdBwdSize = 0; // Size in bits
const auto namePtrTable = mGraph->getRankedNodesName("{0} ({1}#{3})");
- for (const auto node : mGraph->getOrderedNodes()) {
+ for (const auto& node : mGraph->getOrderedNodes()) {
if (node->type() == Producer_Op::Type && !incProducers) {
continue;
}
@@ -53,8 +75,8 @@ void Aidge::StaticAnalysis::summary(bool incProducers) const {
if (opTensor) {
const auto outputDims = opTensor->getOutput(0)->dims();
outputDimsStr = fmt::format("{: >27}", fmt::format("{}", outputDims));
-
- for (size_t out = 0; out < node->nbOutputs(); ++out) {
+
+ for (std::size_t out = 0; out < node->nbOutputs(); ++out) {
const auto output = opTensor->getOutput(out);
if (output && node->type() != Producer_Op::Type) {
fwdBwdSize += output->size()
@@ -69,8 +91,8 @@ void Aidge::StaticAnalysis::summary(bool incProducers) const {
namePtrTable.at(node), outputDimsStr, getNbParams(node));
}
- size_t inputSize = 0; // Size in bits
- for (const auto input : mGraph->getOrderedInputs()) {
+ std::size_t inputSize = 0; // Size in bits
+ for (const auto& input : mGraph->getOrderedInputs()) {
if (input.first) {
auto opTensor = std::dynamic_pointer_cast<OperatorTensor>(input.first->getOperator());
if (opTensor && opTensor->getInput(input.second)) {
@@ -90,13 +112,13 @@ void Aidge::StaticAnalysis::summary(bool incProducers) const {
fmt::println("--------------------------------------------------------------------------------");
}
-size_t Aidge::StaticAnalysis::getNbParams(std::shared_ptr<Node> node) const {
+std::size_t Aidge::StaticAnalysis::getNbParams(std::shared_ptr<Node> node) const {
const auto opTensor = std::dynamic_pointer_cast<OperatorTensor>(node->getOperator());
- size_t nbParams = 0;
+ std::size_t nbParams = 0;
// Look for Producers directly attached to the node's inputs.
- size_t i = 0;
+ std::size_t i = 0;
for (auto parent : node->inputs()) {
if (parent.first && mGraph->inView(parent.first)) {
if (parent.first->type() == Producer_Op::Type && opTensor->getInput(i)) {
@@ -109,7 +131,7 @@ size_t Aidge::StaticAnalysis::getNbParams(std::shared_ptr<Node> node) const {
// Look for internal Producers, in case of meta-op.
if (!node->getOperator()->isAtomic()) {
const auto microGraph = std::dynamic_pointer_cast<MetaOperator_Op>(node->getOperator())->getMicroGraph();
- for (const auto internalNode : microGraph->getNodes()) {
+ for (const auto& internalNode : microGraph->getNodes()) {
if (internalNode->type() == Producer_Op::Type) {
const auto internalOpTensor = std::dynamic_pointer_cast<OperatorTensor>(internalNode->getOperator());
nbParams += internalOpTensor->getOutput(0)->size();
@@ -120,14 +142,14 @@ size_t Aidge::StaticAnalysis::getNbParams(std::shared_ptr<Node> node) const {
return nbParams;
}
-size_t Aidge::StaticAnalysis::getParamsSize(std::shared_ptr<Node> node) const {
+std::size_t Aidge::StaticAnalysis::getParamsSize(std::shared_ptr<Node> node) const {
const auto opTensor = std::dynamic_pointer_cast<OperatorTensor>(node->getOperator());
- size_t paramsSize = 0;
+ std::size_t paramsSize = 0;
// Look for Producers directly attached to the node's inputs.
- size_t i = 0;
- for (auto parent : node->inputs()) {
+ std::size_t i = 0;
+ for (const auto& parent : node->inputs()) {
if (parent.first && mGraph->inView(parent.first)) {
if (parent.first->type() == Producer_Op::Type && opTensor->getInput(i)) {
paramsSize += opTensor->getInput(i)->size()
@@ -140,7 +162,7 @@ size_t Aidge::StaticAnalysis::getParamsSize(std::shared_ptr<Node> node) const {
// Look for internal Producers, in case of meta-op.
if (!node->getOperator()->isAtomic()) {
const auto microGraph = std::dynamic_pointer_cast<MetaOperator_Op>(node->getOperator())->getMicroGraph();
- for (const auto internalNode : microGraph->getNodes()) {
+ for (const auto& internalNode : microGraph->getNodes()) {
if (internalNode->type() == Producer_Op::Type) {
const auto internalOpTensor = std::dynamic_pointer_cast<OperatorTensor>(internalNode->getOperator());
paramsSize += internalOpTensor->getOutput(0)->size()
@@ -160,12 +182,32 @@ std::shared_ptr<Aidge::OperatorStats> Aidge::StaticAnalysis::getOpStats(std::sha
: std::make_shared<MetaOpStats>(*(node->getOperator()));
}
-size_t Aidge::StaticAnalysis::accumulate(size_t (OperatorStats::*func)() const) const {
+std::size_t Aidge::StaticAnalysis::getNbArithmOps() const { return accumulate(&OperatorStats::getNbArithmOps); }
+std::size_t Aidge::StaticAnalysis::getNbLogicOps() const { return accumulate(&OperatorStats::getNbLogicOps); }
+std::size_t Aidge::StaticAnalysis::getNbCompOps() const { return accumulate(&OperatorStats::getNbCompOps); }
+std::size_t Aidge::StaticAnalysis::getNbNLOps() const { return accumulate(&OperatorStats::getNbNLOps); }
+std::size_t Aidge::StaticAnalysis::getNbOps() const { return accumulate(&OperatorStats::getNbOps); }
+std::size_t Aidge::StaticAnalysis::getNbArithmIntOps() const { return accumulate(&OperatorStats::getNbArithmIntOps); }
+std::size_t Aidge::StaticAnalysis::getNbArithmFpOps() const { return accumulate(&OperatorStats::getNbArithmFpOps); }
+std::size_t Aidge::StaticAnalysis::getNbMACOps() const { return accumulate(&OperatorStats::getNbMACOps); }
+
+std::size_t Aidge::StaticAnalysis::accumulate(std::size_t (OperatorStats::*func)() const) const {
return std::accumulate(
mGraph->getNodes().cbegin(),
mGraph->getNodes().cend(),
std::size_t(0),
- [this, func](const size_t& lhs, const std::shared_ptr<Node>& rhs) {
+ [this, func](const std::size_t& lhs, const std::shared_ptr<Node>& rhs) {
return lhs + (this->getOpStats(rhs).get()->*func)();
});
}
+
+////////////////////////////////////////////////////////////////////////////////
+
+Aidge::MetaOpStats::~MetaOpStats() = default;
+
+std::size_t Aidge::MetaOpStats::getNbArithmOps() const { return StaticAnalysis(dynamic_cast<const MetaOperator_Op&>(mOp).getMicroGraph()).getNbArithmOps(); }
+std::size_t Aidge::MetaOpStats::getNbLogicOps() const { return StaticAnalysis(dynamic_cast<const MetaOperator_Op&>(mOp).getMicroGraph()).getNbLogicOps(); }
+std::size_t Aidge::MetaOpStats::getNbCompOps() const { return StaticAnalysis(dynamic_cast<const MetaOperator_Op&>(mOp).getMicroGraph()).getNbCompOps(); }
+std::size_t Aidge::MetaOpStats::getNbNLOps() const { return StaticAnalysis(dynamic_cast<const MetaOperator_Op&>(mOp).getMicroGraph()).getNbNLOps(); }
+std::size_t Aidge::MetaOpStats::getNbArithmIntOps() const { return StaticAnalysis(dynamic_cast<const MetaOperator_Op&>(mOp).getMicroGraph()).getNbArithmIntOps(); }
+std::size_t Aidge::MetaOpStats::getNbMACOps() const { return StaticAnalysis(dynamic_cast<const MetaOperator_Op&>(mOp).getMicroGraph()).getNbMACOps(); }
\ No newline at end of file
diff --git a/src/operator/ArgMax.cpp b/src/operator/ArgMax.cpp
index 4808b730d2261ba0c1ea6d0d09871b1f322fc8fb..531c41596ed4ef553a4b7ec7d2642b778044cc66 100644
--- a/src/operator/ArgMax.cpp
+++ b/src/operator/ArgMax.cpp
@@ -14,7 +14,6 @@
#include <cstddef> // std::size_t
#include <cstdint> // std::int32_t
#include <memory>
-#include <stdexcept> // std::runtime_error
#include <string>
#include <vector>
@@ -25,6 +24,21 @@
const std::string Aidge::ArgMax_Op::Type = "ArgMax";
+Aidge::ArgMax_Op::ArgMax_Op(const Aidge::ArgMax_Op& op)
+ : OperatorTensor(op),
+ mAttributes(op.mAttributes)
+{
+ if (op.mImpl){
+ SET_IMPL_MACRO(ArgMax_Op, *this, op.backend());
+ } else {
+ mImpl = nullptr;
+ }
+}
+
+std::shared_ptr<Aidge::Operator> Aidge::ArgMax_Op::clone() const {
+ return std::make_shared<ArgMax_Op>(*this);
+}
+
bool Aidge::ArgMax_Op::forwardDims(bool /*allowDataDependency*/) {
if (inputsAssociated()) {
// make Axis attribute positive
@@ -55,3 +69,12 @@ void Aidge::ArgMax_Op::setBackend(const std::string& name, Aidge::DeviceIdx_t de
std::set<std::string> Aidge::ArgMax_Op::getAvailableBackends() const {
return Registrar<ArgMax_Op>::getKeys();
}
+
+////////////////////////////////////////////////////////////////////////////////
+
+std::shared_ptr<Aidge::Node> Aidge::ArgMax(std::int32_t axis,
+ bool keep_dims,
+ bool select_last_index,
+ const std::string& name) {
+ return std::make_shared<Node>(std::make_shared<ArgMax_Op>(axis, keep_dims, select_last_index), name);
+}
\ No newline at end of file
diff --git a/src/operator/OperatorTensor.cpp b/src/operator/OperatorTensor.cpp
index 3bdb4b17127eb8a9115f8dec045db32bf041b00b..873e93f3296bae6c5eae8cf2b5ec7bacc82c45ce 100644
--- a/src/operator/OperatorTensor.cpp
+++ b/src/operator/OperatorTensor.cpp
@@ -92,6 +92,12 @@ const std::shared_ptr<Aidge::Tensor>& Aidge::OperatorTensor::getOutput(const Aid
return mOutputs[outputIdx];
}
+const std::vector<std::shared_ptr<Aidge::Tensor>>& Aidge::OperatorTensor::getOutputs() const{
+ return mOutputs;
+}
+const std::vector<std::shared_ptr<Aidge::Tensor>>& Aidge::OperatorTensor::getInputs() const{
+ return mInputs;
+}
std::vector<std::pair<std::vector<Aidge::DimSize_t>, std::vector<Aidge::DimSize_t>>> Aidge::OperatorTensor::computeReceptiveField(
const std::vector<DimSize_t>& firstEltDims,
diff --git a/src/operator/Slice.cpp b/src/operator/Slice.cpp
index 02dcad58c47fb804f50b9eb2e20be45a12e73fae..31c7c09c9ff41c163f5d505bd4ce6b3aeaf42872 100644
--- a/src/operator/Slice.cpp
+++ b/src/operator/Slice.cpp
@@ -101,8 +101,9 @@ void Aidge::Slice_OpImpl::forward() {
int step = op.steps()[axisIdx];
start = start >= 0 ? start: start + inputDims[axisIdx];
+ start = std::max(0, std::min(start, static_cast<int>(inputDims[axisIdx])));
end = end >= 0 ? end: end + inputDims[axisIdx];
-
+ end = std::max(0, std::min(end, static_cast<int>(inputDims[axisIdx])));
// Generate the range of indices for this axis
for (int idx = start; (step > 0) ? (idx < end) : (idx > end); idx += step) {
ranges[axisIdx].push_back(idx);
@@ -253,12 +254,17 @@ bool Aidge::Slice_Op::forwardDims(bool allowDataDependency) {
const DimIdx_t axis = this->axes()[i] >= 0 ?
static_cast<DimIdx_t>(this->axes()[i]) :
static_cast<DimIdx_t>(this->axes()[i] + static_cast<DimIdx_t>(getInput(0)->nbDims()));
- const DimSize_t start = this->starts()[i] >= 0 ?
+ DimSize_t start = this->starts()[i] >= 0 ?
static_cast<DimSize_t>(this->starts()[i]) :
static_cast<DimSize_t>(this->starts()[i] + static_cast<DimSize_t>(getInput(0)->dims()[axis]));
- const DimSize_t end = this->ends()[i] >= 0 ?
+ // Clamp start to the range [0, axis_dim]
+ start = std::max(static_cast<DimSize_t>(0), std::min(start, getInput(0)->dims()[axis]-1));
+
+ DimSize_t end = this->ends()[i] >= 0 ?
static_cast<DimSize_t>(this->ends()[i]) :
static_cast<DimSize_t>(this->ends()[i] + static_cast<DimSize_t>(getInput(0)->dims()[axis]));
+ // Clamp end to the range [0, axis_dim]
+ end = std::max(static_cast<DimSize_t>(0), std::min(end, getInput(0)->dims()[axis]));
const std::int64_t step = this->steps()[i];
AIDGE_ASSERT(step != 0, "Slice_Op: Step ({}) must have a non-zero value on axis {}!", this->steps(), axis);
@@ -309,4 +315,4 @@ std::shared_ptr<Aidge::Node> Aidge::Slice(const std::vector<std::int64_t>& start
const std::vector<std::int64_t>& steps,
const std::string &name) {
return std::make_shared<Node>(std::make_shared<Slice_Op>(starts, ends, axes, steps), name);
-}
\ No newline at end of file
+}
diff --git a/src/operator/WeightInterleaving.cpp b/src/operator/WeightInterleaving.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..66af1d51f87c24b5b8d7d9c1f0ab3701f122515d
--- /dev/null
+++ b/src/operator/WeightInterleaving.cpp
@@ -0,0 +1,121 @@
+/********************************************************************************
+ * 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
+ *
+ ********************************************************************************/
+
+#include "aidge/operator/WeightInterleaving.hpp"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "aidge/data/Data.hpp"
+#include "aidge/data/Tensor.hpp"
+#include "aidge/utils/ErrorHandling.hpp"
+#include "aidge/utils/StaticAttributes.hpp"
+#include "aidge/utils/Types.h"
+
+const std::string Aidge::WeightInterleaving_Op::Type = "WeightInterleaving";
+
+/**
+ * @brief Copy-constructor.
+ * @param op WeightInterleaving_Op to copy.
+ * @details Copies the operator attributes and its output tensor(s), but not
+ * its input tensors. The new operator has no associated input.
+ */
+Aidge::WeightInterleaving_Op::WeightInterleaving_Op(const WeightInterleaving_Op& op)
+ : OperatorTensor(op)
+{
+ if (op.mImpl) {
+ SET_IMPL_MACRO(WeightInterleaving_Op, *this, op.backend());
+ } else {
+ mImpl = nullptr;
+ }
+}
+
+
+std::shared_ptr<Aidge::Operator> Aidge::WeightInterleaving_Op::clone() const {
+ return std::make_shared<WeightInterleaving_Op>(*this);
+}
+
+
+bool Aidge::WeightInterleaving_Op::forwardDims(bool /*allowDataDependency*/) {
+
+ if (inputsAssociated()) {
+
+ // check input data format is NHWC
+ AIDGE_ASSERT((getInput(0)->dataFormat() == DataFormat::NHWC),
+ "Wrong Input tensor Data Format : {} for WeightInterleaving operator (should be DataFormat::NHWC for STM32).", getInput(0)->dataFormat());
+
+ // Take the last dimension of the tensor : It is the Channel dimension in format NHWC
+ // The weights will be compacted along side the channel dimension only
+ const DimSize_t& lastDim = getInput(0)->dims().back();
+
+ // Compute the last dimension size of the tensor after the weight interleaving compression
+ // TO DO : implement a mechanism to get the number of bits of the DataType
+ const DataType& dt = getInput(0)->dataType();
+
+ std::uint8_t nbBits = 0;
+
+ switch (dt) {
+ case DataType::Int4:
+ nbBits=4;
+ break;
+ case DataType::Int3:
+ nbBits=3;
+ break;
+ case DataType::Int2:
+ nbBits=2;
+ break;
+ default:
+ AIDGE_ASSERT(true, "Unsupport type for WeightInterleaving {}", dt);
+ }
+
+
+ const auto lastDimCompression = compactDataSize(lastDim, nbBits);
+
+ std::vector<DimSize_t> outputDims = getInput(0)->dims();
+ outputDims.back() = lastDimCompression;
+
+ // <batch, OutChannels>
+ mOutputs[0]->resize(outputDims);
+
+ return true;
+ }
+
+ return false;
+}
+
+
+void Aidge::WeightInterleaving_Op::setBackend(const std::string& name, DeviceIdx_t device) {
+ SET_IMPL_MACRO(WeightInterleaving_Op, *this, name);
+ mOutputs[0]->setBackend(name, device);
+}
+
+std::set<std::string> Aidge::WeightInterleaving_Op::getAvailableBackends() const {
+ return Registrar<WeightInterleaving_Op>::getKeys();
+}
+
+std::shared_ptr<Aidge::Node> Aidge::WeightInterleaving(const std::string& name) {
+ return std::make_shared<Node>(std::make_shared<WeightInterleaving_Op>(), name);
+}
+
+
+std::size_t Aidge::WeightInterleaving_Op::compactDataSize(std::size_t dataSize, std::uint8_t nbBits) {
+ AIDGE_ASSERT(nbBits > 0 && nbBits < 8, "nbBits must be between 1 and 4"); // Ensure valid bit width
+
+ // Calculate the number of `nbBits` segments that can fit in an 8-bit byte.
+ const unsigned int nbSlot = 8 / nbBits;
+
+ // Calculate the number of compacted bytes needed to store all data elements.
+ // The formula (dataSize + nbSlot - 1) / nbSlot effectively rounds up the division, ensuring that any remaining elements that don't fully fill a byte are accounted for.
+ std::size_t requiredSize = (dataSize + nbSlot - 1) / nbSlot;
+
+ return requiredSize;
+}
\ No newline at end of file
diff --git a/src/recipes/ApplyWeightInterleaving.cpp b/src/recipes/ApplyWeightInterleaving.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b9c042a538bc1ece754c5f659048e9c5f6c0d249
--- /dev/null
+++ b/src/recipes/ApplyWeightInterleaving.cpp
@@ -0,0 +1,119 @@
+/********************************************************************************
+ * 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
+ *
+ ********************************************************************************/
+
+#include <memory>
+
+#include "aidge/data/Data.hpp"
+#include "aidge/data/Tensor.hpp"
+#include "aidge/graph/Node.hpp"
+#include "aidge/graph/GraphView.hpp"
+#include "aidge/operator/WeightInterleaving.hpp"
+#include "aidge/operator/Transpose.hpp"
+#include "aidge/operator/Producer.hpp"
+#include "aidge/operator/OperatorTensor.hpp"
+#include "aidge/recipes/Recipes.hpp"
+
+
+
+
+void Aidge::applyWeightInterleaving(std::shared_ptr<Node> node){
+ auto weightProducer = node->getParent(1);
+ AIDGE_ASSERT(weightProducer, "Cannot Apply Weight Interleaving on {} because it has no weights linked", node->name())
+
+ auto weightTensor = std::make_shared<Aidge::Tensor>(std::static_pointer_cast<Aidge::OperatorTensor>(weightProducer->getOperator())->getOutput(0)->clone());
+ // auto backend = node->getOperator()->backend();
+ // Cover the case of Generic Operators
+ auto backend = node->getOperator()->backend().empty() ? "cpu" : node->getOperator()->backend();
+
+ const Aidge::DataType weightDataType = weightTensor->dataType();
+
+ // 1 - Apply dataformat NHWC to match the custom kernel implementation for ARM cortexM
+ // Issue : If the dataFormat is Default then setting it to NHWC won't permute dimensions
+ // Fix : If the datatype is at default then set it to NCHW THEN set it to NHWC
+
+ std::shared_ptr<Tensor> transposedWeightTensor;
+
+ // Case 4D tensor (conv)
+ if (weightTensor->nbDims() == 4)
+ {
+ if (weightTensor->dataFormat() == Aidge::DataFormat::Default) {
+ weightTensor->setDataFormat(Aidge::DataFormat::NCHW);
+ }
+
+ // Apply permutation for NHWC format
+ if (weightTensor->dataFormat() != Aidge::DataFormat::NHWC) {
+ weightTensor->setDataFormat(Aidge::DataFormat::NHWC);
+ }
+
+ transposedWeightTensor = weightTensor;
+
+ }
+ else if (weightTensor->nbDims() == 2)
+ {
+ std::shared_ptr<Node> myTranspose = Transpose({1, 0});
+ auto op = std::static_pointer_cast<OperatorTensor>(myTranspose -> getOperator());
+ op->associateInput(0,weightTensor);
+ op->setDataType(weightDataType);
+ op->setBackend("cpu");
+ myTranspose->forward();
+
+ transposedWeightTensor = op->getOutput(0);
+ transposedWeightTensor->setDataFormat(Aidge::DataFormat::NHWC);
+
+ } else {
+ AIDGE_THROW_OR_ABORT(std::runtime_error, "Cannot transpose {} weights.", node->name());
+ }
+
+ // 2 - Apply Weight interleaving
+ // Instanciate weight Interleaving operator
+ auto WIOp = WeightInterleaving_Op();
+
+ // Forward the Weight INterleaving op
+ WIOp.associateInput(0, transposedWeightTensor);
+
+ switch (weightDataType) {
+ case Aidge::DataType::Int4:
+ WIOp.setDataType(Aidge::DataType::Dual_Int4);
+ break;
+ case Aidge::DataType::UInt4:
+ WIOp.setDataType(Aidge::DataType::Dual_UInt4);
+ break;
+ case Aidge::DataType::Int3:
+ WIOp.setDataType(Aidge::DataType::Dual_Int3);
+ break;
+ case Aidge::DataType::UInt3:
+ WIOp.setDataType(Aidge::DataType::Dual_UInt3);
+ break;
+ case Aidge::DataType::Int2:
+ WIOp.setDataType(Aidge::DataType::Quad_Int2);
+ break;
+ case Aidge::DataType::UInt2:
+ WIOp.setDataType(Aidge::DataType::Quad_UInt2);
+ break;
+ case Aidge::DataType::Binary:
+ WIOp.setDataType(Aidge::DataType::Octo_Binary);
+ break;
+ default:
+ AIDGE_THROW_OR_ABORT(std::runtime_error, "Data type {} not supported for weight interleaving.", weightDataType);
+ }
+
+ WIOp.setDataFormat(Aidge::DataFormat::NHWC);
+ WIOp.setBackend(backend);
+
+ WIOp.forward();
+
+ // 3 - Replace the Weight Producer
+ auto newProducer = {Producer(WIOp.getOutput(0), weightProducer->name())};
+ auto oldProducer = {weightProducer};
+
+ GraphView::replace(oldProducer, newProducer);
+
+}
\ No newline at end of file
diff --git a/src/recipes/FuseBatchNorm.cpp b/src/recipes/FuseBatchNorm.cpp
index 50c8f561c1732d6f7f37ae5b8d6f03c4e135939c..55be9636f4596b0deeb81d0174b717a91ff76644 100644
--- a/src/recipes/FuseBatchNorm.cpp
+++ b/src/recipes/FuseBatchNorm.cpp
@@ -117,7 +117,7 @@ void Aidge::fuseBatchNorm(std::shared_ptr<Aidge::Node> convNode,
auto prod = addProducer(metaNode, inputIdx, {convNbOutChannels}, "b");
// Add the new bias node to the same views as the meta node
- for (auto g : metaNode->views()) {
+ for (auto& g : metaNode->views()) {
g->add(prod);
}
}
@@ -126,12 +126,12 @@ void Aidge::fuseBatchNorm(std::shared_ptr<Aidge::Node> convNode,
if (convNode->input(1).first) {
// Add the new bias node to the same views as the weights node
// if possible
- for (auto g : convNode->input(1).first->views()) {
+ for (auto& g : convNode->input(1).first->views()) {
g->add(prod);
}
}
else {
- for (auto g : convNode->views()) {
+ for (auto& g : convNode->views()) {
g->add(prod);
}
}
diff --git a/src/scheduler/MemoryManager.cpp b/src/scheduler/MemoryManager.cpp
index ba805f919a607e0b2ae3272d173aa11360548fa7..05f461b82f16b6af4ed412b7336aa2328bcafbe1 100644
--- a/src/scheduler/MemoryManager.cpp
+++ b/src/scheduler/MemoryManager.cpp
@@ -634,152 +634,6 @@ void Aidge::MemoryManager::tick()
++mClock;
}
-void Aidge::MemoryManager::log(const std::string& fileName) const
-{
- auto memData = std::unique_ptr<FILE, decltype(&std::fclose)>(std::fopen(fileName.c_str(), "w"), &std::fclose);
-
- if (!memData) {
- AIDGE_THROW_OR_ABORT(std::runtime_error,
- "Could not create memory layout log file: {}", fileName);
- }
-
- auto gnuplot = std::unique_ptr<FILE, decltype(&std::fclose)>(std::fopen((fileName + "_plot.gnu").c_str(), "w"), &std::fclose);
-
- if (!gnuplot) {
- AIDGE_THROW_OR_ABORT(std::runtime_error,
- "Could not create memory layout log file: {}", (fileName + "_plot.gnu"));
- }
-
- const Clock_T maxLifetime = getMaxLifetime();
- const unsigned int peakUsage = getPeakUsage();
-
- fmt::print(gnuplot.get(), "#!/usr/bin/gnuplot\n");
- fmt::print(gnuplot.get(), "set term pngcairo size 1280,768 noenhanced\n");
- fmt::print(gnuplot.get(), "set output \"{}\"\n", fileName + "_plot.png");
- fmt::print(gnuplot.get(), "set xrange [{}:{}]\n", 0, maxLifetime + 1);
- fmt::print(gnuplot.get(), "set yrange [{}:{}]\n", 0, 1.05 * (peakUsage / 1024.0));
- fmt::print(gnuplot.get(), "set xlabel \"Time\"\n");
- fmt::print(gnuplot.get(), "set ylabel \"Memory usage (KWords)\"\n");
- fmt::print(gnuplot.get(), "set grid\n");
- fmt::print(gnuplot.get(), "set xtics 1\n");
- fmt::print(gnuplot.get(), "unset key\n");
- fmt::print(gnuplot.get(), "set palette rgbformulae 30,31,32\n");
- fmt::print(gnuplot.get(), "unset colorbox\n");
- fmt::print(gnuplot.get(), "N={}\n", mMemPlanes.size() + 1);
-
- unsigned int objectId = 1;
- unsigned int labelId = 1;
-
- for (std::map<std::shared_ptr<Node>, std::vector<MemoryPlane> >
- ::const_iterator it = mMemPlanes.begin(), itEnd = mMemPlanes.end();
- it != itEnd; ++it)
- {
- const std::string name = (*it).first->name();
- fmt::print(memData.get(), "{}\n", name);
-
- double minX = -1;
- unsigned int maxY = 0;
-
- for (std::vector<MemoryPlane>::const_iterator itPlanes
- = (*it).second.begin(), itPlanesBegin = (*it).second.begin(),
- itPlanesEnd = (*it).second.end(); itPlanes != itPlanesEnd;
- ++itPlanes)
- {
- const unsigned int contiguousOffset
- = (*itPlanes).getContiguousOffset();
- const unsigned int contiguousSize = (*itPlanes).getContiguousSize();
- const unsigned int wrappedOffset = (*itPlanes).getWrappedOffset();
- const unsigned int wrappedSize = (*itPlanes).getWrappedSize();
-
- const Clock_T allocated = (*itPlanes).allocated;
- const Clock_T released = (*itPlanes).memSpace->released;
- const bool isReleased = (released >= 0
- && (*itPlanes).memSpace->dependencies.empty());
-
- fmt::print(memData.get(), " {} {} ({:#08x}U) -> {} ({:#08x}U)",
- (itPlanes - itPlanesBegin), contiguousOffset, contiguousOffset,
- (contiguousOffset + contiguousSize), (contiguousOffset + contiguousSize));
-
- if (wrappedSize > 0) {
- fmt::print(memData.get(), " + {} ({:#08x}U) -> {} ({:#08x}U)",
- wrappedOffset, wrappedOffset,
- (wrappedOffset + wrappedSize), (wrappedOffset + wrappedSize));
- }
-
- fmt::print(memData.get(), " [{}] @ {}", (*itPlanes).getSize(), allocated);
-
- if (isReleased) {
- fmt::print(memData.get(), " to {}", released);
- }
-
- fmt::print(memData.get(), "\n");
-
- // Gnuplot
- const double startX = allocated;
-
- if (startX < minX || minX < 0) {
- minX = startX;
- maxY = contiguousOffset + contiguousSize;
- }
-
- if ((*itPlanes).size != (*itPlanes).stride) {
- for (unsigned int offset = contiguousOffset;
- offset < contiguousOffset + contiguousSize;
- offset += (*itPlanes).stride)
- {
- fmt::print(gnuplot.get(), "set object {} rectangle from {},{} to {},{} fc palette frac ({} * 1./N)\n",
- (allocated * 100 + objectId), startX, (offset / 1024.0),
- (((isReleased) ? released : maxLifetime) + 1),
- (std::min((offset + (*itPlanes).size),
- contiguousOffset + contiguousSize) / 1024.0),
- labelId);
- ++objectId;
- }
- }
- else {
- fmt::print(gnuplot.get(), "set object {} rectangle from {},{} to {},{} fc palette frac ({} * 1./N)\n",
- (allocated * 100 + objectId), startX, (contiguousOffset / 1024.0),
- (((isReleased) ? released : maxLifetime) + 1),
- ((contiguousOffset + contiguousSize) / 1024.0),
- labelId);
- ++objectId;
- }
-
- if (wrappedSize > 0) {
- fmt::print(gnuplot.get(), "set object {} rectangle from {},{} to {},{} fc palette frac ({} * 1./N)\n",
- (allocated * 100 + objectId), startX, (wrappedOffset / 1024.0),
- (((isReleased) ? released : maxLifetime) + 1),
- ((wrappedOffset + contiguousSize) / 1024.0),
- labelId);
- ++objectId;
-
- fmt::print(gnuplot.get(), "set arrow from {},{} to {},{} nohead\n",
- startX, (contiguousOffset / 1024.0),
- (startX + 0.1), (contiguousOffset / 1024.0));
-
- fmt::print(gnuplot.get(), "set arrow from {},{} to {},{} nohead\n",
- (startX + 0.05), ((contiguousOffset + contiguousSize) / 1024.0),
- (startX + 0.05), (wrappedOffset / 1024.0));
- }
- }
-
- fmt::print(gnuplot.get(), "set label {} '{}' at {},{} rotate by 30 font \",8\" offset char 0.5,0.5\n",
- labelId, name, minX, (maxY / 1024.0));
- ++labelId;
-
- fmt::print(memData.get(), "\n");
- }
-
- fmt::print(gnuplot.get(), "set arrow from 0,{} to {},{} nohead lc rgb \"red\"\n",
- (peakUsage / 1024.0), (maxLifetime + 1),
- (peakUsage / 1024.0));
-
- fmt::print(gnuplot.get(), "set label {} 'Peak usage = {} KWords' at 0,{} textcolor rgb \"red\" offset char 0.5,0.5\n",
- labelId, (peakUsage / 1024.0), (peakUsage / 1024.0));
-
- fmt::print(gnuplot.get(), "plot 0\n");
-}
-
unsigned int Aidge::MemoryManager::onStack(unsigned int size)
{
unsigned int offset = 0;
diff --git a/unit_tests/scheduler/Test_MemoryManager.cpp b/unit_tests/scheduler/Test_MemoryManager.cpp
index a4941203644b7ba291682f3932926a36fa83b745..b6cedfac47d53e0f8ab464fad8a2f6cc6c8dcc15 100644
--- a/unit_tests/scheduler/Test_MemoryManager.cpp
+++ b/unit_tests/scheduler/Test_MemoryManager.cpp
@@ -136,7 +136,6 @@ TEST_CASE("allocate1", "[MemoryManager]") {
REQUIRE(memManager.getPlanes(node4).back().memSpace->allocated == 3);
REQUIRE(memManager.getPlanes(node4).back().memSpace->released == 4);
- memManager.log("MemoryManager_allocate1.log");
}
TEST_CASE("allocate2", "[MemoryManager]") {
@@ -281,7 +280,6 @@ TEST_CASE("allocate2", "[MemoryManager]") {
REQUIRE(memManager.getPlanes(node4).back().memSpace->allocated == 3);
REQUIRE(memManager.getPlanes(node4).back().memSpace->released == 4);
- memManager.log("MemoryManager_allocate2.log");
}
TEST_CASE("allocate3", "[MemoryManager]") {
@@ -438,7 +436,6 @@ TEST_CASE("allocate3", "[MemoryManager]") {
REQUIRE(memManager.getPlanes(node4).back().memSpace->allocated == 0);
REQUIRE(memManager.getPlanes(node4).back().memSpace->released == 4);
- memManager.log("MemoryManager_allocate3.log");
}
TEST_CASE("allocate3_wrapAround", "[MemoryManager]") {
@@ -595,5 +592,4 @@ TEST_CASE("allocate3_wrapAround", "[MemoryManager]") {
REQUIRE(memManager.getPlanes(node4).back().memSpace->allocated == 0);
REQUIRE(memManager.getPlanes(node4).back().memSpace->released == 4);
- memManager.log("MemoryManager_allocate3_wrapAround.log");
}