队列方式模型推理

多Device切换

开发应用时，如果涉及多Device之间的任务等待，则应用程序中必须包含相关的代码逻辑，关于该场景的接口调用流程，请依次参见AscendCL接口调用流程以及本节中的说明。

图1 同步等待流程_多Device场景

在多Device时，利用Context切换（调用aclrtSetCurrentContext接口）来切换Device，比使用aclrtSetDevice接口效率高。
调用aclrtSynchronizeDevice接口等待Device上的计算任务结束。
模型加载与执行的流程请参见基础推理应用。
算子加载与执行的流程请参见单算子调用。

父主题： 扩展更多特性

多模型串联推理

多模型推理的基本流程与单模型类似，请参见基础推理应用。

多模型推理与单模型推理在AscendCL接口使用上的不同点如下：

关于模型加载，如果涉及多个模型，需调用多次模型加载接口。模型加载请参见模型加载。
关于模型执行，如果涉及多个模型，需调用多次模型执行接口。模型执行请参见模型执行。

例如，调用aclmdlExecute接口实现同步模型推理。

父主题： 扩展更多特性

多Batch模型推理

多Batch推理的基本流程与单Batch类似，请参见基础推理应用。

多Batch推理与单Batch推理的不同点在于：

多Batch场景下，在构建模型时，使用ATC工具的input_shape参数需根据实际的Batch数设置batch size值，详细说明请参见《ATC工具使用指南》。
在推理前，需要编写一段代码，实现逻辑为：等输入数据满足多Batch（例如：8Batch）的要求，申请Device上的内存存放多Batch的数据，作为模型推理的输入。如果最后循环遍历所有的输入数据后，仍不满足多Batch的要求，则直接将剩余数据作为模型推理的输入。

调用接口后，需增加异常处理的分支，并记录报错日志、提示日志，此处不一一列举。以下是关键步骤的代码示例，不可以直接拷贝编译运行，仅供参考，此处以8Batch为例：

uint32_t batchSize = 8;
uint32_t deviceNum = 1;
uint32_t deviceId = 0;

// 获取模型第一个输入的大小
uint32_t modelInputSize = aclmdlGetInputSizeByIndex(modelDesc, 0);
// 获取每个Batch输入数据的大小
uint32_t singleBuffSize = modelInputSize / batchSize;

// 定义该变量，用于累加batch size是否达到8Batch
uint32_t cnt = 0;
// 定义该变量，用于描述每个文件读入内存时的位置偏移
uint32_t pos = 0;

void* p_batchDst = NULL;
std::vector<std::string>inferFile_vec;

for (int i = 0; i < files.size(); ++i) 
        &#123;
            // 每8个文件，申请一次Device上的内存，存放8Batch的输入数据 
            if (cnt % batchSize == 0)
            &#123;
                pos = 0;
                inferFile_vec.clear();
                // 申请Device上的内存
                ret = aclrtMalloc(&p_batchDst, modelInputSize, ACL_MEM_MALLOC_NORMAL_ONLY);
            &#125;

            // TODO: 从某个目录下读入文件，计算文件大小fileSize
            
            // 根据文件大小，申请内存，存放文件数据
            ret = aclrtMallocHost(&p_imgBuf, fileSize);

            // 将数据传输到Device的内存
            ret = aclrtMemcpy((uint8_t *)p_batchDst + pos, fileSize, p_imgBuf, fileSize, ACL_MEMCPY_HOST_TO_DEVICE);
            pos += fileSize;
            // 及时释放不使用的内存
            aclrtFreeHost(p_imgBuf);

            // 将第i个文件存入vector中，同时cnt+1
            inferFile_vec.push_back(files[i]);
            cnt++;

            // 每8Batch的输入数据送给模型推理进行推理
            if (cnt % batchSize == 0)
            &#123;
                // TODO: 创建aclmdlDataset、aclDataBuffer类型的数据，用于描述模型的输入、输出数据
                // TODO: 调用aclmdlExecute接口执行模型推理
                // TODO: 推理结束后，调用aclrtFree接口释放Device上的内存
            &#125;
        &#125;

// 如果最后循环遍历所有的输入数据后，仍不满足多Batch的要求，则直接将剩余数据作为模型推理的输入。
if (cnt % batchSize != 0)
    &#123;
            // TODO: 创建aclmdlDataset、aclDataBuffer类型的数据，用于描述模型的输入、输出数据
            // TODO: 调用aclmdlExecute接口执行模型推理
            // TODO: 推理结束后，调用aclrtFree接口释放Device上的内存
    &#125;

父主题： 扩展更多特性

队列方式模型推理

关于模型推理场景下的主要接口调用流程，请参见AscendCL接口调用流程。

基本原理

调用aclmdlLoadFromFileWithQ或aclmdlLoadFromMemWithQ接口以队列方式加载模型。
调用acltdtEnqueueData接口将模型的输入数据传入队列，由AscendCL内部根据队列中的输入数据进行推理，无需调用模型执行的接口。
调用acltdtDequeueData接口等待模型推理执行完毕，再由用户从输出内存中获取结果数据。

:::note 说明如果涉及多线程，当模型有多个输入时，多个输入数据的入队任务（即调用acltdtEnqueueData接口）必须在同一个线程中；当模型有多个输出时，多个输出数据的出队任务（即调用acltdtDequeueData接口）必须在同一个线程中。 :::

示例代码

调用接口后，需增加异常处理的分支，并记录报错日志、提示日志，此处不一一列举。以下是关键步骤的代码示例，不可以直接拷贝编译运行，仅供参考。

#include "acl/acl.h"
// ......
// 1. AscendCL初始化
// 此处的..表示相对路径，相对可执行文件所在的目录
// 例如，编译出来的可执行文件存放在out目录下，此处的..就表示out目录的上一级目录
const char *aclConfigPath = "../src/acl.json";
aclInit(aclConfigPath);

// 2. 申请运行管理资源
extern bool g_isDevice;
aclrtSetDevice(deviceId_);
aclrtCreateContext(&context_, deviceId_);
aclrtCreateStream(&stream_);
// 获取当前昇腾AI软件栈的运行模式，根据不同的运行模式，后续的内存申请、内存复制等接口调用方式不同
aclrtRunMode runMode;
aclError ret = aclrtGetRunMode(&runMode);
g_isDevice = (runMode == ACL_DEVICE);

// 3. 加载并执行模型
// 此处的..表示相对路径，相对可执行文件所在的目录
// 例如，编译出来的可执行文件存放在out目录下，此处的..就表示out目录的上一级目录
const char* omModelPath = "../model/resnet50.om"

// 3.1 创建模型的输入队列，如果模型有多个输入，则创建多个输入队列，此处以一个输入为例
acltdtQueueAttr *attr = acltdtCreateQueueAttr();
uint32_t *inputQueueList = new (nothrow) uint32_t[num];
int32_t inputNum = 1;

for (int n = 0; n < inputNum; n++) &#123;
        uint32_t inputQid;
        ret = acltdtCreateQueue(attr, &inputQid);
        inputQueueList[n] = inputQid;
    &#125;

// 3.2 创建模型的输出队列，如果模型有多个输出，则创建多个输出队列，此处以一个输出为例
uint32_t *outputQueueList = new (nothrow) uint32_t[num];
int32_t outputNum = 1;

for (int n = 0; n < outputNum; n++) &#123;
        uint32_t outputQid;
        ret = acltdtCreateQueue(attr, &outputQid);
        outputQueueList[n] = outputQid;
    &#125;

// 3.3 加载模型
uint32_t modelId;
ret= aclmdlLoadFromFileWithQ(modelPath, &modelId, 
                             inputQueueList, inputNum, outputQueueList, outputNum);

// 3.4 根据模型的ID，获取该模型的描述信息
aclmdlDesc *modelDesc = aclmdlCreateDesc();
ret = aclmdlGetDesc(modelDesc, modelId);

// 3.5 获取模型的输入内存大小，如果模型有多个输入，则需要获取每个输入的内存大小，此处以一个输入为例
size_t inputSize = aclmdlGetInputSizeByIndex(modelDesc, 0);

// 3.6 加载测试图片数据，进行推理，并对推理结果数据进行后处理
string testFile[] = &#123;
        "../data/dog1_1024_683.bin",
        "../data/dog2_1024_683.bin"
&#125;;

for (size_t index = 0; index < sizeof(testFile) / sizeof(testFile[0]); ++index) &#123;
        uint32_t devBufferSize;
        void *picDevBuffer = nullptr;
        // 自定义函数ReadBinFile，根据昇腾AI软件栈的运行模式，申请对应的内存，再调用C++标准库中的函数将图片数据读入内存
        ret = Utils::ReadBinFile(testFile[index], picDevBuffer, devBufferSize);

        // 将模型输入数据传入队列中，执行模型推理，-1是表示阻塞程序直到输入数据入队完成
        ret = acltdtEnqueueData(inputQid, picDevBuffer, devBufferSize, nullptr, 0, -1, 0);
        // 获取每个输出的大小
	size_t dataSize = aclmdlGetOutputSizeByIndex(modelDesc, 0);
	void *data = nullptr;
        size_t retDataSize = 0;
        // 为模型输出数据申请内存
	if (!g_isDevice) &#123;
            aclError aclRet = aclrtMallocHost(&data, dataSize);
	 &#125; else &#123;
	    aclError aclRet = aclrtMalloc(&data, dataSize, ACL_MEM_MALLOC_NORMAL_ONLY);
	 &#125;
         // 等待模型推理执行完毕，从输出内存中获取结果数据，-1是表示阻塞程序直到推理输出数据入队完成
         ret = acltdtDequeueData(outputQid, data, dataSize, &retDataSize, nullptr, 0, -1);
         //将输出内存中的数据转换为float类型
         float *outData = NULL;
         outData = reinterpret_cast<float*>(data);
        
         //屏显每张图片的top5置信度的类别编号
         map<float, int, greater<float> > resultMap;
         for (int j = 0; j < len / sizeof(float); ++j) &#123;
            resultMap[*outData] = j;
            outData++;
         &#125;
         int cnt = 0;
         for (auto it = resultMap.begin(); it != resultMap.end(); ++it) &#123;
            // print top 5
            if (++cnt > 5) &#123;
               break;
            &#125;
            INFO_LOG("top %d: index[%d] value[%lf]", cnt, it->second, it->first);
         &#125;
         if (!g_isDevice) &#123;
            aclError aclRet = aclrtFreeHost(picDevBuffer);
            aclrtFreeHost(data);
	 &#125; else &#123;
	    aclError aclRet = aclrtFree(picDevBuffer);
            aclrtFree(data); 
	 &#125;
&#125;

// 4. 卸载模型，并释放模型推理相关资源
aclmdlUnload(modelId);
aclmdlDestroyDesc(modelDesc);
acltdtDestroyQueue(inputQid);
acltdtDestroyQueue(outputQid);
acltdtDestroyQueueAttr(attr);

// 6. 释放运行管理资源
aclrtDestroyStream(stream_);
aclrtDestroyContext(context_);
aclrtResetDevice(deviceId_);

// 7. AscendCL去初始化
aclFinalize();
// ......

父主题： 扩展更多特性

异步模型推理

接口调用流程

开发应用时，如果涉及异步场景下的同步等待，则应用程序中必须包含相关的代码逻辑，关于该场景的接口调用流程，请参见下图。

图1 同步等待流程_Callback场景

关键接口说明如下：

回调函数需由用户提前创建，用于获取并处理模型推理或算子执行的结果。
线程需由用户提前创建，并自定义线程函数，在线程函数内调用aclrtProcessReport接口，设置超时时间，等待aclrtLaunchCallback接口下发的回调任务执行。
调用aclrtSubscribeReport接口：指定处理Stream上回调函数的线程，线程与2中创建的线程保持一致。
异步推理时调用aclmdlExecuteAsync接口。

对于异步接口，还需调用aclrtSynchronizeStream接口阻塞应用程序运行，直到指定Stream中的所有任务都完成。

用户可以在aclrtSynchronizeStream接口之后一次性获取所有图片的异步推理结果，但如果图片数据量较大的情况下，需要等待的时间比较长，这时可以使用Callback功能，每隔一段时间下发一次Callback任务，获取前一段时间内的异步推理结果。
调用aclrtLaunchCallback接口：在Stream的任务队列中下发一个回调任务，系统内部在执行到该回调任务时，会在Stream上注册的线程（通过aclrtSubscribeReport接口注册的线程）中执行回调函数，回调函数与1中的回调函数保持一致。

每调用一次本接口，就会触发一次回调函数的执行。
调用aclrtUnSubscribeReport接口：取消线程注册（Stream上的回调函数不再由指定线程处理）。

示例代码

您可以从样例介绍中获取完整样例代码。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 cpp #include "acl/acl.h" // ...... // 1. AscendCL初始化 // 此处的..表示相对路径，相对可执行文件所在的目录 // 例如，编译出来的可执行文件存放在out目录下，此处的..就表示out目录的上一级目录 const char *aclConfigPath = "../src/acl.json"; aclError ret = aclInit(aclConfigPath); // 2. 申请运行管理资源 extern bool g_isDevice; ret = aclrtSetDevice(deviceId_); ret = aclrtCreateContext(&context_, deviceId_); ret = aclrtCreateStream(&stream_); // 获取当前昇腾AI软件栈的运行模式，根据不同的运行模式，后续的内存申请、内存复制等接口调用方式不同 aclrtRunMode runMode; ret = aclrtGetRunMode(&runMode); g_isDevice = (runMode == ACL_DEVICE); // 3. 申请模型推理资源 // 此处的..表示相对路径，相对可执行文件所在的目录 // 例如，编译出来的可执行文件存放在out目录下，此处的..就表示out目录的上一级目录 const char* omModelPath = "../model/resnet50.om" // 3.1 加载模型 // 根据模型文件获取模型执行时所需的权值内存大小、工作内存大小，并申请权值内存、工作内存 ret = aclmdlQuerySize(omModelPath, &modelMemSize_, &modelWeightSize_); ret = aclrtMalloc(&modelMemPtr_, modelMemSize_, ACL_MEM_MALLOC_NORMAL_ONLY); ret = aclrtMalloc(&modelWeightPtr_, modelWeightSize_, ACL_MEM_MALLOC_NORMAL_ONLY); // 加载离线模型文件，模型加载成功，返回标识模型的ID。 ret = aclmdlLoadFromFileWithMem(modelPath, &modelId_, modelMemPtr_, modelMemSize_, modelWeightPtr_, modelWeightSize_); // 3.2 根据模型的ID，获取该模型的描述信息 modelDesc_ = aclmdlCreateDesc(); ret = aclmdlGetDesc(modelDesc_, modelId_); // 3.3 自定义函数InitMemPool，初始化内存池，存放模型推理的输入数据、输出数据 // -----自定义函数InitMemPool内部的关键实现----- string testFile[] = { "../data/dog1_1024_683.bin", "../data/dog2_1024_683.bin" }; size_t fileNum = sizeof(testFile) / sizeof(testFile[0]); // g_memoryPoolSize表示内存池中的内存块的个数默认为100个 for (size_t i = 0; i < g_memoryPoolSize; ++i) { size_t index = i % (sizeof(testFile) / sizeof(testFile[0])); // model process uint32_t devBufferSize; // 自定义函数GetDeviceBufferOfFile，完成以下功能： // 获取存放输入图片数据的内存及内存大小、将图片数据传输到Device void *picDevBuffer = Utils::GetDeviceBufferOfFile(testFile[index], devBufferSize); aclmdlDataset *input = nullptr; // 自定义函数CreateInput，创建aclmdlDataset类型的数据input，用于存放模型推理的输入数据 Result ret = CreateInput(picDevBuffer, devBufferSize, input); aclmdlDataset *output = nullptr; // 自定义函数CreateOutput，创建aclmdlDataset类型的数据output，用于存放模型推理的输出数据，modelDesc表示模型的描述信息 CreateOutput(output, modelDesc); { std::lock_guard<std::recursive_mutex> lk(freePoolMutex_); freeMemoryPool_[input] = output; } } // -----自定义函数InitMemPool内部的关键实现----- // 4 模型推理 // 4.1 创建线程tid，并将该tid线程指定为处理Stream上回调函数的线程 // 其中ProcessCallback为线程函数，在该函数内调用aclrtProcessReport接口，等待指定时间后，触发回调函数处理 pthread_t tid; (void)pthread_create(&tid, nullptr, ProcessCallback, &s_isExit); // 4.2 指定处理Stream上回调函数的线程 aclError aclRt = aclrtSubscribeReport(tid, stream_); // 4.2 创建回调函数，用户处理模型推理的结果，由用户自行定义 void ModelProcess::CallBackFunc(void *arg) { std::map<aclmdlDataset *, aclmdlDataset *> *dataMap = (std::map<aclmdlDataset *, aclmdlDataset *> *)arg; aclmdlDataset *input = nullptr; aclmdlDataset *output = nullptr; MemoryPool *memPool = MemoryPool::Instance(); for (auto& data : *dataMap) { ModelProcess::OutputModelResult(data.second); memPool->FreeMemory(data.first, data.second); } delete dataMap; } // 4.3 自定义函数ExecuteAsync，执行模型推理 // -----自定义函数ExecuteAsync内部的关键实现开始----- // g_callbackInterval表示callback间隔，默认为1，表示1次异步推理后，下发一次callback任务 bool isCallback = (g_callbackInterval != 0); size_t callbackCnt = 0; std::map<aclmdlDataset *, aclmdlDataset *> *dataMap = nullptr; aclmdlDataset *input = nullptr; aclmdlDataset *output = nullptr; MemoryPool *memPool = MemoryPool::Instance(); // g_executeTimes表示执行模型异步推理的次数，默认为100次 for (uint32_t cnt = 0; cnt < g_executeTimes; ++cnt) { if (memPool->mallocMemory(input, output) != SUCCESS) { ERROR_LOG("get free memory failed"); return FAILED; } // 执行异步推理 aclError ret = aclmdlExecuteAsync(modelId_, input, output, stream_); if (isCallback) { if (dataMap == nullptr) { dataMap = new std::map<aclmdlDataset *, aclmdlDataset *>; if (dataMap == nullptr) { ERROR_LOG("malloc list failed, modelId is %u", modelId_); memPool->FreeMemory(input, output); return FAILED; } } (*dataMap)[input] = output; callbackCnt++; if ((callbackCnt % g_callbackInterval) == 0) { // 在Stream的任务队列中增加一个需要执行的回调函数 ret = aclrtLaunchCallback(CallBackFunc, (void *)dataMap, ACL_CALLBACK_BLOCK, stream_); if (ret != ACL_SUCCESS) { ERROR_LOG("launch callback failed, index=%zu", callbackCnt); memPool->FreeMemory(input, output); delete dataMap; return FAILED; } dataMap = nullptr; } } } // -----自定义函数ExecuteAsync内部的关键实现结束----- // 4.4 对于异步推理，需阻塞应用程序运行，直到指定Stream中的所有任务都完成 aclrtSynchronizeStream(stream_); // 4.5 取消线程注册，Stream上的回调函数不再由指定线程处理 aclRt = aclrtUnSubscribeReport(static_cast<uint64_t>(tid), stream_); s_isExit = true; (void)pthread_join(tid, nullptr); // 5 释放运行管理资源 aclError ret = aclrtDestroyStream(stream_); ret = aclrtDestroyContext(context_); ret = aclrtResetDevice(deviceId_); // 6 AscendCL去初始化 ret = aclFinalize(); // ......

父主题： 扩展更多特性

使用约束

对同一个模型，AIPP（包括静态AIPP和动态AIPP）与动态维度（ND格式）不能同时使用。
对同一个模型，以下方式，只能选择其中一种：
- 调用aclmdlSetDatasetTensorDesc接口设置Shape范围
- 调用aclmdlSetDynamicBatchSize接口设置动态Batch
- 调用aclmdlSetDynamicHWSize接口设置动态分辨率
- 调用aclmdlSetInputDynamicDims接口设置动态维度的维度值
申请模型推理的输出内存****时，可以按照各档位的实际大小申请内存，也可以调用aclmdlGetOutputSizeByIndex接口获取内存大小后再申请内存（建议使用该方式，确保内存足够）。
动态AIPP和动态Batch同时使用时：
- 调用aclmdlCreateAIPP接口设置batchSize时，batchSize要设置为最大batch size。
- 模型中需要进行动态AIPP处理的data节点，其对应的输入内存大小需按照最大Batch来申请。
动态AIPP和动态分辨率同时使用时：
- 若在设置动态AIPP参数时，开启了抠图或缩放或补边功能，则不能与动态分辨率同时使用。
- 若在设置动态AIPP参数时，未开启抠图或缩放或补边功能，在与动态分辨率同时使用时，需确保通过aclmdlSetAIPPSrcImageSize接口设置的宽、高与通过aclmdlSetDynamicHWSize接口设置的宽、高相等，都必须设置成模型转换时动态分辨率最大档位的宽、高。
- 模型中需要进行动态AIPP处理的data节点，其对应的输入内存大小需按照最大分辨率（宽、高）来申请。
动态AIPP和动态Shape输入（设置Shape范围）同时使用时，动态AIPP的输出图片宽、高要在所设置的Shape范围内。
静态AIPP和动态分辨率同时使用时，由于动态分辨率场景下输入图片的宽和高不确定，因此在使用ATC工具的insert_op_conf参数传入AIPP配置文件时，AIPP配置文件中不能开启Crop和Padding功能，并且需要将配置文件中的src_image_size_w和src_image_size_h取值设置为0。

父主题： 模型动态Shape输入推理

动态Batch/动态分辨率/动态维度（设置多档维度值）

视频课程

通过在线视频课程学习该功能，请参见AscendCL模型推理动态特性。

接口调用流程

动态Shape输入场景下模型推理与基础推理应用的流程类似，都涉及AscendCL初始化与去初始化、运行管理资源申请与释放、模型构建、模型加载、模型执行、模型卸载等。

本节中重点描述动态Shape输入场景下模型推理与基础推理应用的不同之处：

构建模型时，需配置动态Batch、动态分辨率、动态维度（ND格式）相关的信息：

若模型推理时包含动态Batch特性，在模型推理时，需调用AscendCL提供的接口设置模型推理时需使用的batch size，模型支持的batch size已提前在构建模型时配置（使用ATC工具的dynamic_batch_size参数）。

若模型推理时包含动态分辨率特性，在模型推理时，需调用AscendCL提供的接口设置模型推理时需使用的分辨率，模型支持的分辨率已提前在构建模型时配置（使用ATC工具的dynamic_image_size参数）。

若模型推理时包含动态维度（ND格式）特性，在模型推理时，需调用AscendCL提供的接口设置模型推理时需使用的维度值，模型支持哪些维度值已提前在构建模型时配置（使用ATC工具的dynamic_dims参数）。

构建模型成功后，在生成的om模型中，会新增相应的输入（下文简称动态Batch/动态分辨率/动态维度输入），在模型推理时通过该新增的输入提供具体的Batch值/分辨率/维度值。

例如，a输入的batch size是动态的，在om模型中，会新增与a对应的b输入来描述a的batch信息。在模型执行时，准备a输入的数据结构请参见准备模型执行的输入/输出数据结构，准备b输入的数据结构、设置b输入的数据请参见2。

ATC工具的参数说明请参见《ATC工具使用指南》。
在执行模型推理前：
- 需准备动态Batch/动态分辨率/动态维度输入的数据结构：
  1. 申请动态Batch/动态分辨率/动态维度输入对应的内存前，需要先调用aclmdlGetInputIndexByName接口根据输入名称（固定为ACL_DYNAMIC_TENSOR_NAME）获取模型中标识该输入的index。
    
    :::note 说明 ACL_DYNAMIC_TENSOR_NAME是一个宏，宏的定义如下：
    #define ACL_DYNAMIC_TENSOR_NAME "ascend_mbatch_shape_data"
    :::
  2. 调用aclmdlGetInputSizeByIndex根据index获取输入内存大小。
  3. 调用aclrtMalloc接口根据2.b中的大小申请内存。
    
    申请动态Batch/动态分辨率/动态AIPP/动态维度输入对应的内存后，无需用户设置该内存中的数据（否则可能会导致业务异常），用户调用2.b中的接口后，系统会自动向该内存中填入数据。
  4. 调用aclCreateDataBuffer接口创建aclDataBuffer类型的数据，用于存放动态Batch/动态分辨率/动态维度输入数据的内存地址、内存大小。
  5. 调用aclmdlCreateDataset接口创建aclmdlDataset类型的数据，并调用aclmdlAddDatasetBuffer接口向aclmdlDataset类型的数据中增加aclDataBuffer类型的数据。
- 需设置动态Batch/动态分辨率/动态维度参数值：
  
  图1 接口调用流程
  1. 调用aclmdlGetInputIndexByName接口根据输入名称（固定为ACL_DYNAMIC_TENSOR_NAME）获取模型中标识该输入的index。
  2. 设置动态Batch/动态分辨率/动态维度参数值。
    - 调用aclmdlSetDynamicBatchSize接口设置动态Batch。
      
      此处设置的batch size只能是构建模型时设置的Batch档位中的某一个。
      
      也可以调用aclmdlGetDynamicBatch接口获取指定模型支持的Batch档位数以及每一档中的batch size。
    - 调用aclmdlSetDynamicHWSize接口设置动态分辨率。
      
      此处设置的分辨率只能是构建模型时设置的分辨率档位中的某一个。
      
      也可以调用aclmdlGetDynamicHW接口获取指定模型支持的分辨率档位数以及每一档中的宽、高。
    - 调用aclmdlSetInputDynamicDims接口设置动态维度的维度值。
      
      此处设置的动态维度的值只能是构建模型时设置的档位中的某一档。
      
      也可以调用aclmdlGetInputDynamicDims接口获取指定模型支持的动态维度档位数以及每一档中的值。

动态Batch示例代码

 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31  // 1.模型加载，加载成功后，再设置动态Batch // ...... // 2.准备模型描述信息modelDesc_，准备模型的输入数据input_和模型的输出数据output_ // ...... // 3.自定义函数，设置动态Batch int ModelSetDynamicInfo() { size_t index; // 3.1 获取动态Batch输入的index，标识动态Batch输入的输入名称固定为ACL_DYNAMIC_TENSOR_NAME aclError ret = aclmdlGetInputIndexByName(modelDesc_, ACL_DYNAMIC_TENSOR_NAME, &index); // 3.2 设置Batch // modelId_表示加载成功的模型的ID，input_表示aclmdlDataset类型的数据，index表示标识动态Batch输入的输入index，batchSize表示Batch数（此处以8为例） uint64_t batchSize = 8; ret = aclmdlSetDynamicBatchSize(modelId_, input_, index, batchSize); // ...... } // 4.自定义函数，执行模型 int ModelExecute(int index) { aclError ret; // 4.1 调用自定义函数，设置动态Batch ret = ModelSetDynamicInfo(); // 4.2 执行模型，modelId_表示加载成功的模型的ID，input_和output_分别表示模型的输入和输出 ret = aclmdlExecute(modelId_, input_, output_); // ...... } // 5.处理模型推理结果 // TODO

动态分辨率示例代码

 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32  // 1.模型加载，加载成功后，再设置动态分辨率 // ...... // 2.准备模型描述信息modelDesc_，准备模型的输入数据input_和模型的输出数据output_ // ...... // 3.自定义函数，设置动态分辨率 int ModelSetDynamicInfo() { size_t index; // 3.1 获取动态分辨率输入的index，标识动态分辨率输入的输入名称固定为ACL_DYNAMIC_TENSOR_NAME aclError ret = aclmdlGetInputIndexByName(modelDesc_, ACL_DYNAMIC_TENSOR_NAME, &index); // 3.2 设置输入图片分辨率，modelId_表示加载成功的模型的ID，input_表示aclmdlDataset类型的数据，index表示标识动态分辨率输入的输入index uint64_t height = 224; uint64_t width = 224; ret = aclmdlSetDynamicHWSize(modelId_, input_, index, height, width); // ...... } // 4.自定义函数，执行模型 int ModelExecute(int index) { aclError ret; // 4.1 调用自定义函数，设置动态分辨率 ret = ModelSetDynamicInfo(); // 4.2 执行模型，modelId_表示加载成功的模型的ID，input_和output_分别表示模型的输入和输出 ret = aclmdlExecute(modelId_, input_, output_); // ...... } // 5.处理模型推理结果 // TODO

ND格式，动态维度示例代码

 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35  // 1.模型加载，加载成功后，再设置动态维度 // ...... // 2.准备模型描述信息modelDesc_，准备模型的输入数据input_和模型的输出数据output_ // ...... // 3.自定义函数，设置动态维度 int ModelSetDynamicInfo() { size_t index; // 3.1 获取动态维度输入的index，标识动态维度输入的输入名称固定为ACL_DYNAMIC_TENSOR_NAME aclError ret = aclmdlGetInputIndexByName(modelDesc_, ACL_DYNAMIC_TENSOR_NAME, &index); // 3.2 设置具体档位信息，包括维度数dimCount和各个维度的数值，modelId_表示加载成功的模型的ID，input_表示aclmdlDataset类型的数据，index表示标识动态维度输入的输入index aclmdlIODims currentDims; currentDims.dimCount = 4; currentDims.dims[0] = 8; currentDims.dims[1] = 3; currentDims.dims[2] = 224; currentDims.dims[3] = 224; ret = aclmdlSetInputDynamicDims(modelId_, input_, index, &currentDims); // ...... } // 4.自定义函数，执行模型 int ModelExecute(int index) { aclError ret; // 4.1 调用自定义函数，设置动态维度 ret = ModelSetDynamicInfo(); // 4.2 执行模型，modelId_表示加载成功的模型的ID，input_和output_分别表示模型的输入和输出 ret = aclmdlExecute(modelId_, input_, output_); // ...... } // 5.处理模型推理结果 // TODO

父主题： 模型动态Shape输入推理

在线提单

多Device切换​

多模型串联推理​

多Batch模型推理​

队列方式模型推理​

基本原理​

示例代码​

异步模型推理​

接口调用流程​

示例代码​

使用约束​

动态Batch/动态分辨率/动态维度（设置多档维度值）​

视频课程​

接口调用流程​

动态Batch示例代码​

动态分辨率示例代码​

ND格式，动态维度示例代码​

多Device切换

多模型串联推理

多Batch模型推理

队列方式模型推理

基本原理

示例代码

异步模型推理

接口调用流程

示例代码

使用约束

动态Batch/动态分辨率/动态维度（设置多档维度值）

视频课程

接口调用流程

动态Batch示例代码

动态分辨率示例代码

ND格式，动态维度示例代码