84 lines
3.7 KiB
Python
84 lines
3.7 KiB
Python
"""
|
|
Generic inference function for ONNX, BIE, or NEF model.
|
|
"""
|
|
import pathlib
|
|
import sys
|
|
from typing import List, Optional
|
|
|
|
import numpy.typing as npt
|
|
from sys_flow.compiler_v2 import unpack_nefs as unpack_nefs_v1
|
|
from sys_flow.inference import get_model_io as get_model_io_v1
|
|
from sys_flow_v2.compiler_v2 import unpack_nefs as unpack_nefs_v2
|
|
from sys_flow_v2.inference import get_model_io as get_model_io_v2
|
|
|
|
ROOT_FOLDER = pathlib.Path(__file__).resolve().parent.parent
|
|
sys.path.append(str(ROOT_FOLDER))
|
|
|
|
from python_flow.common import constants
|
|
from python_flow.common import exceptions
|
|
from python_flow.utils import csim
|
|
from python_flow.utils import dynasty
|
|
from python_flow.utils import utils
|
|
|
|
def kneron_inference(pre_results: List[npt.ArrayLike], input_names: Optional[List[str]],
|
|
nef_file: str = "", onnx_file: str = "", bie_file: str = "",
|
|
model_id: Optional[int] = None, data_type: str = "float",
|
|
reordering: Optional[List[str]] = None,
|
|
platform: int = 520) -> List[npt.ArrayLike]:
|
|
"""Performs inference on the input model given the specified parameters.
|
|
|
|
Input pre_results should be in channel first.
|
|
|
|
Arguments:
|
|
pre_results: List of NumPy arrays in channel first format from preprocessing.
|
|
input_names: List of input node names of the model.
|
|
nef_file: String path to NEF model for inference.
|
|
onnx_file: String path to ONNX model for inference, unused if nef_file is specified.
|
|
bie_file: String path to BIE model for inference, unused if nef_file/onnx_file is
|
|
specified.
|
|
model_id: Integer of model to run inference, only necessary for NEF with multiple models.
|
|
data_type: String format of the resulting output, "fixed" or "float".
|
|
reordering: List of string node names specifying the output order.
|
|
platform: Integer indicating platform of BIE or NEF.
|
|
|
|
Returns:
|
|
A list of NumPy arrays of either floats or integers, depending on 'data_type'. If
|
|
data_type is "float", results will be float arrays. If data_type is "fixed", results
|
|
will be fixed arrays.
|
|
"""
|
|
try:
|
|
inputs = utils.prep_inputs(pre_results, input_names, True, inp_trans=None)
|
|
if platform in constants.PLATFORMS_MO3:
|
|
unpack_nefs = unpack_nefs_v1
|
|
get_model_io = get_model_io_v1
|
|
else:
|
|
unpack_nefs = unpack_nefs_v2
|
|
get_model_io = get_model_io_v2
|
|
|
|
if nef_file:
|
|
nef = pathlib.Path(nef_file).resolve()
|
|
model_maps, _p_out = unpack_nefs(nef, platform)
|
|
output = csim.csim_inference(nef, inputs, reordering, True, model_maps,
|
|
platform=platform, model_id=model_id, data_type=data_type,
|
|
oup_trans=None)
|
|
elif onnx_file:
|
|
onnx = pathlib.Path(onnx_file).resolve()
|
|
input_nodes, _, out_node_shape, _ = get_model_io(onnx)
|
|
output = dynasty.dynasty_inference(
|
|
str(onnx), inputs, reordering, True, input_nodes, out_node_shape, data_type=data_type,
|
|
oup_trans=None)
|
|
elif bie_file:
|
|
bie = pathlib.Path(bie_file).resolve()
|
|
input_nodes, _, out_node_shape, d_ioinfo = get_model_io(bie, platform)
|
|
output = dynasty.dynasty_inference(
|
|
str(bie), inputs, reordering, True, input_nodes, out_node_shape,
|
|
is_fixed=True, platform=platform, data_type=data_type, oup_trans=None,
|
|
d_ioinfo=d_ioinfo)
|
|
|
|
else:
|
|
raise exceptions.RequiredConfigError("No input model selected for inference.")
|
|
except exceptions.ConfigError as error:
|
|
sys.exit(error)
|
|
|
|
return output
|