华为CANN训练营笔记——应用开发全流程 [4]（with 代码版）

已于 2022-08-25 19:36:11 修改
阅读量566 收藏
点赞数
分类专栏： Ascend CANN 文章标签： 华为 华为云 计算机视觉 人工智能 深度学习
于 2022-08-25 19:23:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56945333/article/details/126530998
版权
Ascend 同时被 2 个专栏收录
10 篇文章 5 订阅
订阅专栏
CANN
10 篇文章 5 订阅
订阅专栏
6. main.cpp
# include <iostream>
# include "sample_process.h"
# include "utils.h"
using namespace std;
bool g_isDevice = false; // 全局变量赋初值

int main(){
	SampleProcess processSample;
	Result ret = processSample.InitResource(); // 运行资源初始化
	if (ret != SUCCESS){
		ERROR_LOG("sample init resource failed");
		return FAILED;
	}
	
	ret = processSample.Process();
	if (ret != SUCCESS){
		ERROR_LOG("sample process failed");
		return FAILED;
	}
	INFO_LOG("execute sample success");
	return SUCCESS;
}
7. sample_process.cpp
# include <iostream>
# include "sample_process.h"
# include "utils.h"
# include "model_process.h"
# include "acl/acl.h"
using namespace std;
extern bool g_isDevice;

// 构造方法，为三个成员变量赋初值
SampleProcess::SampleProcess() :deviceId_(0), context_(nullptr), stream_(nullptr) 
{
}

// 析构
SampleProcess::~SampleProcess(){
	DestroyResource();
}

// 初始化函数
Result SampleProcess::InitResource(){
	// ACL初始化
	const char *aclConfigPath = "../src/acl.json";
	aclError ret = aclInit(aclConfigPath);
	if (ret != ACL_ERROR_NONE){	// 判断初始化成功
		ERROR_LOG("acl init failed");
	}
	INFO_LOG("acl init success");

	// open device
	ret = aclrtSetDevice(deviceId_);
	if (ret != ACL_ERROR_NONE){
		ERROR_LOG("acl open device %d failed", deviceId_);
		return FAILED;
	}
	INFO_LOG("acl open device %d success", deviceId_);

	// create context
	ret = aclrtCreateContext(&context_, deviceId_);
	if (ret != ACL_ERROR_NONE){
		ERROR_LOG("acl create context failed");
		return FAILED;
	}
	INFO_LOG("acl create contxt success");

	// create stream
	ret = aclrtCreateStream(&stream_);
	if (ret != ACL_ERROR_NONE){
		ERROR_LOG("acl create stream failed");
		return FAILED;
	}
	INFO_LOG("acl create stream success");
	
	// get run mode
	aclrtRunMode runMode;
	ret = aclrtGetRunMode(&runMode);
	if (ret != ACL_ERROR_NONE){
		ERROR_LOG("acl get run mode failed");
		return FAILED;
	}
	g_isDevice = (runMode == ACL_DEVICE);
	INFO_LOG("get run mode success");
	return SUCCESS;
}


Result SampleProcess::Process(){
	// 创建一个modelProcess对象, 这个类构造于model_process.cpp
	ModelProcess processModel;
	const char* omModelPath = "../model/resnet50.om";	// 模型文件路径
	// 手动管理内存, 从文件加载模型
	Result ret = processModel.LoadModelFromFileWithMem(omModelPath);
	if (ret != SUCCESS){
		ERROR_LOG("excute LoadModelFromFileWithMem failed");
		return FAILED;
	}
	// 创建模型描述信息
	ret = processModel.CreateDesc();
    if (ret != SUCCESS) {
        ERROR_LOG("execute CreateModelDesc failed");
        return FAILED;
    }
	// 对于一个模型, 他的输出应该是固定的
	ret = processModel.CreateOutput();
    if (ret != SUCCESS) {
        ERROR_LOG("execute CreateOutput failed");
        return FAILED;
    }
	
	// =================
	// 		图片数据
	// =================
	string testFile[] = {
        "../data/dog1_1024_683.bin",
        "../data/dog2_1024_683.bin"
    };

	for (size_t index = 0; index < sizeof(testFile) / sizeof(testFile[0]); ++index) {
		INFO_LOG("start to process file:%s", testFile[index].c_str());
		
		// 处理模型
		// 不同于resnet50_imageclassification工程; 这里将获取输入放在了循环里
		uint32_t devBufferSize;
		// 申请这个文件在device上的内存 并返回内存地址
		void *picDevBuffer = Utils::GetDeviceBufferOfFile(testFile[index], devBufferSize);
		if (picDevBuffer == nullptr){
			ERROR_LOG("get pic device buffer failed, index is %zu", index);
			return FAILED;
		}

		// 图片数据内存地址放入input
		ret = processModel.CreateInput(picDevBuffer, devBufferSize);
		if (ret != SUCCESS){
			ERROR_LOG("get pic device buffer failed, index is %zu", index);
			aclrtFree(picDevBuffer); // 失败及时销毁
			return FAILED;
		}
		
		// 推理；结果保存在processModel的成员变量中
		ret = processModel.Execute();
		if (ret != SUCCESS){
			ERROR_LOG("execute inference failed");
			aclrtFree(picDevBuffer);
			return FAILED;
		}
	
		processModel.OutputModelResult();
		aclrtFree(picDevBuffer);
		processModel.DestroyInput();
	}
	return SUCCESS;
}

void SampleProcess::DestroyResource()
{	
	// 销毁顺序：stream -> context -> device -> finalize
    aclError ret;
    if (stream_ != nullptr) {
        ret = aclrtDestroyStream(stream_);
        if (ret != ACL_ERROR_NONE) {
            ERROR_LOG("destroy stream failed");
        }
        stream_ = nullptr;
    }
    INFO_LOG("end to destroy stream");

    if (context_ != nullptr) {
        ret = aclrtDestroyContext(context_);
        if (ret != ACL_ERROR_NONE) {
            ERROR_LOG("destroy context failed");
        }
        context_ = nullptr;
    }
    INFO_LOG("end to destroy context");

    ret = aclrtResetDevice(deviceId_);
    if (ret != ACL_ERROR_NONE) {
        ERROR_LOG("reset device failed");
    }
    INFO_LOG("end to reset device %d", deviceId_);

    ret = aclFinalize();
    if (ret != ACL_ERROR_NONE) {
        ERROR_LOG("finalize acl failed");
    }
    INFO_LOG("end to finalize acl");
}
8. model_process.cpp

手动管理内存

# include <iostream>
# include "model_process.h"
# include <map>
# include <sstream>
# include <algorithm>
# include "utils.h"
using namespace std;
extern bool g_isDevice;

// 构造函数 loadFlag_ 1表示模型已加载
ModelProcess::ModelProcess() :modelId_(0), modelMemSize_(0), modelWeightSize_(0), modelMemPtr_(nullptr), modelWeightPtr_(nullptr), loadFlag_(false), modelDesc_(nullptr), input_(nullptr), output_(nullptr)
{
}

ModelProcess :: ~ModelProcess(){
	Unload(); // 卸载模型
	DestroyDesc();
	DestroyInput();
	DestroyOutput();
}

// 从文件加载模型文件至手动管理内存
Result ModelProcess::LoadModelFromFileWithMem(const char* modelPath){
	if (loadFlag_){
		ERROR_LOG("has already loaded a model");
		return FAILED;
	}
	
	// 从文件中加载模型内存大小与权重大小
	aclError ret = aclmdlQuerySize(modelPath, &modelMemSize_, &modelWeightSize_);
	if (ret != ACL_ERROR_NONE){
		ERROR_LOG("query mem of model file %s failed", modelPath);
		return FAILED;
	}
	
	// 根据查询的模型内存大小分配空间
	ret = aclrtMalloc(&modelMemPtr_, modelMemSize_, ACL_MEM_MALLOC_HUGE_FIRST);
	if (ret != ACL_ERROR_NONE){
		ERROR_LOG("malloc buffer for mem failed, required size is %zu", modelMemSize_);
		return FAILED;
	}

	// 根据查询的模型参数内存大小分配空间
	ret = aclrtMalloc(&modelWeightPtr_, modelWeightSize_, ACL_MEM_MALLOC_HUGE_FIRST);
	if (ret != ACL_ERROR_NONE){
		ERROR_LOG("malloc buffer for weight failed, required size is %zu", modelMemSize_);
		return FAILED;
	}
	
	// 调用acl接口，从文件加载模型
	ret = aclmdlLoadFromFileWithMem(modelPath, &modelId_, modelMemPtr_, modelMemSize_, modelWeightPtr_, modelWeightSize_);
	if (ret != ACL_ERROR_NONE){
		ERROR_LOG("load model from file %s failed", modelPath );
		return FAILED;
	}
	
	// 加载模型结束
	loadFlag_ = true;
	INFO_LOG("load model %s success", modelPath);
	return SUCCESS;
}

// 创建模型描述信息
Result ModelProcess::CreateDesc()
{
    modelDesc_ = aclmdlCreateDesc();
    if (modelDesc_ == nullptr) {
        ERROR_LOG("create model description failed");
        return FAILED;
    }

    aclError ret = aclmdlGetDesc(modelDesc_, modelId_);
    if (ret != ACL_SUCCESS) {
        ERROR_LOG("get model description failed, modelId is %u", modelId_);
        return FAILED;
    }

    INFO_LOG("create model description success");
    return SUCCESS;
}

// 有了模型描述, 然后才可以创建输出
Result ModelProcess::CreateOutput()
{
    if (modelDesc_ == nullptr) {
        ERROR_LOG("no model description, create ouput failed");
        return FAILED;
    }

    output_ = aclmdlCreateDataset();
    if (output_ == nullptr) {
        ERROR_LOG("can't create dataset, create output failed");
        return FAILED;
    }

	// 从模型描述中获取输出个数
    size_t outputSize = aclmdlGetNumOutputs(modelDesc_);
    for (size_t i = 0; i < outputSize; ++i) {
    	// 获取第i个输出的大小
        size_t buffer_size = aclmdlGetOutputSizeByIndex(modelDesc_, i);

        void *outputBuffer = nullptr;
        aclError ret = aclrtMalloc(&outputBuffer, buffer_size, ACL_MEM_MALLOC_NORMAL_ONLY);
        if (ret != ACL_ERROR_NONE) {
            ERROR_LOG("can't malloc buffer, size is %zu, create output failed", buffer_size);
            return FAILED;
        }
        
		// 创建databuffer
        aclDataBuffer *outputData = aclCreateDataBuffer(outputBuffer, buffer_size);
        if (outputData == nullptr) {
            ERROR_LOG("can't create data buffer, create output failed");
            (void)aclrtFree(outputBuffer);
            return FAILED;
        }
		
		// 将databuffer放入output dataset
        ret = aclmdlAddDatasetBuffer(output_, outputData);
        if (ret != ACL_ERROR_NONE) {
            ERROR_LOG("can't add data buffer, create output failed");
            // 如果失败，释放内存
            (void)aclrtFree(outputBuffer);            
            (void)aclDestroyDataBuffer(outputData);
            return FAILED;
        }
    }

    INFO_LOG("create model output success");

    return SUCCESS;
}

Result ModelProcess::CreateInput(void *inputDataBuffer, size_t bufferSize)
{
    input_ = aclmdlCreateDataset();
    if (input_ == nullptr) {
        ERROR_LOG("can't create dataset, create input failed");
        return FAILED;
    }
	// 创建databuffer
    aclDataBuffer *inputData = aclCreateDataBuffer(inputDataBuffer, bufferSize);
    if (inputData == nullptr) {
        ERROR_LOG("can't create data buffer, create input failed");
        return FAILED;
    }

    aclError ret = aclmdlAddDatasetBuffer(input_, inputData);
    if (ret != ACL_SUCCESS) {
        ERROR_LOG("add input dataset buffer failed");
        (void)aclDestroyDataBuffer(inputData);
        inputData = nullptr;
        return FAILED;
    }
    INFO_LOG("create model input success");

    return SUCCESS;
}

Result ModelProcess::Execute()
{
	// 推理，结果放入output中
    aclError ret = aclmdlExecute(modelId_, input_, output_);
    if (ret != ACL_ERROR_NONE) {
        ERROR_LOG("execute model failed, modelId is %u", modelId_);
        return FAILED;
    }

    INFO_LOG("model execute success");
    return SUCCESS;
}

void ModelProcess::OutputModelResult()
{
    for (size_t i = 0; i < aclmdlGetDatasetNumBuffers(output_); ++i) {
        // 遍历output dataset里的data buffer
        aclDataBuffer* dataBuffer = aclmdlGetDatasetBuffer(output_, i);
        void* data = aclGetDataBufferAddr(dataBuffer);
        // uint32_t len = aclGetDataBufferSizeV2(dataBuffer);
        uint32_t len = aclGetDataBufferSizeV2(dataBuffer);

        void *outHostData = nullptr;
        aclError ret = ACL_ERROR_NONE;
        float *outData = nullptr;
        if (!g_isDevice) { // 如果正在运行在HOST上，就需要把数据从Device上取回到HOST
            aclError ret = aclrtMallocHost(&outHostData, len);
            if (ret != ACL_ERROR_NONE) {
                ERROR_LOG("aclrtMallocHost failed, ret[%d]", ret);
                return;
            }

            // Device -> HOST
            ret = aclrtMemcpy(outHostData, len, data, len, ACL_MEMCPY_DEVICE_TO_HOST);
            if (ret != ACL_ERROR_NONE) {
                ERROR_LOG("aclrtMemcpy failed, ret[%d]", ret);
                (void)aclrtFreeHost(outHostData);
                return;
            }

            outData = reinterpret_cast<float*>(outHostData);
        } else {
            outData = reinterpret_cast<float*>(data);
        }

		// 打印
        map<float, unsigned int, greater<float> > resultMap;
        for (unsigned int j = 0; j < len / sizeof(float); ++j) {
            resultMap[*outData] = j;
            outData++;
        }

        int cnt = 0;
        for (auto it = resultMap.begin(); it != resultMap.end(); ++it) {
            // print top 5
            if (++cnt > 5) {
                break;
            }

            INFO_LOG("top %d: index[%d] value[%lf]", cnt, it->second, it->first);
        }
        if (!g_isDevice) {
            ret = aclrtFreeHost(outHostData);
            if (ret != ACL_ERROR_NONE) {
                ERROR_LOG("aclrtFreeHost failed, ret[%d]", ret);
                return;
            }
        }
    }

    INFO_LOG("output data success");
    return;
}

void ModelProcess::DestroyInput()
{
    if (input_ == nullptr) {
        return;
    }

    for (size_t i = 0; i < aclmdlGetDatasetNumBuffers(input_); ++i) {
    	// 销毁所有的buffer
        aclDataBuffer *dataBuffer = aclmdlGetDatasetBuffer(input_, i);
        (void)aclDestroyDataBuffer(dataBuffer);
    }
    (void)aclmdlDestroyDataset(input_);
    input_ = nullptr;
    INFO_LOG("destroy model input success");
}

void ModelProcess::Unload()
{
    if (!loadFlag_) {
        WARN_LOG("no model had been loaded, unload failed");
        return;
    }

    aclError ret = aclmdlUnload(modelId_);
    if (ret != ACL_ERROR_NONE) {
        ERROR_LOG("unload model failed, modelId is %u", modelId_);
    }
	
	// 销毁模型描述信息
    if (modelDesc_ != nullptr) {
        (void)aclmdlDestroyDesc(modelDesc_);
        modelDesc_ = nullptr;
    }

    if (modelMemPtr_ != nullptr) {
        (void)aclrtFree(modelMemPtr_);
        modelMemPtr_ = nullptr;
        modelMemSize_ = 0;
    }

    if (modelWeightPtr_ != nullptr) {
        (void)aclrtFree(modelWeightPtr_);
        modelWeightPtr_ = nullptr;
        modelWeightSize_ = 0;
    }

    loadFlag_ = false;
    INFO_LOG("unload model success, modelId is %u", modelId_);
}

void ModelProcess::DestroyDesc()
{
    if (modelDesc_ != nullptr) {
        (void)aclmdlDestroyDesc(modelDesc_);
        modelDesc_ = nullptr;
    }
    INFO_LOG("destroy model description success");
}

void ModelProcess::DestroyOutput()
{
    if (output_ == nullptr) {
        return;
    }

    for (size_t i = 0; i < aclmdlGetDatasetNumBuffers(output_); ++i) {
        aclDataBuffer* dataBuffer = aclmdlGetDatasetBuffer(output_, i);
        void* data = aclGetDataBufferAddr(dataBuffer);
        (void)aclrtFree(data);
        (void)aclDestroyDataBuffer(dataBuffer);
    }

    (void)aclmdlDestroyDataset(output_);
    output_ = nullptr;
    INFO_LOG("destroy model output success");
}
9. utils.cpp
#include "utils.h"
#include <iostream>
#include <fstream>
#include <cstring>
#include "acl/acl.h"
#include <sys/stat.h>

extern bool g_isDevice;

void* Utils::ReadBinFile(std::string fileName, uint32_t &fileSize)
{
    struct stat sBuf;
    int fileStatus = stat(fileName.data(), &sBuf);
    if (fileStatus == -1) {
        ERROR_LOG("failed to get file");
        return nullptr;
    }
    if (S_ISREG(sBuf.st_mode) == 0) {
        ERROR_LOG("%s is not a file, please enter a file", fileName.c_str());
        return nullptr;
    }

    std::ifstream binFile(fileName, std::ifstream::binary);
    if (binFile.is_open() == false) {
        ERROR_LOG("open file %s failed", fileName.c_str());
        return nullptr;
    }

    binFile.seekg(0, binFile.end);
    uint32_t binFileBufferLen = binFile.tellg();
    if (binFileBufferLen == 0) {
        ERROR_LOG("binfile is empty, filename is %s", fileName.c_str());
        binFile.close();
        return nullptr;
    }

    binFile.seekg(0, binFile.beg);

    void* binFileBufferData = nullptr;
    aclError ret = ACL_ERROR_NONE;
    if (!g_isDevice) {
        ret = aclrtMallocHost(&binFileBufferData, binFileBufferLen);
        if (binFileBufferData == nullptr) {
            ERROR_LOG("malloc binFileBufferData failed");
            binFile.close();
            return nullptr;
        }
    } else {
        ret = aclrtMalloc(&binFileBufferData, binFileBufferLen, ACL_MEM_MALLOC_NORMAL_ONLY);
        if (ret != ACL_ERROR_NONE) {
            ERROR_LOG("malloc device buffer failed. size is %u", binFileBufferLen);
            binFile.close();
            return nullptr;
        }
    }
    binFile.read(static_cast<char *>(binFileBufferData), binFileBufferLen);
    binFile.close();
    fileSize = binFileBufferLen;
    return binFileBufferData;
}

void* Utils::GetDeviceBufferOfFile(std::string fileName, uint32_t &fileSize)
{
	// 根据文件名及文件大小 返回模型内存地址
    uint32_t inputHostBuffSize = 0;
    void* inputHostBuff = Utils::ReadBinFile(fileName, inputHostBuffSize);
    if (inputHostBuff == nullptr) {
        return nullptr;
    }
    if (!g_isDevice) {
        void *inBufferDev = nullptr;
        uint32_t inBufferSize = inputHostBuffSize;
        aclError ret = aclrtMalloc(&inBufferDev, inBufferSize, ACL_MEM_MALLOC_NORMAL_ONLY);
        if (ret != ACL_ERROR_NONE) {
            ERROR_LOG("malloc device buffer failed. size is %u", inBufferSize);
            aclrtFreeHost(inputHostBuff);
            return nullptr;
        }

        ret = aclrtMemcpy(inBufferDev, inBufferSize, inputHostBuff, inputHostBuffSize, ACL_MEMCPY_HOST_TO_DEVICE);
        if (ret != ACL_ERROR_NONE) {
            ERROR_LOG("memcpy failed. device buffer size is %u, input host buffer size is %u",
                inBufferSize, inputHostBuffSize);
            aclrtFree(inBufferDev);
            aclrtFreeHost(inputHostBuff);
            return nullptr;
        }
        aclrtFreeHost(inputHostBuff);
        fileSize = inBufferSize;
        return inBufferDev;
    } else {
        fileSize = inputHostBuffSize;
        return inputHostBuff;
    }
}

1.5.5 编译&运行

下载模型文件.prototxt和.caffemodel
设置环境. /usr/local/Ascend/ascend-toolkit/set_env.sh
转换模型atc --model caffe_model/resnet50.prototxt --weight caffe_model/resnet50.caffemodel --framework 0 --output model/resnet50 --soc_version Ascend310 --input_format NCHW --input_fp16_nodes data --output_type FP32 --out_nodes prob:0
转换图片格式python3 ../scripts/transferPic.py

转到根目录下mkdir -p build/intermediates/host
编译cmake ../../../src/ -DCMAKE_CXX_COMPILER=g++ -DCMAKE_SKIP_RPATH=TRUE
make

转到生成的out目录下 ./main

  • result
    在这里插入图片描述
KimJuneJune
关注
专栏目录
《深度学习》：CANN训练营_昇腾AI入门课学习笔记（第二章 TensorFlow模型迁移&训练）
MAVER1CK的博客
10-24 1166
CANN训练营_昇腾AI入门课学习笔记（第二章 TensorFlow模型迁移&训练）
《深度学习》：CANN训练营_昇腾AI入门课学习笔记（第一章 昇腾AI基础知识介绍）
MAVER1CK的博客
10-24 1140
CANN训练营_昇腾AI入门课。
华为CANN训练营笔记——应用开发全流程 [2]（with 代码版）
m0_56945333的博客
08-25 1288
1. 介绍了Acl运行资源管理，包括对Device，Context和Stream的管理，并附带了对应的Demo。 2. 实现HOST侧和Device侧的内存管理与数据传输，附带对应的Demo
华为CANN训练营笔记——算子开发
m0_56945333的博客
09-23 905
第二部分——算子开发的实现
c语言库函数1
jilily的专栏
01-05 786
函数名: signal  功 能: 设置某一信号的对应动作  用 法: int signal(int sig, sigfun fname);  程序例:  /* This example installs a signal handler routine for SIGFPE,    catches an integer overflow condition, makes an adj
基于昇腾计算语言AscendCL开发AI推理应用
m0_71340392的博客
02-10 1812
本文介绍了昇腾计算语言AscendCL的基本概念，并以示例代码的形式介绍了如何基于AscendCL开发AI推理应用，最后配以实际的操作演示说明如何编译运行应用。
【MindStudio训练营第一期】垃圾分类案例代码详解
weixin_42244535的博客
12-30 622
昇腾垃圾分类案例代码分析
华为昇腾CANN模型开发（CANN训练营2022年度第一季-学习笔记）
weixin_44831765的博客
03-29 3862
本帖为“CANN训练营2022年度第一季-新手班模型开发课”的学习笔记，包含学习文档及其中视频、直播的学习笔记和个人补充资料
小北的技术博客：探索华为昇腾CANN训练营与AI技术创新——Ascend C算子开发能力认证考试（中级）
最新发布
Zhiyilang的博客
10-10 1206
近期，小北参与了华为昇腾CANN训练营2024第二季的学习，这次训练营聚焦于Ascend C算子开发能力认证（中级），为我提供了一个深入学习昇腾AI基础软硬件平台的机会。通过系统的课程学习和实践操作，我不仅掌握了算子开发的基本技能，还了解了昇腾原生开发的全流程，这对于小北在大数据和AI领域的进一步研究具有重要意义。
昇腾AI入门：2023 CANN训练营直播笔记（上）
"这篇文章是关于2023年CANN训练营第一季的直播课程笔记，主题是零基础入门昇腾AI技术的上半部分。笔记涵盖了昇腾AI的全栈架构、Atlas系列硬件、NPU（神经处理单元）介绍、CANN（异构计算架构）以及PyTorch在昇腾AI...
【2023 · CANN训练营第一季】YOLOV7体验记录
JeffDing
05-15 360
华为云ai1s内存：8G操作系统：Ubuntu 18.04.4 LTS以YOLOV7网络模型为例，使能Acllite对图片进行预处理，并通过模型转换使能静态AIPP功能，使能AIPP功能后，YUV420SP_U8格式图片转化为RGB，然后减均值和归一化操作，并将该信息固化到转换后的离线模型中，对YOLOV7网络执行推理，对图片进行物体检测和分类，并给出标定框和类别置信度。样例输入：图片。样例输出：图片物体检测，并且在图片上给出物体标注框，类别以及置信度。
学习笔记二 不同的roles，resource 和 access
congbiao0695的博客
05-14 322
ACL学习笔记网站在大多数情况下使用不同的resource： 网站可能有主页，留言板，和管理员面板resource。 也可能有一些files甚至有一台咖啡机这些都可以称为resource。上一章中我们定义了一个静态的r...
应用班第三课
ponieer的博客
03-30 1376
应用班第三课 图片分类 这节课得目标是掌握基本的开发流程，以及相关的应用日志查看。 主要步骤 准备模型、准备数据、编译程序、运行程序 编译 编译的主要步骤有准备环境，ACL初始化、运行管理资源申请、模型加载、模型推理、模型卸载、运行资源管理资源释放、ACL去初始化、编译代码生成可执行文件。 运行ACL时需要先初始化，初始化时需要有配置文件，json格式的。如果不关注配置文件，则该文件可以为空json文件，即只有“{}”。 运行 准备运行环境、执行可执行文件、运行运用。 程序整体框架 首先时头文件，需要有ac
华为Ascend昇腾CANN详细教程（一）
热门推荐
IT菜鸟
07-12 1万+
华为Ascend昇腾CANN详细教程（一）
CANN编码的一些报错汇编
hppyhjh01的专栏
06-27 1351
介绍一下背景，就是CANN体验营里有2个小功能的串接。这样首先在形式上将2个小功能的代码串接起来，编译通过后，运行时报了这个错。 首先查看一下错误码的含义，在 里定义有： 根据错误码100002，所以错误信息为：ACL_ERROR_REPEAT_INITIALIZE，也就是重复初始化的意思。 确实有做重复初始化，因为2个小功能在开头都做过初始化，虽然在结尾也都做了去初始化，但是去初始化后再初始化也是不行的，有点难理解哦，那来查阅一下 aclInit 的文档： 里面约束说明写的很清楚了：而媒体数据处理初始化
【2023 · CANN训练营第一季】1.基础理论知识
weixin_70078089的博客
05-14 147
华为公司面向计算机视觉、自然语言处理、推荐系统、类机器人等领域量身打造了基于“达芬奇 (DaVinci)架构”的异腾(Ascend) A处理器，开启了智能之旅。华为的AI全栈解决方案包括硬件，AI框架，CANN异构计算架构，相关SDK，部署平台生态等，其中，CANN作为软件和硬件之间的桥梁，向上兼容兼容多种AI框架，向下调用并加速硬件，是学习华为的AI全栈解决方案的重中之重。另外CANN本身还要连接上层的应用层和下层的计算硬件，具体功能可以看下方的一图解，在实际操作中，使用和感知较多的应该是其应用层。
黑白图上色推理
Gavin的博客
11-09 1177
环境准备 服务器：Atlas800推理服务器 系统：Ubuntu18.04 开发环境：Ascend_toolkit5.0.2 工具依赖：ffmpeg+opencv都需要源码安装 Atlas工具库：源码编译atlasutil 概述 黑白图像上色模型原理如下图所示，对物件包括背景色（L通道代表的灰度图）使用卷积运算提取特征，然后同样用卷积进行分类，从而尝试给出对灰度图片每个像素点的色彩预期（ab通道）。将ab通道的值Resize到原始图片宽高并与L通道叠加后，转为RGB图片即可得到彩色图像。 其中模型的输入为L
基于昇腾处理器的目标检测应用（ACL）
SimonChen
08-16 3670
实验内容 本实验通过模型转換、数据预处理/络模型加载/推理/结果输出全流程屐示昇腾处理器推理应用开发过程,帮助您快速熟悉ACL这套计算加速库。 实验目标： 了解华为昇腾全栈开发工具 Mindstudio 及其离线模型转换功能 了解如何使用 ACL 开发基于华为昇腾处理器的神经网络推理应用 实验流程总览： 1.准备环境 1.1.预置环境 点击上方“预置实验环境”按钮，【约等待1-3分钟】后预置成功。环境预置会生成名称为“ecs-ai”弹性云服务器ECS，创建配置相关的VPC、弹性公网IP、安全组，并在“
【MindSpore】Ascend（昇腾）310推理 | 实现步骤
bravozyz的博客
09-24 3150
本文介绍在Ascend 310平台对MindSpore框架实现的网络进行推理的流程。以语义分割网络（HRNet）为例，使用的数据集是Cityscapes。采取的数据集格式为二进制文件格式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值