AidLite C++ API

💡Note: When developing with Aidlite-SDK C++, you need to be aware of the following:

• Include the header file during compilation, located at: /usr/local/include/aidlux/aidlite/aidlite.hpp
• Link the library file during linking, located at: /usr/local/lib/libaidlite.so

Model Data Type enum DataType

For AidliteSDK, it handles different models from different frameworks, and each model has different input data types and output data types. When setting the input and output data types of the model in the usage workflow mentioned above, this data type enumeration is needed.

Member Variable	Type	Value	Description
TYPE_DEFAULT	uint8_t	0	Invalid DataType
TYPE_UINT8	uint8_t	1	Unsigned byte data
TYPE_INT8	uint8_t	2	Byte data
TYPE_UINT32	uint8_t	3	Uint32 data
TYPE_FLOAT32	uint8_t	4	Float32 data
TYPE_INT32	uint8_t	5	Int32 data
TYPE_INT64	uint8_t	6	Int64 data
TYPE_UINT64	uint8_t	7	Uint64 data
TYPE_INT16	uint8_t	8	Int16 data
TYPE_UINT16	uint8_t	9	Uint16 data
TYPE_FLOAT16	uint8_t	10	Float16 data
TYPE_BOOL	uint8_t	11	Bool data

Inference Implementation Type enum ImplementType

Member Variable	Type	Value	Description
TYPE_DEFAULT	uint8_t	0	Invalid ImplementType
TYPE_MMKV	uint8_t	1	Implementation via MMKV (no current implementation, may be removed later)
TYPE_REMOTE	uint8_t	2	Backend implementation via IPC
TYPE_FAST	uint8_t	2	Compatibility alias of TYPE_REMOTE; deprecated and not recommended for new code
TYPE_LOCAL	uint8_t	3	Backend implementation via local calls

💡Note

Special Notes:

The difference between TYPE_LOCAL and TYPE_REMOTE is that, for the Aplux integrated system, the former completes inference locally in the Linux environment without data transfer, while the latter exchanges data with the Android environment through IPC (inter-process communication), and the actual inference process is completed in Android, so data transfer is involved. Therefore, TYPE_LOCAL is the preferred mode whenever it can satisfy the inference workflow.

Model Framework Type enum FrameworkType

As mentioned earlier, AidliteSDK integrates multiple deep learning inference frameworks, so in the usage workflow described above, you need to set which framework's model is currently being used, which requires this framework type enumeration.

Member Variable	Type	Value	Description
TYPE_DEFAULT	uint8_t	0	Invalid FrameworkType
TYPE_SNPE	uint8_t	1	SNPE1.x(dlc) model
TYPE_TFLITE	uint8_t	2	TFLite model
TYPE_RKNN	uint8_t	3	RKNN model
TYPE_QNN	uint8_t	4	QNN model
TYPE_SNPE2	uint8_t	5	SNPE2.x(dlc) model
TYPE_NCNN	uint8_t	6	NCNN model
TYPE_MNN	uint8_t	7	MNN model
TYPE_TNN	uint8_t	8	TNN model
TYPE_PADDLE	uint8_t	9	Paddle model
TYPE_MS	uint8_t	10	MindSpore model
TYPE_ONNX	uint8_t	11	ONNX model
TYPE_QNN216	uint8_t	101	QNN2.16 model
TYPE_SNPE216	uint8_t	102	SNPE2.16 model
TYPE_QNN223	uint8_t	103	QNN2.23 model
TYPE_SNPE223	uint8_t	104	SNPE2.23 model
TYPE_QNN229	uint8_t	105	QNN2.29 model
TYPE_SNPE229	uint8_t	106	SNPE2.29 model
TYPE_QNN231	uint8_t	107	QNN2.31 model
TYPE_QNN236	uint8_t	108	QNN2.36 model
TYPE_QNN240	uint8_t	109	QNN2.40 model

💡Note

Special Notes:

• If the user environment has multiple backend implementation packages installed at the same time, such as AidLite-QNN216, AidLite-QNN223, and AidLite-QNN231, and FrameworkType in the code is set to TYPE_QNN (that is, no specific QNN backend version is explicitly selected), then the backend that actually runs should be the highest available QNN version. In other words, AidLite-QNN231 is preferred for inference. SNPE2 follows the same rule.
• The same program cannot use backend packages of different QNN versions at the same time. In other words, if the program first specifies TYPE_QNN216 for inference, it cannot then use TYPE_QNN223 or TYPE_QNN231 for model inference. SNPE2 follows the same rule.

Acceleration Hardware Type enum AccelerateType

For each deep learning inference framework, it may support running on different acceleration devices (such as SNPE/QNN models running on DSP devices, RKNN models running on NPU devices). Therefore, in the usage workflow described above, you need to set which device the current model is expected to run on, which requires this acceleration hardware enumeration.

Member Variable	Type	Value	Description
TYPE_DEFAULT	uint8_t	0	Invalid AccelerateType
TYPE_CPU	uint8_t	1	CPU acceleration
TYPE_GPU	uint8_t	2	GPU acceleration
TYPE_DSP	uint8_t	3	DSP acceleration
TYPE_NPU	uint8_t	4	NPU acceleration

Log Level enum LogLevel

AidliteSDK provides interfaces for setting logs (which will be introduced later). You need to provide the interface with the current log level to use, so this log level enumeration is needed.

Member Variable	Type	Value	Description
INFO	uint8_t	0	Information
WARNING	uint8_t	1	Warning
ERROR	uint8_t	2	Error
FATAL	uint8_t	3	Fatal error

Device Information Class class DeviceInfo

Starting from version 2.3.1, Aidlite uses DeviceInfo to describe the available underlying inference devices. It is currently mainly used for device queries and custom device configuration in QNN DSP scenarios.

Member Variable List

Member Variable	Type	Default Value	Description
version	uint32_t	0X00020301	Structure version number of DeviceInfo
id	uint32_t	0	Device ID
type	uint32_t	0	Device type number interpreted by the backend
cores_num	uint32_t	1	Number of cores included in the device
cores_id	std::vector<uint32_t>	Empty	List of device core IDs

Input/Output Information Class class TensorInfo

Each model has its own inputs and outputs. For models that developers are not familiar with, they may need to query the input and output tensor information of the model during development to facilitate pre- and post-processing operations for model inference. Aidlite provides interfaces for developers to query detailed information about model inputs and outputs.

Member Variable List

The TensorInfo object is used to store detailed information about model input and output tensors, including the following parameters:

Member Variable	version
Type	uint32_t
Default Value	No default value
Description	This member is used to identify the TensorInfo version. If more information needs to be extended in the future, the version number will be updated

Member Variable	index
Type	uint32_t
Default Value	No default value
Description	Index value of the Tensor

Member Variable	name
Type	std::string
Default Value	No default value
Description	Name string of the Tensor

Member Variable	element_count
Type	uint64_t
Default Value	0
Description	Number of data elements in the Tensor

Member Variable	element_type
Type	enum DataType
Default Value	DataType::TYPE_DEFAULT
Description	Type of data elements in the Tensor

Member Variable	dimensions
Type	uint32_t
Default Value	0
Description	Dimension value of data elements in the Tensor

Member Variable	shape
Type	std::vector< uint64_t >
Default Value	No default value
Description	Shape description of data elements in the Tensor

Model Class .class Model

As mentioned earlier, before creating an inference interpreter, you need to set detailed parameters related to the specific model. The Model class is mainly used to record model file information, structure information, and model-related content during runtime.

Create Empty Instance Object .create_instance()

The current header also provides a no-argument overload that creates an empty Model instance first, allowing the caller to fill in the model path or property information later in the workflow.

API	create_instance
Description	Construct a Model instance object that does not carry a model file path
Parameters	void
Return Value	If the value is nullptr, the function failed to construct the object; otherwise, it is a pointer to the Model object

Create Instance Object .create_instance()

To set detailed information related to the model, you first need to have a model instance object. This function is used to create a Model instance object. If the model framework (such as snpe, tflite, and so on) requires only one model file, call this interface.

API	create_instance
Description	Construct a Model type instance object by passing the path name of the model file
Parameters	model_path: Path name of the model file
Return Value	If it's a nullptr value, it indicates function object construction failure; otherwise it's a pointer to the Model object

// Create model object using inceptionv3_float32.dlc file in current path, error if return value is null
Model* model = Model::create_instance("./inceptionv3_float32.dlc");
if(model == nullptr){
    printf("Create model failed !\n");
    return EXIT_FAILURE;
}

Create Instance Object create_instance()

To set detailed information related to the model, you first need to have a model instance object. This function is used to create a Model instance object. If the model framework (such as ncnn, tnn, etc.) involves two model files, call this interface.

API	create_instance
Description	Construct a Model type instance object by passing the path name of the model file
Parameters	model_struct_path: Path name of the model structure file
	model_weight_path: Path name of the model weight parameter file
Return Value	If it's a nullptr value, it indicates function object construction failure; otherwise it's a pointer to the Model object

// Create model object using two ncnn model files in current path, error if return value is null
Model* model = Model::create_instance("./mobilenet_ssd_voc_ncnn.param", 
     "./mobilenet_ssd_voc_ncnn.bin");
if(model == nullptr){
    printf("Create model failed !\n");
    return EXIT_FAILURE;
}

Set Model Properties set_model_properties()

After the model instance object is successfully created, you need to set the input and output data types of the model and the shape information of the input and output tensor data.

API	set_model_properties
Description	Set model properties, input and output data shapes and data types
Parameters	input_shapes: Shape array of input tensors, two-dimensional array structure
	input_data_type: Data type of input tensors, DataType enumeration type
	output_shapes: Shape array of output tensors, two-dimensional array structure
	output_data_type: Data type of output tensors, DataType enumeration type
Return Value	0 indicates success; a non-zero value indicates failure
Note	1. This interface needs to be called to set detailed input and output information if and only if ImplementType is REMOTE. 2. For the SNPE and QNN inference frameworks, input and output data can only be float32, so this interface must use DataType::TYPE_FLOAT32 as the passed value. For other inference frameworks, the input and output data types should remain consistent with the data types of the model file input and output tensors.

// Data types use the aforementioned DataType enum, input/output shapes are 2D arrays
std::vector<std::vector<uint32_t>> input_shapes = {{1,299,299,3}};
std::vector<std::vector<uint32_t>> output_shapes = {{1,1001}};
model->set_model_properties(input_shapes, DataType::TYPE_FLOAT32, 
    output_shapes, DataType::TYPE_FLOAT32);

Get Model Path get_model_absolute_path()

If the model framework (such as SNPE, TFLite, etc.) involves only one model file, and the Model object construction is successful, the input model file parameter will be converted to an absolute path form.

API	get_model_absolute_path
Description	Used to get the storage path of the model file
Parameters	void
Return Value	Model file path string object corresponding to the Model object

Get Model Path get_model_struct_absolute_path()

If the model framework (such as NCNN, TNN, etc.) involves two model files, and the Model object construction is successful, the input model structure file parameter will be converted to an absolute path form.

API	get_model_struct_absolute_path
Description	Used to get the storage path of the model structure file
Parameters	void
Return Value	Model structure file path string object corresponding to the Model object

Get Model Path get_model_weight_absolute_path()

If the model framework (such as NCNN, TNN, etc.) involves two model files, and the Model object construction is successful, the input model weight parameter file parameter will be converted to an absolute path form.

API	get_model_weight_absolute_path
Description	Used to get the absolute path of the model weight parameter file
Parameters	void
Return Value	String object representing the model weight parameter file path corresponding to the Model object

Configuration Class class Config

Before creating an inference interpreter, in addition to setting the specific Model information, you also need to set some runtime configuration information for inference. The Config class is used to record configuration options that need to be preset, and these configuration items will be used at runtime.

Create Instance Object.create_instance()

To set runtime configuration information, you first need a configuration instance object. This function is used to create a Config instance.

API	create_instance
Description	Used to construct an instance object of the Config class
Parameters	void
Return Value	If the value is nullptr, the function failed to construct the object; otherwise, it is a pointer to the Config object

// Create a configuration instance object; report an error if the return value is null
Config* config = Config::create_instance();
if(config == nullptr){
    printf("Create config failed.\n");
    return EXIT_FAILURE;
}

Member Variable List

The Config object is used to set runtime configuration information, which includes the following parameters:

Member	accelerate_type
Type	enum AccelerateType
Default	AccelerateType.TYPE_CPU
Description	Type of acceleration hardware

Member	implement_type
Type	enum ImplementType
Default	ImplementType.TYPE_DEFAULT
Description	Used to distinguish different environments for backend inference implementation
Note	Developers do not need to explicitly set this configuration item. AidliteSDK will adaptively determine a more suitable ImplementType according to factors such as the current system environment and model framework

Member	framework_type
Type	enum FrameworkType
Default	FrameworkType.TYPE_DEFAULT
Description	Type of the underlying inference framework

Member	number_of_threads
Type	int8_t
Default	-1
Description	Number of threads; valid when greater than 0
Note	This configuration item can be set optionally if and only if framework_type is TFLITE

Member	snpe_out_names
Type	string array
Default	Empty
Description	List of model output node names
Note	This configuration item must be set if and only if framework_type is SNPE

Member	is_quantify_model
Type	Int32_t
Default	0
Description	Whether the model is quantized; 1 indicates a quantized model
Note	This configuration item must be set if and only if implement_type is REMOTE

Member	remote_timeout
Type	Int32_t
Default	-1
Description	Interface timeout duration, in milliseconds; valid when greater than 0
Note	This configuration item can be set optionally if and only if implement_type is REMOTE

Member	qnn_shared_buffer
Type	int32_t
Default	0
Description	Whether to enable the QNN shared buffer; currently mainly used in QNN DSP scenarios

Member	batch_invoke_size
Type	uint32_t
Default	1
Description	Backend batch inference configuration parameter; currently mainly used in QNN DSP scenarios

Member	backend_extension_config
Type	std::string
Default	Empty string
Description	Extension configuration file of the backend inference framework; currently mainly used in QNN DSP scenarios

Member	custom_device_info
Type	std::vector<DeviceInfo>
Default	Empty
Description	Custom device information list used to specify the actual device set used during backend QNN DSP inference

Member	reserved1
Type	int32_t
Default	0
Description	Reserved field. It currently has no business semantics, and callers do not need to set it explicitly

💡Note

remote_timeout in Config shares the same union memory with the historical field fast_timeout. fast_timeout has already been marked as deprecated in the header file and is retained only for compatibility. New code should consistently use remote_timeout.

config->framework_type = FrameworkType::TYPE_QNN;
config->accelerate_type = AccelerateType::TYPE_DSP;
// Set other configuration items as needed
// ... ...

Context Class class Context

Used to store runtime context involved in the execution process, including Model objects and Config objects. More runtime data may be extended in the future.

Constructor Context()

API	Context
Description	Construct Context instance object
Parameters	model: Model instance object pointer
	config: Config instance object pointer
Return Value	Normal: Context instance object

💡Note

Special note: The memory space pointed to by the model and config pointer parameters must be allocated on the heap. After Context is successfully constructed, their lifecycle will be managed by Context (Context will automatically release model and config objects when released), so developers do not need to manually release the space of both, otherwise it will report an error of duplicate object release.

Get Model Member Variable get_model()

API	get_model
Description	Get the Model object pointer managed by context
Parameters	void
Return Value	Pointer to Model object

Get Config Member Variable get_config()

API	get_config
Description	Get the Config object pointer managed by context
Parameters	void
Return Value	Pointer to Config object

Interpreter Class class Interpreter

The Interpreter class object instance is the main body for performing inference operations and is used to execute specific inference processes. In the inference workflow mentioned in the previous sections, after creating the interpreter object, all operations are based on the interpreter object, making it the absolute core content of AidliteSDK.

Create Instance Object create_instance()

To perform inference-related operations, an inference interpreter is essential. This function is used to construct an inference interpreter instance object.

API	create_instance
Description	Construct an Interpreter type object using various data managed by the Context object
Parameters	context: Pointer to Context instance object
Return Value	If nullptr, it indicates the function failed to construct the object; otherwise, it is a pointer to the Interpreter object

// Use Context object pointer to create interpreter object, error if return value is null
Interpreter* current_interpreter = Interpreter::create_instance(context);
if(current_interpreter == nullptr){
    printf("Create Interpreter failed !\n");
    return EXIT_FAILURE;
}

Initialize init()

After the interpreter object is created, some initialization operations need to be performed (such as environment checks, resource construction, etc.).

API	init
Description	Complete the initialization work required for inference
Parameters	void
Return Value	A value of 0 indicates successful initialization; otherwise, a non-zero value indicates failure

// Initialize interpreter, error if return value is non-zero
int result = fast_interpreter->init();
if(result != EXIT_SUCCESS){
    printf("sample : interpreter->init() failed !\n");
    return EXIT_FAILURE;
}

Load Model load_model()

After the interpreter object completes initialization operations, the required model files can be loaded for the interpreter to complete model loading work. The subsequent inference process uses the loaded model resources.

API	load_model
Description	Complete the model loading related work. Since the model file path has been set in the Model object as mentioned above, the model loading operation can be executed directly
Parameters	void
Return Value	A value of 0 indicates successful model loading operation; otherwise, a non-zero value indicates failure

// Load model for interpreter, error if return value is non-zero
int result = fast_interpreter->load_model();
if(result != EXIT_SUCCESS){
    printf("sample : interpreter->load_model() failed !\n");
    return EXIT_FAILURE;
}

Get Input Tensor Details get_input_tensor_info()

If you want to get detailed information about the model's input tensors, you can use this interface to obtain it.

API	get_input_tensor_info
Description	Get detailed information of input Tensor in the model
Parameters	in_tensor_info: Array storing detailed information of input tensor
Return Value	A value of 0 indicates successful retrieval of Tensor details; otherwise, a non-zero value indicates failure
Special Note	This interface is supported starting from version 2.2.5

// Get model input details data, error if return value is non-zero
std::vector<std::vector<TensorInfo>> in_tensor_info;
result = interpreter->get_input_tensor_info(in_tensor_info);
if(result != EXIT_SUCCESS){
    printf("interpreter->get_input_tensor_info() failed !\n");
    return EXIT_FAILURE;
}
for(int gi = 0; gi < in_tensor_info.size(); ++gi){
    for(int ti = 0; ti < in_tensor_info[gi].size(); ++ti){

        std::string tensor_shape_str = std::to_string(in_tensor_info[gi][ti].shape[0]);
        for(int si = 1; si < in_tensor_info[gi][ti].dimensions; ++si){
            tensor_shape_str += " ";
            tensor_shape_str += std::to_string(in_tensor_info[gi][ti].shape[si]);
        }

        printf("Input  tensor : Graph[%d]-Tensor[%d]-name[%s]-element_count[%ld]-element_type[%d]-dimensions[%d]-shape[%s]\n",
                gi, ti, in_tensor_info[gi][ti].name.c_str(), in_tensor_info[gi][ti].element_count, 
                (int)in_tensor_info[gi][ti].element_type, in_tensor_info[gi][ti].dimensions, tensor_shape_str.c_str());
    }
}

Get Output Tensor Details get_output_tensor_info()

If you want to get detailed information about the model's output tensors, you can use this interface to obtain it.

API	get_output_tensor_info
Description	Get detailed information of output Tensor in the model
Parameters	out_tensor_info: Array storing detailed information of output tensor
Return Value	A value of 0 indicates successful retrieval of Tensor details; otherwise, a non-zero value indicates failure
Special Note	This interface is supported starting from version 2.2.5

// Get model output details data, error if return value is non-zero
std::vector<std::vector<TensorInfo>> out_tensor_info;
result = onnx_interpreter->get_output_tensor_info(out_tensor_info);
if(result != EXIT_SUCCESS){
    printf("interpreter->get_output_tensor_info() failed !\n");
    return EXIT_FAILURE;
}
for(int gi = 0; gi < out_tensor_info.size(); ++gi){
    for(int ti = 0; ti < out_tensor_info[gi].size(); ++ti){

        std::string tensor_shape_str = std::to_string(out_tensor_info[gi][ti].shape[0]);
        for(int si = 1; si < out_tensor_info[gi][ti].dimensions; ++si){
            tensor_shape_str += " ";
            tensor_shape_str += std::to_string(out_tensor_info[gi][ti].shape[si]);
        }

        printf("Output tensor : Graph[%d]-Tensor[%d]-name[%s]-element_count[%ld]-element_type[%d]-dimensions[%d]-shape[%s]\n",
                gi, ti, out_tensor_info[gi][ti].name.c_str(), out_tensor_info[gi][ti].element_count, 
                (int)out_tensor_info[gi][ti].element_type, out_tensor_info[gi][ti].dimensions, tensor_shape_str.c_str());
    }
}

Set Input Data set_input_tensor()

As mentioned in the workflow introduction earlier, before setting input data, different preprocessing operations need to be completed for different models to adapt to specific models.

API	set_input_tensor
Description	Set the data of input tensor required for inference
Parameters	in_tensor_idx/in_tensor_name: Index value/name string of input tensor
	input_data: Pointer to the data storage address of input tensor
Return Value	A value of 0 indicates successful setting of input Tensor; otherwise, a non-zero value indicates failure
Special Note	Parameter in_tensor_name is supported starting from version 2.2.5

// Set input data for inference, error if return value is non-zero
// int result = fast_interpreter->set_input_tensor(0, input_tensor_data);
int result = fast_interpreter->set_input_tensor("in_tensor_name", input_tensor_data);
if(result != EXIT_SUCCESS){
    printf("interpreter->set_input_tensor() failed !\n");
    return EXIT_FAILURE;
}

Execute Inference .invoke()

As mentioned in the previous sections about the workflow, after setting up the input data, the next step is naturally to execute the inference process on the input data.

API	invoke
Description	Execute the inference computation process
Parameters	void
Return Value	A value of 0 indicates successful inference execution, otherwise a non-zero value indicates execution failure

// Execute inference operation, non-zero return value indicates error
int result = fast_interpreter->invoke();
if(result != EXIT_SUCCESS){
    printf("sample : interpreter->invoke() failed !\n");
    return EXIT_FAILURE;
}

Get Output Data .get_output_tensor()

After inference is completed, the result data obtained from inference needs to be extracted. As mentioned in the previous sections about the workflow, after extracting the result data, these result data can be processed to determine whether the results are correct.

API	get_output_tensor
Description	Get inference result data after successful inference
Parameters	out_tensor_idx/out_tensor_name: Index value/name string of the output result tensor
	output_data: This value is the address of a pointer variable, the function internally resets the value of this pointer variable
	output_length: The data size (in bytes) of this result output tensor
Return Value	A value of 0 indicates successful output tensor retrieval, otherwise a non-zero value indicates execution failure
Special Note	Parameter out_tensor_name is supported starting from version 2.2.5

// Get inference result data, non-zero return value indicates error
float* out_data = nullptr;
uint32_t output_tensor_length = 0;
// int result = fast_interpreter->get_output_tensor(0, (void**)&out_data, &output_tensor_length);
int result = fast_interpreter->get_output_tensor("out_tensor_name", (void**)&out_data, &output_tensor_length);
if(result != EXIT_SUCCESS){
    printf("interpreter->get_output_tensor() failed !\n");
    return EXIT_FAILURE;
}

Resource Cleanup .destroy()

As mentioned earlier, the interpreter object needs to perform init() initialization operations and model loading operations. Correspondingly, the interpreter also needs to perform some cleanup operations to destroy previously created resources.

API	destroy
Description	Perform necessary cleanup operations
Parameters	void
Return Value	A value of 0 indicates successful cleanup operation, otherwise a non-zero value indicates execution failure

// Execute interpreter cleanup process, non-zero return value indicates error
int result = fast_interpreter->destroy();
if(result != EXIT_SUCCESS){
    printf("sample : interpreter-> destroy() failed !\n");
    return EXIT_FAILURE;
}

Interpreter Creation Class .class InterpreterBuilder

Unified interpreter creation function for Interpreter objects. Use this class to create the required interpreter objects.

Build Interpreter .build_interpreter_from_path()

Build inference interpreter object. Different parameters can be provided, the simplest being just providing the path and name of the model file. If the model framework (such as SNPE, TFLite, etc.) only requires one model file, call this interface.

API	build_interpreter_from_path
Description	Create corresponding interpreter object directly through the path name of the model file
Parameters	path: Path name of the model file
Return Value	Returns a unique_ptr pointer of Interpreter type. If it's a nullptr value, it indicates function object construction failure; otherwise it's a pointer to the Interpreter object

Build Interpreter .build_interpreter_from_path()

Build inference interpreter object. Different parameters can be provided, the simplest being just providing the path and name of the model file. If the model framework (such as NCNN, TNN, etc.) involves two model files, call this interface.

API	build_interpreter_from_path
Description	Create corresponding interpreter object directly through the path name of the model file
Parameters	model_struct_path: Path name of the model structure file
	model_weight_path: Path name of the model weight parameter file
Return Value	Returns a unique_ptr pointer of Interpreter type. If it's a nullptr value, it indicates function object construction failure; otherwise it's a pointer to the Interpreter object

Build Interpreter .build_interpreter_from_model()

Build inference interpreter object. In addition to providing model file paths, Model objects can also be provided, which allows setting not only the model file path and name, but also the input/output data types and input/output data shape information of the model.

API	build_interpreter_from_model
Description	Create corresponding interpreter object by passing in Model object. All Config-related parameters use default values
Parameters	model: Model type object containing model-related data
Return Value	Returns a unique_ptr pointer of Interpreter type. If it's a nullptr value, it indicates function object construction failure; otherwise it's a pointer to the Interpreter object

💡Note

Special note: The memory space pointed to by the model parameter must be allocated on the heap. After successful Interpreter construction, its lifecycle will be managed by the Interpreter (when the Interpreter is released, it will automatically release the model object), so developers do not need to manually release the space for both objects, otherwise duplicate object release errors will occur.

Build Interpreter .build_interpreter_from_model_and_config()

Build inference interpreter object. In addition to the aforementioned methods, Model objects and Config objects can also be provided simultaneously, which allows providing not only model-related information but also more runtime configuration parameters.

API	build_interpreter_from_model_and_config
Description	Create corresponding interpreter object by passing in Model object and Config
Parameters	model: Model type object containing model-related data
	config: Config type object containing configuration parameters
Return Value	Returns a unique_ptr pointer of Interpreter type. If it's a nullptr value, it indicates function object construction failure; otherwise it's a pointer to the Interpreter object

💡Note

Special note: The memory space pointed to by both model and config parameters must be allocated on the heap. After successful Interpreter construction, their lifecycles will be managed by the Interpreter (when the Interpreter is released, it will automatically release both model and config objects), so developers do not need to manually release the space for both objects, otherwise duplicate object release errors will occur.

// Build interpreter by passing in Model and Config objects, null return value indicates error
std::unique_ptr<Interpreter>&& fast_interpreter = 
 InterpreterBuilder::build_interpreter_from_model_and_config(model, config);
if(fast_interpreter == nullptr){
    printf("build_interpreter failed !\n");
    return EXIT_FAILURE;
}

Other Methods

In addition to the aforementioned inference-related interfaces, Aidlite-SDK also provides the following auxiliary interfaces.

Get SDK Version Information .get_library_version()

API	get_library_version
Description	Used to get version-related information of the current aidlite-sdk.
Parameters	void
Return Value	Returns the version information string of the current aidlite-sdk

Set Log Level .set_log_level()

API	set_log_level
Description	Set the current minimum log level, output log data greater than or equal to this log level. By default, prints WARNING level and above logs
Parameters	log_level: Enumeration type LogLevel value
Return Value	Returns 0 by default

Log Output to Standard Terminal .log_to_stderr()

API	log_to_stderr
Description	Set log information output to standard error terminal
Parameters	void
Return Value	Returns 0 by default

Log Output to Text File .log_to_file()

API	log_to_file
Description	Set log information output to specified text file
Parameters	path_and_prefix: Storage path and name prefix of the log file
	also_to_stderr: Indicates whether to simultaneously output logs to stderr terminal, default value is false
Return Value	A value of 0 indicates successful execution, otherwise a non-zero value indicates execution failure

Get Recent Log Information .last_log_msg()

API	last_log_msg
Description	Get the latest log information for a specific log level, usually to get the latest error information
Parameters	log_level: Enumeration type LogLevel value
Return Value	Storage address pointer to the latest log information