安 发表于 2020-12-8 13:35 楼主是否方便把这个文件上传一下，in template "app_x-cube-ai_c.ftl" at line 296, column 20。看一下这里 ... [#ftl] [#assign useAI_SYSTEM_PERFORMANCE = false] [#assign useAI_VALIDATION = false] [#assign useAI_TEMPLATE = false] [#assign useAI_BSP = false] [#if RTEdatas??] [#list RTEdatas as define] [#if define?contains("AI_SYSTEM_PERFORMANCE")] [#assign useAI_BSP = true] [#assign useAI_SYSTEM_PERFORMANCE = true] [/#if] [#if define?contains("AI_VALIDATION")] [#assign useAI_BSP = true] [#assign useAI_VALIDATION = true] [/#if] [#if define?contains("AI_ApplicationTemplate")] [#assign useAI_BSP = false] [#assign useAI_TEMPLATE = true] [/#if] [/#list] [/#if] [#assign useAI_RELOC = false] [#attempt] [#list configs as config] [#assign ModelNameList = config.peripheralParams.get("STMicroelectronics.X-CUBE-AI.5.2.0").get("ModelNameList").split(",")] [#assign InitF = config.peripheralParams.get("STMicroelectronics.X-CUBE-AI.5.2.0").get("initFunctions")] [#if config.peripheralParams.get("STMicroelectronics.X-CUBE-AI.5.2.0").get("relocatableNetwork")??] [#assign useAI_RELOC = true] [/#if] [#if InitF??] [#assign InitFunctions = InitF.split(":")] [/#if] [#assign NETWORK = ModelNameList[0]?upper_case] [/#list] [#recover] [/#attempt] #ifdef __cplusplus extern "C" { #endif /** ****************************************************************************** * @file : app_x-cube-ai.c * @brief : AI program body ****************************************************************************** * This notice applies to any and all portions of this file * that are not between comment pairs USER CODE BEGIN and * USER CODE END. Other portions of this file, whether * inserted by the user or by software development tools * are owned by their respective copyright owners. * * Copyright (c) 2018 STMicroelectronics International N.V. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted, provided that the following conditions are met: * * 1. Redistribution of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * 3. Neither the name of STMicroelectronics nor the names of other * contributors to this software may be used to endorse or promote products * derived from this software without specific written permission. * 4. This software, including modifications and/or derivative works of this * software, must execute solely and exclusively on microcontroller or * microprocessor devices manufactured by or for STMicroelectronics. * 5. Redistribution and use of this software other than as permitted under * this license is void and will automatically terminate your rights under * this license. * * THIS SOFTWARE IS PROVIDED BY STMICROELECTRONICS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS, IMPLIED OR STATUTORY WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A * PARTICULAR PURPOSE AND NON-INFRINGEMENT OF THIRD PARTY INTELLECTUAL PROPERTY * RIGHTS ARE DISCLAIMED TO THE FULLEST EXTENT PERMITTED BY LAW. IN NO EVENT * SHALL STMICROELECTRONICS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ****************************************************************************** */ [#if useAI_TEMPLATE] [#if useAI_RELOC] /* * Description * v1.0 - Basic template to show how to instantiate a relocatable binary * model. Only one input and one output is supported. It illustrates * how to use the ai_rel_network_XXX() API. * Re-target of the printf function is out-of-scope. * [#else] /* * Description * v1.0 - Minimum template to show how to use the Embedded Client API * model. Only one input and one output is supported. All * memory resources are allocated statically (AI_NETWORK_XX, defines * are used). * Re-target of the printf function is out-of-scope. * [/#if] * For more information, see the embeded documentation: * * [1] %X_CUBE_AI_DIR%/Documentation/index.html * * X_CUBE_AI_DIR indicates the location where the X-CUBE-AI pack is installed * typical : C:%users\<user_name>\STM32Cube\Repository\STMicroelectronics\X-CUBE-AI\5.2.0 */ [/#if] /* Includes ------------------------------------------------------------------*/ /* System headers */ #include <string.h> #include <stdlib.h> #include <stdio.h> #include <inttypes.h> #include <string.h> #include "app_x-cube-ai.h" [#if useAI_BSP] #include "bsp_ai.h" [#else] #include "main.h" [/#if] [#if useAI_SYSTEM_PERFORMANCE] #include "aiSystemPerformance.h" [/#if] [#if useAI_VALIDATION] #include "aiValidation.h" [/#if] #include "ai_datatypes_defines.h" /* USER CODE BEGIN includes */ /* USER CODE END includes */ [#if useAI_TEMPLATE] [#if useAI_RELOC] #include <ai_reloc_network.h> /* Global AI objects */ static ai_handle ${ModelNameList[0]} = AI_HANDLE_NULL; static ai_network_report ${ModelNameList[0]}_info; static ai_rel_network_info ${ModelNameList[0]}_rt_info; static void ai_log_err(const ai_error err, const char *fct) { /* USER CODE BEGIN 0 */ if (fct) printf("TEMPLATE - Error (%s) - type=0x%02x code=0x%02x\r\n", fct, err.type, err.code); else printf("TEMPLATE - Error - type=0x%02x code=0x%02x\r\n", err.type, err.code); do {} while (1); /* USER CODE END 0 */ } static int ai_boostrap(const uint8_t *obj, uint8_t *ram_addr, ai_size ram_sz, ai_handle w_addr, ai_handle act_addr) { ai_error err; ai_handle weights_addr; /* 1 - Create an instance (XIP mode)*/ err = ai_rel_network_load_and_create(obj, ram_addr, ram_sz, AI_RELOC_RT_LOAD_MODE_XIP, &${ModelNameList[0]}); if (err.type != AI_ERROR_NONE) { ai_log_err(err, "ai_rel_network_load_and_create"); return -1; } /* 2 - Initialize the created instance */ if (${ModelNameList[0]}_rt_info.weights) weights_addr = ${ModelNameList[0]}_rt_info.weights; else weights_addr = w_addr; if (!ai_rel_network_init(${ModelNameList[0]}, weights_addr, act_addr)) { err = ai_rel_network_get_error(${ModelNameList[0]}); ai_log_err(err, "ai_rel_network_init"); ai_rel_network_destroy(${ModelNameList[0]}); ${ModelNameList[0]} = AI_HANDLE_NULL; return -2; } /* 3 - Retrieve the network info of the created instance */ if (!ai_rel_network_get_info(${ModelNameList[0]}, &${ModelNameList[0]}_info)) { err = ai_rel_network_get_error(${ModelNameList[0]}); ai_log_err(err, "ai_rel_network_get_info"); ai_rel_network_destroy(${ModelNameList[0]}); ${ModelNameList[0]} = AI_HANDLE_NULL; return -3; } return 0; } static int ai_run(void *data_in, void *data_out) { ai_i32 batch; ai_buffer *ai_input = ${ModelNameList[0]}_info.inputs; ai_buffer *ai_output = ${ModelNameList[0]}_info.outputs; ai_input[0].data = AI_HANDLE_PTR(data_in); ai_output[0].data = AI_HANDLE_PTR(data_out); batch = ai_rel_network_run(${ModelNameList[0]}, ai_input, ai_output); if (batch != 1) { ai_log_err(ai_rel_network_get_error(${ModelNameList[0]}), "ai_rel_network_run"); return -1; } return 0; } /* USER CODE BEGIN 2 */ int acquire_and_process_data(void * data) { return 0; } int post_process(void * data) { return 0; } /* USER CODE END 2 */ /* USER CODE BEGIN 10 */ /* * The following code is based on the generated/specific * network_img_rel.h/.c files. These files include a * image of the relocatable binary image as a * C-table which is included in the firmware image. * This is a facility to use the model. * * For a normal case with the end-user application which * requires the capability to update the model w/o * re-flash the whole firmware (FOTA-like mechanism), * the BIN_ADDRESS should be provided by the APP module in charge * to update the model. It can be a fixed address. * The requested RT RAM buffer (RAM_RT_ADDRESS/RAM_RT_SIZE) * to instantiate the network can be also fixed or dynamically * allocated. As for the management of the * activations buffer, the sizes of the RT RAM and the activations * buffer are model dependent. */ /* Include the image of the relocatable network */ #include <${ModelNameList[0]}_img_rel.h> #define BIN_ADDRESS ai_${ModelNameList[0]}_reloc_img_get() /* Allocate the rt ram buffer to install a model * - it should be aligned on 4-bytes */ AI_ALIGNED(4) uint8_t reloc_rt_ram[AI_${NETWORK}_RELOC_RAM_SIZE_XIP]; #define RAM_RT_ADDRESS reloc_rt_ram #define RAM_RT_SIZE AI_${NETWORK}_RELOC_RAM_SIZE_XIP /* Allocate the activations buffer to use the model * - it should be aligned on 4-bytes */ AI_ALIGNED(4) uint8_t activations[AI_${NETWORK}_RELOC_ACTIVATIONS_SIZE]; #define ACT_ADDR activations #define ACT_SIZE AI_${NETWORK}_RELOC_ACTIVATIONS_SIZE /* In the case where the weights are not included in the * binary object (generated in a separate file), the * @ should be passed to initialize the instance. * - it should be aligned on 4-bytes */ #define WEIGHTS_ADD 0 #define WEIGHTS_SIZE AI_${NETWORK}_RELOC_WEIGHTS_SIZE /* USER CODE END 10 */ [#else] /* Global AI objects */ static ai_handle ${ModelNameList[0]} = AI_HANDLE_NULL; static ai_network_report ${ModelNameList[0]}_info; /* Global c-array to handle the activations buffer */ AI_ALIGNED(4) static ai_u8 activations[AI_${NETWORK}_DATA_ACTIVATIONS_SIZE]; /* In the case where "--allocate-inputs" option is used, memory buffer can be * used from the activations buffer. This is not mandatory. */ #if !defined(AI_${NETWORK}_INPUTS_IN_ACTIVATIONS) /* Allocate data payload for input tensor */ AI_ALIGNED(4) static ai_u8 in_data_s[AI_${NETWORK}_IN_1_SIZE_BYTES]; #endif /* In the case where "--allocate-outputs" option is used, memory buffer can be * used from the activations buffer. This is no mandatory. */ #if !defined(AI_${NETWORK}_OUTPUTS_IN_ACTIVATIONS) /* Allocate data payload for the output tensor */ AI_ALIGNED(4) static ai_u8 out_data_s[AI_${NETWORK}_OUT_1_SIZE_BYTES]; #endif static void ai_log_err(const ai_error err, const char *fct) { /* USER CODE BEGIN 0 */ if (fct) printf("TEMPLATE - Error (%s) - type=0x%02x code=0x%02x\r\n", fct, err.type, err.code); else printf("TEMPLATE - Error - type=0x%02x code=0x%02x\r\n", err.type, err.code); do {} while (1); /* USER CODE END 0 */ } static int ai_boostrap(ai_handle w_addr, ai_handle act_addr) { ai_error err; /* 1 - Create an instance of the model */ err = ai_${ModelNameList[0]}_create(&${ModelNameList[0]}, AI_${NETWORK}_DATA_CONFIG); if (err.type != AI_ERROR_NONE) { ai_log_err(err, "ai_${ModelNameList[0]}_create"); return -1; } /* 2 - Initialize the instance */ const ai_network_params params = { AI_${NETWORK}_DATA_WEIGHTS(w_addr), AI_${NETWORK}_DATA_ACTIVATIONS(act_addr) }; if (!ai_${ModelNameList[0]}_init(${ModelNameList[0]}, ¶ms)) { err = ai_${ModelNameList[0]}_get_error(${ModelNameList[0]}); ai_log_err(err, "ai_${ModelNameList[0]}_init"); return -1; } /* 3 - Retrieve the network info of the created instance */ if (!ai_${ModelNameList[0]}_get_info(${ModelNameList[0]}, &${ModelNameList[0]}_info)) { err = ai_${ModelNameList[0]}_get_error(${ModelNameList[0]}); ai_log_err(err, "ai_${ModelNameList[0]}_get_error"); ai_${ModelNameList[0]}_destroy(${ModelNameList[0]}); ${ModelNameList[0]} = AI_HANDLE_NULL; return -3; } return 0; } static int ai_run(void *data_in, void *data_out) { ai_i32 batch; ai_buffer *ai_input = ${ModelNameList[0]}_info.inputs; ai_buffer *ai_output = ${ModelNameList[0]}_info.outputs; ai_input[0].data = AI_HANDLE_PTR(data_in); ai_output[0].data = AI_HANDLE_PTR(data_out); batch = ai_${ModelNameList[0]}_run(${ModelNameList[0]}, ai_input, ai_output); if (batch != 1) { ai_log_err(ai_${ModelNameList[0]}_get_error(${ModelNameList[0]}), "ai_${ModelNameList[0]}_run"); return -1; } return 0; } /* USER CODE BEGIN 2 */ int acquire_and_process_data(void * data) { return 0; } int post_process(void * data) { return 0; } /* USER CODE END 2 */ [/#if] [/#if] /************************************************************************* * */ void ${fctName}(void) { [#if useAI_BSP] MX_UARTx_Init(); [/#if] [#if InitFunctions??] [#list InitFunctions as initFunction] [#if initFunction?has_content] [#if initFunction?ends_with(".ftl")] [#include initFunction] [#else] ${initFunction} [/#if] [/#if] [/#list] [/#if] [#if useAI_SYSTEM_PERFORMANCE] aiSystemPerformanceInit(); [/#if] [#if useAI_VALIDATION] aiValidationInit(); [/#if] /* USER CODE BEGIN 3 */ [#if useAI_TEMPLATE] [#if useAI_RELOC] ai_error err; printf("\r\nTEMPLATE RELOC - initialization\r\n"); err = ai_rel_network_rt_get_info(BIN_ADDRESS, &${ModelNameList[0]}_rt_info); if (err.type != AI_ERROR_NONE) { ai_log_err(err, "ai_rel_network_rt_get_info"); } else { /* USER CODE BEGIN 11 */ printf("Load a relocatable binary model, located at the address 0x%08x\r\n", (int)BIN_ADDRESS); printf(" model name : %s\r\n", ${ModelNameList[0]}_rt_info.c_name); printf(" weights size : %d bytes\r\n", (int)${ModelNameList[0]}_rt_info.weights_sz); printf(" activations size : %d bytes (minimum)\r\n", (int)${ModelNameList[0]}_rt_info.acts_sz); printf(" compiled for a Cortex-Mx : 0x%03X\r\n", (int)AI_RELOC_RT_GET_CPUID(${ModelNameList[0]}_rt_info.variant)); printf(" FPU should be enabled : %s\r\n", AI_RELOC_RT_FPU_USED(${ModelNameList[0]}_rt_info.variant)?"yes":"no"); printf(" RT RAM minimum size : %d bytes (%d bytes in COPY mode)\r\n", (int)${ModelNameList[0]}_rt_info.rt_ram_xip, (int)${ModelNameList[0]}_rt_info.rt_ram_copy); /* USER CODE END 11 */ ai_boostrap(BIN_ADDRESS, RAM_RT_ADDRESS, RAM_RT_SIZE, WEIGHTS_ADD, ACT_ADDR); } [#else] printf("\r\nTEMPLATE - initialization\r\n"); ai_boostrap(ai_${ModelNameList[0]}_data_weights_get(), activations); [/#if] [/#if] /* USER CODE END 3 */ } void ${fctProcessName}(void) { [#if useAI_SYSTEM_PERFORMANCE] aiSystemPerformanceProcess(); HAL_Delay(1000); /* delay 1s */ [/#if] [#if useAI_VALIDATION] aiValidationProcess(); [/#if] /* USER CODE BEGIN 4 */ [#if useAI_TEMPLATE] int res = -1; uint8_t *in_data = NULL; uint8_t *out_data = NULL; printf("TEMPLATE - run - main loop\r\n"); if (${ModelNameList[0]}) { if ((${ModelNameList[0]}_info.n_inputs != 1) || (${ModelNameList[0]}_info.n_outputs != 1)) { ai_error err = {AI_ERROR_INVALID_PARAM, AI_ERROR_CODE_OUT_OF_RANGE}; ai_log_err(err, "template code should be updated\r\n to support a model with multiple IO"); return; } /* 1 - Set the I/O data buffer */ [#if useAI_RELOC] const ai_buffer_format fmt_in = AI_BUFFER_FORMAT(&${ModelNameList[0]}_info.inputs[0]); const ai_u32 size_in = AI_BUFFER_BYTE_SIZE(AI_BUFFER_SIZE(&${ModelNameList[0]}_info.inputs[0]), fmt_in); const ai_buffer_format fmt_out = AI_BUFFER_FORMAT(&${ModelNameList[0]}_info.outputs[0]); const ai_u32 size_out = AI_BUFFER_BYTE_SIZE(AI_BUFFER_SIZE(&${ModelNameList[0]}_info.outputs[0]), fmt_out); /* In the case where "--allocate-inputs" option is used, memory buffer can be * used from the activations buffer. This is not mandatory. */ if (${ModelNameList[0]}_info.inputs[0].data) in_data = ${ModelNameList[0]}_info.inputs[0].data; else { in_data = malloc(size_in); } /* In the case where "--allocate-outputs" option is used, memory buffer can be * used from the activations buffer. This is no mandatory. */ if (${ModelNameList[0]}_info.outputs[0].data) out_data = ${ModelNameList[0]}_info.outputs[0].data; else { out_data = malloc(size_out); } [#else] #if AI_${NETWORK}_INPUTS_IN_ACTIVATIONS in_data = ${ModelNameList[0]}_info.inputs[0].data; #else in_data = in_data_s; #endif #if AI_${NETWORK}_OUTPUTS_IN_ACTIVATIONS out_data = ${ModelNameList[0]}_info.outputs[0].data; #else out_data = out_data_s; #endif [/#if] if ((!in_data) || (!out_data)) { printf("TEMPLATE - I/O buffers are invalid\r\n"); return; } /* 2 - main loop */ do { /* 1 - acquire and pre-process input data */ res = acquire_and_process_data(in_data); /* 2 - process the data - call inference engine */ if (res == 0) res = ai_run(in_data, out_data); /* 3- post-process the predictions */ if (res == 0) res = post_process(out_data); } while (res==0); } if (res) { ai_error err = {AI_ERROR_INVALID_STATE, AI_ERROR_CODE_NETWORK}; ai_log_err(err, "rocess has FAILED"); } [/#if] /* USER CODE END 4 */ } [#if ModelNameList?size > 1 || useAI_SYSTEM_PERFORMANCE || useAI_VALIDATION] /* Multiple network support --------------------------------------------------*/ #include <string.h> #include "ai_datatypes_defines.h" static const ai_network_entry_t networks[AI_MNETWORK_NUMBER] = { [#list 0..ModelNameList?size-1 as i] [#assign NETWORK = ModelNameList?upper_case] { .name = (const char *)AI_${NETWORK}_MODEL_NAME, .config = AI_${NETWORK}_DATA_CONFIG, .ai_get_info = ai_${ModelNameList}_get_info, .ai_create = ai_${ModelNameList}_create, .ai_destroy = ai_${ModelNameList}_destroy, .ai_get_error = ai_${ModelNameList}_get_error, .ai_init = ai_${ModelNameList}_init, .ai_run = ai_${ModelNameList}_run, .ai_forward = ai_${ModelNameList}_forward, .ai_data_weights_get_default = ai_${ModelNameList}_data_weights_get, .params = { AI_${NETWORK}_DATA_WEIGHTS(0), AI_${NETWORK}_DATA_ACTIVATIONS(0)}, .extActBufferStartAddr = AI_${NETWORK}_DATA_ACTIVATIONS_START_ADDR, .actBufferSize = AI_${NETWORK}_DATA_ACTIVATIONS_SIZE }, [/#list] }; struct network_instance { const ai_network_entry_t *entry; ai_handle handle; ai_network_params params; }; /* Number of instance is aligned on the number of network */ AI_STATIC struct network_instance gnetworks[AI_MNETWORK_NUMBER] = {0}; AI_DECLARE_STATIC ai_bool ai_mnetwork_is_valid(const char* name, const ai_network_entry_t *entry) { if (name && (strlen(entry->name) == strlen(name)) && (strncmp(entry->name, name, strlen(entry->name)) == 0)) return true; return false; } AI_DECLARE_STATIC struct network_instance *ai_mnetwork_handle(struct network_instance *inst) { for (int i=0; i<AI_MNETWORK_NUMBER; i++) { if ((inst) && (&gnetworks == inst)) return inst; else if ((!inst) && (gnetworks.entry == NULL)) return &gnetworks; } return NULL; } AI_DECLARE_STATIC void ai_mnetwork_release_handle(struct network_instance *inst) { for (int i=0; i<AI_MNETWORK_NUMBER; i++) { if ((inst) && (&gnetworks == inst)) { gnetworks.entry = NULL; return; } } } AI_API_ENTRY const char* ai_mnetwork_find(const char *name, ai_int idx) { const ai_network_entry_t *entry; for (int i=0; i<AI_MNETWORK_NUMBER; i++) { entry = &networks; if (ai_mnetwork_is_valid(name, entry)) return entry->name; else { if (!idx--) return entry->name; } } return NULL; } AI_API_ENTRY ai_error ai_mnetwork_create(const char *name, ai_handle* network, const ai_buffer* network_config) { const ai_network_entry_t *entry; const ai_network_entry_t *found = NULL; ai_error err; struct network_instance *inst = ai_mnetwork_handle(NULL); if (!inst) { err.type = AI_ERROR_ALLOCATION_FAILED; err.code = AI_ERROR_CODE_NETWORK; return err; } for (int i=0; i<AI_MNETWORK_NUMBER; i++) { entry = &networks; if (ai_mnetwork_is_valid(name, entry)) { found = entry; break; } } if (!found) { err.type = AI_ERROR_INVALID_PARAM; err.code = AI_ERROR_CODE_NETWORK; return err; } if (network_config == NULL) err = found->ai_create(network, found->config); else err = found->ai_create(network, network_config); if ((err.code == AI_ERROR_CODE_NONE) && (err.type == AI_ERROR_NONE)) { inst->entry = found; inst->handle = *network; *network = (ai_handle*)inst; } return err; } AI_API_ENTRY ai_handle ai_mnetwork_destroy(ai_handle network) { struct network_instance *inn; inn = ai_mnetwork_handle((struct network_instance *)network); if (inn) { ai_handle hdl = inn->entry->ai_destroy(inn->handle); if (hdl != inn->handle) { ai_mnetwork_release_handle(inn); network = AI_HANDLE_NULL; } } return network; } AI_API_ENTRY ai_bool ai_mnetwork_get_info(ai_handle network, ai_network_report* report) { struct network_instance *inn; inn = ai_mnetwork_handle((struct network_instance *)network); if (inn) return inn->entry->ai_get_info(inn->handle, report); else return false; } AI_API_ENTRY ai_error ai_mnetwork_get_error(ai_handle network) { struct network_instance *inn; ai_error err; err.type = AI_ERROR_INVALID_PARAM; err.code = AI_ERROR_CODE_NETWORK; inn = ai_mnetwork_handle((struct network_instance *)network); if (inn) return inn->entry->ai_get_error(inn->handle); else return err; } AI_API_ENTRY ai_bool ai_mnetwork_init(ai_handle network, const ai_network_params* params) { struct network_instance *inn; ai_network_params par; /* TODO: adding check ai_buffer activations/weights shape coherence */ inn = ai_mnetwork_handle((struct network_instance *)network); if (inn) { par = inn->entry->params; if (params->activations.n_batches) par.activations = params->activations; else par.activations.data = params->activations.data; if (params->params.n_batches) par.params = params->params; else par.params.data = inn->entry->ai_data_weights_get_default(); return inn->entry->ai_init(inn->handle, &par); } else return false; } AI_API_ENTRY ai_i32 ai_mnetwork_run(ai_handle network, const ai_buffer* input, ai_buffer* output) { struct network_instance* inn; inn = ai_mnetwork_handle((struct network_instance *)network); if (inn) return inn->entry->ai_run(inn->handle, input, output); else return 0; } AI_API_ENTRY ai_i32 ai_mnetwork_forward(ai_handle network, const ai_buffer* input) { struct network_instance *inn; inn = ai_mnetwork_handle((struct network_instance *)network); if (inn) return inn->entry->ai_forward(inn->handle, input); else return 0; } AI_API_ENTRY int ai_mnetwork_get_private_handle(ai_handle network, ai_handle *phandle, ai_network_params *pparams) { struct network_instance* inn; inn = ai_mnetwork_handle((struct network_instance *)network); if (inn && phandle && pparams) { *phandle = inn->handle; *pparams = inn->params; return 0; } else return -1; } AI_API_ENTRY int ai_mnetwork_get_ext_data_activations(ai_handle network, ai_u32 *add, ai_u32 *size) { struct network_instance* inn; inn = ai_mnetwork_handle((struct network_instance *)network); if (inn && add && size) { *add = inn->entry->extActBufferStartAddr; *size = inn->entry->actBufferSize; return 0; } else return -1; } [/#if] #ifdef __cplusplus } #endif
