Skip to content
Snippets Groups Projects
Commit 5b64071c authored by Cyril Moineau's avatar Cyril Moineau
Browse files

Merge branch 'RemoveSCM' into 'dev'

remove scm

See merge request !25
parents 05400e59 d7d6330b
No related branches found
No related tags found
2 merge requests!33Add and modify operators to run the ConvNeXt onnx model,!25remove scm
Pipeline #62367 passed
......@@ -2,15 +2,9 @@ r"""
Aidge Export for CPP standalone projects
"""
from .utils import ROOT
from .export_registry import ExportLibCpp
from .operators import *
from collections import defaultdict
import aidge_core
from aidge_export_cpp.utils import ROOT
from ._version import *
from .export import *
import re
import os
import numpy as np
import aidge_core
from aidge_core.export_utils.code_generation import *
from aidge_core.mem_info import compute_default_mem_info
from aidge_export_cpp.utils import ROOT
from aidge_export_cpp.utils.converter import numpy_dtype2ctype
from aidge_export_cpp import ExportLibCpp
from aidge_export_cpp.utils.generation import *
# from aidge_export_cpp.memory import *
def generate_input_file(export_folder:str,
array_name:str,
array: np.ndarray):
# If directory doesn't exist, create it
if not os.path.exists(export_folder):
os.makedirs(export_folder)
generate_file(
file_path=f"{export_folder}/{array_name}.h",
template_path=str(ROOT / "templates" / "data" / "inputs.jinja"),
dims = array.shape,
data_t = numpy_dtype2ctype(array.dtype),
name = array_name,
values = array.tolist()
)
def export(export_folder_name, graphview, scheduler, mem_wrapping=False):
print("Warning: This function is deprecated, check tutorial https://eclipse.dev/aidge/source/Tutorial/export_cpp.html to find the new way to generate a C++ export.")
aidge_core.export_utils.scheduler_export(
scheduler,
export_folder_name,
ExportLibCpp,
memory_manager=compute_default_mem_info
memory_manager=aidge_core.mem_info.generate_optimized_memory_info,
memory_manager_args={
"stats_folder": f"{export_folder_name}/stats",
"wrapping": mem_wrapping
}
)
# export_folder = Path().absolute() / export_folder_name
# os.makedirs(str(export_folder), exist_ok=True)
# dnn_folder = export_folder / "dnn"
# os.makedirs(str(dnn_folder), exist_ok=True)
# list_actions = []
# list_configs = []
# peak_mem, mem_info = compute_default_mem_info(scheduler)
# list_forward_nodes = scheduler.get_static_scheduling()
# for node in list_forward_nodes:
# if ExportLibCpp.exportable(node):
# op = ExportLibCpp.get_export_node(node)(node, mem_info[node])
# # For configuration files
# list_configs = op.export(dnn_folder, list_configs)
# # For forward file
# list_actions = op.forward(list_actions)
# else:
# raise RuntimeError(f"Operator not supported: {node.type()} !")
# # Memory management
# # stats_folder = export_folder / "statistics"
# # os.makedirs(str(stats_folder), exist_ok=True)
# # mem_size, mem_info = generate_optimized_memory_info(stats_folder, scheduler, mem_wrapping)
# # peak_mem, mem_info = compute_default_mem_info(scheduler)
# # Generate the memory file
# # generate_file(
# # str(dnn_folder / "memory" / "mem_info.h"),
# # str(ROOT / "templates" / "memory" / "mem_info.jinja"),
# # mem_size = mem_size,
# # mem_info_legends = MEMORY_INFO_TEMPLATE,
# # mem_info = mem_info
# # )
# # list_configs.append("memory/mem_info.h")
# # Get entry nodes
# # Store the datatype & name
# list_inputs_name = []
# for node in graphview.get_input_nodes():
# for idx, node_input_tuple in enumerate(node.inputs()):
# node_input, _ = node_input_tuple
# if node_input is None:
# export_type = aidge2c(node.get_operator().get_output(0).dtype())
# list_inputs_name.append((export_type, f"{node.name()}_input_{idx}"))
# elif node_input not in graphview.get_nodes():
# export_type = aidge2c(node_input.get_operator().get_output(0).dtype())
# list_inputs_name.append((export_type, node_input.name()))
# # Get output nodes
# # Store the datatype & name, like entry nodes
# list_outputs_name = []
# for node in graphview.get_nodes():
# if len(node.get_children()) == 0:
# export_type = aidge2c(node.get_operator().get_output(0).dtype())
# list_outputs_name.append((export_type, f"{node.name()}_output_0"))
# # Generate forward file
# # TODO: for now the mem type is bound for all intermediate results, should change.
# # Note that we may have all inputs constants, hence select output type
# assert len(list_outputs_name) >= 1, f"TODO: requires some output to determine mem type"
# mem_ctype = list_outputs_name[0][0]
# generate_file(
# str(dnn_folder / "src" / "forward.cpp"),
# str(ROOT / "templates" / "network" / "network_forward.jinja"),
# headers=set(list_configs),
# actions=list_actions,
# inputs= list_inputs_name,
# outputs=list_outputs_name,
# mem_ctype=mem_ctype,
# peak_mem=peak_mem
# )
# # Generate dnn API
# generate_file(
# str(dnn_folder / "include" / "dnn.hpp"),
# str(ROOT / "templates" / "network" / "dnn_header.jinja"),
# libraries=[],
# functions=get_functions_from_c_file(str(dnn_folder / "src" / "forward.cpp")),
# )
# # Copy all static files in the export
# shutil.copy(str(ROOT / "static" / "main.cpp"), str(export_folder))
# shutil.copy(str(ROOT / "static" / "Makefile"), str(export_folder))
# shutil.copytree(str(ROOT / "static" / "include"), str(dnn_folder / "include"), dirs_exist_ok=True)
from aidge_core.export_utils import ExportLib
from aidge_export_cpp.utils import ROOT
from aidge_export_cpp import ROOT
class ExportLibCpp(ExportLib):
_name="export_cpp"
......
......@@ -4,12 +4,27 @@ from pathlib import Path
import aidge_core
from aidge_core.export_utils import ExportNode, ExportNodeCpp, generate_file
from aidge_export_cpp.utils import ROOT
from aidge_export_cpp.utils.converter import numpy_dtype2ctype
from aidge_export_cpp import ExportLibCpp
##############################################
############## Export functions ##############
##############################################
def numpy_dtype2ctype(dtype):
if dtype == np.int8:
return "int8_t"
elif dtype == np.int16:
return "int16_t"
elif dtype == np.int32:
return "int32_t"
elif dtype == np.int64:
return "int64_t"
elif dtype == np.float32:
return "float"
elif dtype == np.float64:
return "double"
# Add more dtype mappings as needed
else:
raise ValueError(f"Unsupported {dtype} dtype")
def export_params(name: str,
array: np.ndarray,
......
from pathlib import Path
from importlib.metadata import version
# Constants
FILE = Path(__file__).resolve()
ROOT = FILE.parents[0]
def show_version():
version_aidge_export_cpp = version("aidge_export_cpp")
print(f"Aidge Export CPP: {version_aidge_export_cpp}")
def get_project_version()->str:
return version("aidge_export_cpp")
from pathlib import Path
import os
# Constants
FILE = Path(__file__).resolve()
ROOT = FILE.parents[1]
OPERATORS_REGISTRY = {}
def operator_register(*args):
key_list = [arg for arg in args]
def decorator(operator):
class Wrapper(operator):
def __init__(self, *args, **kwargs):
return operator(*args, **kwargs)
for key in key_list:
OPERATORS_REGISTRY[key] = operator
return Wrapper
return decorator
def supported_operators():
return list(OPERATORS_REGISTRY.keys())
import numpy as np
def numpy_dtype2ctype(dtype):
if dtype == np.int8:
return "int8_t"
elif dtype == np.int16:
return "int16_t"
elif dtype == np.int32:
return "int32_t"
elif dtype == np.int64:
return "int64_t"
elif dtype == np.float32:
return "float"
elif dtype == np.float64:
return "double"
# Add more dtype mappings as needed
else:
raise ValueError(f"Unsupported {dtype} dtype")
import re
import os
import shutil
from jinja2 import Environment, FileSystemLoader
def get_functions_from_c_file(file_path):
functions = []
pattern = r'\w+\s+(\w+)\s*\(([^)]*)\)\s*{'
with open(file_path, 'r') as file:
file_content = file.read()
matches = re.findall(pattern, file_content)
for match in matches:
function_name = match[0]
arguments = match[1].split(',')
arguments = [arg.strip() for arg in arguments]
return_type = get_return_type(file_content, function_name)
function_string = f"{return_type} {function_name}({', '.join(arguments)});"
functions.append(function_string)
return functions
def get_return_type(file_content, function_name):
pattern = rf'\w+\s+{function_name}\s*\([^)]*\)\s*{{'
return_type = re.search(pattern, file_content).group()
return_type = return_type.split()[0].strip()
return return_type
def get_functions_from_c_folder(folder_path):
functions = []
for _, _, files in os.walk(folder_path):
for file in files:
functions += get_functions_from_c_file(os.path.join(folder_path, file))
return functions
def copyfile(filename, dst_folder):
# If directory doesn't exist, create it
if not os.path.exists(dst_folder):
os.makedirs(dst_folder)
shutil.copy(filename, dst_folder)
......@@ -9,7 +9,7 @@ dependencies = [
requires-python = ">= 3.7"
readme = "README.md"
license = { file = "LICENSE" }
classifiers = [
classifiers = [
"Development Status :: 2 - Pre-Alpha",
"Intended Audience :: Developers",
"Intended Audience :: Education",
......@@ -26,7 +26,14 @@ classifiers = [
"Topic :: Scientific/Engineering :: Artificial Intelligence",
"Topic :: Software Development"
]
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_export_cpp"
Issues = "https://gitlab.eclipse.org/eclipse/aidge/aidge_export_cpp/-/issues/"
Changelog = "https://gitlab.eclipse.org/eclipse/aidge/aidge_export_cpp/-/releases"
[project.optional-dependencies]
test = ["pytest"]
......@@ -34,7 +41,7 @@ test = ["pytest"]
[build-system]
requires = [
"setuptools>=64",
"setuptools_scm[toml]==7.1.0"
"pbr"
]
build-backend = "setuptools.build_meta"
......@@ -47,6 +54,4 @@ include = ["aidge_export_cpp"] # package names should match these glob patterns
namespaces = false # to disable scanning PEP 420 namespaces (true by default)
[tool.setuptools.exclude-package-data]
aidge_export_cpp = ["unit_tests*"] # exclude unit_tests which may be included as data
# SETUPTOOLS_SCM
[tool.setuptools_scm]
write_to = "aidge_export_cpp/_version.py"
# pbr file
[metadata]
version = file: version.txt
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment