OpenVino入门（二）

最新推荐文章于 2025-02-25 11:53:16 发布
最新推荐文章于 2025-02-25 11:53:16 发布
阅读量2.1k 收藏 9
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cream_Cicilian/article/details/112169332
版权

OpenVino入门（二）

一.OpenVino简介

参考他人博客：[1][2][3]

1.1OpenVino是什么

当模型训练结束后，上线部署时，就会遇到各种问题，比如，模型性能是否满足线上要求，模型如何嵌入到原有工程系统，推理线程的并发路数是否满足，这些问题决定着投入产出比。只有深入且准确的理解深度学习框架，才能更好的完成这些任务，满足上线要求。实际情况是，新的算法模型和所用框架在不停的变化，这个时候恨不得工程师什么框架都熟练掌握，令人失望的是，这种人才目前是稀缺的。

OpenVINO是一个Pipeline工具集，同时可以兼容各种开源框架训练好的模型，拥有算法模型上线部署的各种能力，只要掌握了该工具，可以轻松的将预训练模型在Intel的CPU上快速部署起来。

1.2 OpenVino的网络加速原理

为什么需要网络加速/压缩？

大家熟知的resnet，densenet均属于巨无霸类型的网络，在延迟，大小均对用户不友好。试想：你下载了一个手势识别的app，里面还带上了100m大小的resnet，这不是很好的体验。

为了部署深度学习模型，我们可能会在CPU/GPU设备上部署模型。所幸，英伟达与英特尔都提供了官方的网络加速工具。核弹厂对应Tensor RT（GPU），牙膏厂对应openvino（CPU）。

1.2.1Linear Operations Fusing

在这里插入图片描述

1.2.2 数据精度校准（Precision Calibration）

我们训练的网络通常是FP32精度的网络，一旦网络训练完成，在部署推理的过程中由于不需要反向传播，完全可以适当降低数据精度，比如降为FP16或INT8的精度。更低的数据精度将会使得内存占用和延迟更低，模型体积更小。

而什么是Calibration？对于模型中的若干网络层，我们可以逐个的降低其精度，同时准备一个验证集，再划定一条baseline，但网络的性能降低到baseline时，我们停止降低精度。当然也可以将所有网络层的精度降低，但与此同时模型的性能也会降低。

1.2.3 补充

openvino的网络加速，除了减小模型，还有对硬件指令的优化使得硬件效率更高

1.3 开发流程

OpenVINO工具包(ToolKit)主要包括两个核心组件:

  1. 模型优化器(Model Optimizer)
  2. 推理引擎(Inference Engine)

在这里插入图片描述

1.3.1 模型优化器(Model Optimizer)

模型优化器(Model Optimizer)将给定的模型转化为标准的 Intermediate Representation (IR) ，并对模型优化。
模型优化器支持的深度学习框架：

  • ONNX
  • TensorFlow
  • Caffe
  • MXNet
  • Kaldi

1.3.2 推断引擎(Inference Engine)

推断引擎(Inference Engine)支持硬件指令集层面的深度学习模型加速运行，同时对传统的OpenCV图像处理库也进行了指令集优化，有显著的性能与速度提升。
支持的硬件设备：

  • CPU
  • GPU
  • FPGA
  • VPU

1.3.2 推断引擎开发代码流程

在这里插入图片描述

  1. 新建InferenceEngine::Core core（处理器的插件库）InferenceEngine的作用
  2. 读取模型（网络结构和权重），由xxx.bin与xxx.xml组成
  3. 配置输入和输出参数（似乎这里可以不做，一切继承模型的配置）
  4. 装载模型，将模型依靠InferenceEngine::Core::LoadNetwork()载入到硬件上
  5. 建立推理请求CreateInferRequest()
  6. 准备输入数据
  7. 推理
  8. 结果处理

二.以Super Resolution C++ Demo展示推断引擎

demo：[官方文档]
demo的使用方法可以详见上篇博客的2.4

2.1Super Resolution C++源代码

// Copyright (C) 2018-2019 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//

/**
 * @brief The entry point for inference engine Super Resolution demo application
 * @file super_resolution_demo/main.cpp
 * @example super_resolution_demo/main.cpp
 */
#include <algorithm>
#include <vector>
#include <string>
#include <memory>

#include <inference_engine.hpp>

#include <samples/slog.hpp>
#include <samples/args_helper.hpp>
#include <samples/ocv_common.hpp>

#include "super_resolution_demo.h"

using namespace InferenceEngine;

bool ParseAndCheckCommandLine(int argc, char *argv[]) {
    // ---------------------------Parsing and validation of input args--------------------------------------
    slog::info << "Parsing input parameters" << slog::endl;

    gflags::ParseCommandLineNonHelpFlags(&argc, &argv, true);
    if (FLAGS_h) {
        showUsage();
        showAvailableDevices();
        return false;
    }

    if (FLAGS_i.empty()) {
        throw std::logic_error("Parameter -i is not set");
    }

    if (FLAGS_m.empty()) {
        throw std::logic_error("Parameter -m is not set");
    }

    return true;
}

int main(int argc, char *argv[]) {
    try {
        slog::info << "InferenceEngine: " << printable(*GetInferenceEngineVersion()) << slog::endl;
        // ------------------------------ Parsing and validation of input args ---------------------------------
        if (!ParseAndCheckCommandLine(argc, argv)) {
            return 0;
        }

        /** This vector stores paths to the processed images **/
        std::vector<std::string> imageNames;
        parseInputFilesArguments(imageNames);
        if (imageNames.empty()) throw std::logic_error("No suitable images were found");
        // -----------------------------------------------------------------------------------------------------

        // --------------------------- 1. Load inference engine -------------------------------------
        slog::info << "Loading Inference Engine" << slog::endl;
        Core ie;

        /** Printing device version **/
        slog::info << "Device info: " << slog::endl;
        slog::info << printable(ie.GetVersions(FLAGS_d)) << slog::endl;

        if (!FLAGS_l.empty()) {
            // CPU(MKLDNN) extensions are loaded as a shared library and passed as a pointer to base extension
            IExtensionPtr extension_ptr = make_so_pointer<IExtension>(FLAGS_l);
            ie.AddExtension(extension_ptr, "CPU");
            slog::info << "CPU Extension loaded: " << FLAGS_l << slog::endl;
        }
        if (!FLAGS_c.empty()) {
            // clDNN Extensions are loaded from an .xml description and OpenCL kernel files
            ie.SetConfig({{PluginConfigParams::KEY_CONFIG_FILE, FLAGS_c}}, "GPU");
            slog::info << "GPU Extension loaded: " << FLAGS_c << slog::endl;
        }
        // -----------------------------------------------------------------------------------------------------

        // --------------------------- 2. Read IR Generated by ModelOptimizer (.xml and .bin files) ------------
        slog::info << "Loading network files" << slog::endl;

        /** Read network model **/
        auto network = ie.ReadNetwork(FLAGS_m);
        // -----------------------------------------------------------------------------------------------------

        // --------------------------- 3. Configure input & output ---------------------------------------------

        // --------------------------- Prepare input blobs -----------------------------------------------------
        slog::info << "Preparing input blobs" << slog::endl;

        /** Taking information about all topology inputs **/
        ICNNNetwork::InputShapes inputShapes(network.getInputShapes());

        if (inputShapes.size() != 1 && inputShapes.size() != 2)
            throw std::logic_error("The demo supports topologies with 1 or 2 inputs only");
        std::string lrInputBlobName = inputShapes.begin()->first;
        SizeVector lrShape = inputShapes[lrInputBlobName];
        if (lrShape.size() != 4) {
            throw std::logic_error("Number of dimensions for an input must be 4");
        }
        // A model like single-image-super-resolution-???? may take bicubic interpolation of the input image as the
        // second input
        std::string bicInputBlobName;
        if (inputShapes.size() == 2) {
            bicInputBlobName = (++inputShapes.begin())->first;
            SizeVector bicShape = inputShapes[bicInputBlobName];
            if (bicShape.size() != 4) {
                throw std::logic_error("Number of dimensions for both inputs must be 4");
            }
            if (lrShape[2] >= bicShape[2] && lrShape[3] >= bicShape[3]) {
                lrInputBlobName.swap(bicInputBlobName);
                lrShape.swap(bicShape);
            } else if (!(lrShape[2] <= bicShape[2] && lrShape[3] <= bicShape[3])) {
                throw std::logic_error("Each spatial dimension of one input must surpass or be equal to a spatial"
                    "dimension of another input");
            }
        }

        /** Collect images**/
        std::vector<cv::Mat> inputImages;
        for (const auto &i : imageNames) {
            /** Get size of low resolution input **/
            int w = lrShape[3];
            int h = lrShape[2];
            int c = lrShape[1];

            cv::Mat img = cv::imread(i, c == 1 ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
            if (img.empty()) {
                slog::warn << "Image " + i + " cannot be read!" << slog::endl;
                continue;
            }
            if (c != img.channels()) {
                slog::warn << "Number of channels of the image " << i << " is not equal to " << c << ". Skip it\n";
                continue;
            }
            if (w != img.cols || h != img.rows) {
                slog::warn << "Size of the image " << i << " is not equal to " << w << "x" << h << ". Resize it\n";
                cv::resize(img, img, {w, h});
            }

            inputImages.push_back(img);
        }

        if (inputImages.empty()) throw std::logic_error("Valid input images were not found!");

        /** Setting batch size using image count **/
        inputShapes[lrInputBlobName][0] = inputImages.size();
        if (!bicInputBlobName.empty()) {
            inputShapes[bicInputBlobName][0] = inputImages.size();
        }
        network.reshape(inputShapes);
        slog::info << "Batch size is " << std::to_string(network.getBatchSize()) << slog::endl;

        // ------------------------------ Prepare output blobs -------------------------------------------------
        slog::info << "Preparing output blobs" << slog::endl;

        OutputsDataMap outputInfo(network.getOutputsInfo());
        // BlobMap outputBlobs;
        std::string firstOutputName;
        for (auto &item : outputInfo) {
            if (firstOutputName.empty()) {
                firstOutputName = item.first;
            }
            DataPtr outputData = item.second;
            if (!outputData) {
                throw std::logic_error("output data pointer is not valid");
            }

            item.second->setPrecision(Precision::FP32);
        }
        // -----------------------------------------------------------------------------------------------------

        // --------------------------- 4. Loading model to the device ------------------------------------------
        slog::info << "Loading model to the device" << slog::endl;
        ExecutableNetwork executableNetwork = ie.LoadNetwork(network, FLAGS_d);
        // -----------------------------------------------------------------------------------------------------

        // --------------------------- 5. Create infer request -------------------------------------------------
        slog::info << "Create infer request" << slog::endl;
        InferRequest inferRequest = executableNetwork.CreateInferRequest();
        // -----------------------------------------------------------------------------------------------------

        // --------------------------- 6. Prepare input --------------------------------------------------------
        Blob::Ptr lrInputBlob = inferRequest.GetBlob(lrInputBlobName);
        for (size_t i = 0; i < inputImages.size(); ++i) {
            cv::Mat img = inputImages[i];
            matU8ToBlob<float_t>(img, lrInputBlob, i);

            if (!bicInputBlobName.empty()) {
                Blob::Ptr bicInputBlob = inferRequest.GetBlob(bicInputBlobName);

                int w = bicInputBlob->getTensorDesc().getDims()[3];
                int h = bicInputBlob->getTensorDesc().getDims()[2];

                cv::Mat resized;
                cv::resize(img, resized, cv::Size(w, h), 0, 0, cv::INTER_CUBIC);

                matU8ToBlob<float_t>(resized, bicInputBlob, i);
            }
        }
        // -----------------------------------------------------------------------------------------------------

        // --------------------------- 7. Do inference ---------------------------------------------------------
        std::cout << "To close the application, press 'CTRL+C' here";
        if (FLAGS_show) {
            std::cout << " or switch to the output window and press any key";
        }
        std::cout << std::endl;

        slog::info << "Start inference" << slog::endl;
        inferRequest.Infer();
        // -----------------------------------------------------------------------------------------------------

        // --------------------------- 8. Process output -------------------------------------------------------
        const Blob::Ptr outputBlob = inferRequest.GetBlob(firstOutputName);
        LockedMemory<const void> outputBlobMapped = as<MemoryBlob>(outputBlob)->rmap();
        const auto outputData = outputBlobMapped.as<float*>();

        size_t numOfImages = outputBlob->getTensorDesc().getDims()[0];
        size_t numOfChannels = outputBlob->getTensorDesc().getDims()[1];
        size_t h = outputBlob->getTensorDesc().getDims()[2];
        size_t w = outputBlob->getTensorDesc().getDims()[3];
        size_t nunOfPixels = w * h;

        slog::info << "Output size [N,C,H,W]: " << numOfImages << ", " << numOfChannels << ", " << h << ", " << w << slog::endl;

        for (size_t i = 0; i < numOfImages; ++i) {
            std::vector<cv::Mat> imgPlanes;
            if (numOfChannels == 3) {
                imgPlanes = std::vector<cv::Mat>{
                      cv::Mat(h, w, CV_32FC1, &(outputData[i * nunOfPixels * numOfChannels])),
                      cv::Mat(h, w, CV_32FC1, &(outputData[i * nunOfPixels * numOfChannels + nunOfPixels])),
                      cv::Mat(h, w, CV_32FC1, &(outputData[i * nunOfPixels * numOfChannels + nunOfPixels * 2]))};
            } else {
                imgPlanes = std::vector<cv::Mat>{cv::Mat(h, w, CV_32FC1, &(outputData[i * nunOfPixels * numOfChannels]))};

                // Post-processing for text-image-super-resolution models
                cv::threshold(imgPlanes[0], imgPlanes[0], 0.5f, 1.0f, cv::THRESH_BINARY);
            };

            for (auto & img : imgPlanes)
                img.convertTo(img, CV_8UC1, 255);

            cv::Mat resultImg;
            cv::merge(imgPlanes, resultImg);

            if (FLAGS_show) {
                cv::imshow("result", resultImg);
                cv::waitKey();
            }

            std::string outImgName = std::string("sr_" + std::to_string(i + 1) + ".png");
            cv::imwrite(outImgName, resultImg);
        }
        // -----------------------------------------------------------------------------------------------------
    }
    catch (const std::exception &error) {
        slog::err << error.what() << slog::endl;
        return 1;
    }
    catch (...) {
        slog::err << "Unknown/internal exception happened" << slog::endl;
        return 1;
    }

    slog::info << "Execution successful" << slog::endl;
    slog::info << slog::endl << "This demo is an API example, for any performance measurements "
                                "please use the dedicated benchmark_app tool from the openVINO toolkit" << slog::endl;
    return 0;
}

2.2不同预训练模型的效果

官方提供了三种预训练：

  • single-image-super-resolution-1032, which is the model that
    performs super resolution 4x upscale on a 270x480 image（它是在270x480图像上执行4倍超高分辨率的模型）
  • single-image-super-resolution-1033, which is the model that
    performs super resolution 3x upscale on a 360x640 image（该模型可在360x640图像上执行3倍超高分辨率的超高分辨率）
  • text-image-super-resolution-0001, which is the model that performs super resolution 3x upscale on a 360x640 image（该模型可在360x640图像上执行3倍超高分辨率的超高分辨率）

    2.2.1 1-o.jpg

原图
1.single-image-super-resolution-1032, which is the model that
performs super resolution 4x upscale on a 270x480 image
在这里插入图片描述

整体对比：在这里插入图片描述
细节对比：在这里插入图片描述
2.single-image-super-resolution-1033, which is the model that
performs super resolution 3x upscale on a 360x640 image
在这里插入图片描述
整体对比：在这里插入图片描述
细节对比：
在这里插入图片描述
3.text-image-super-resolution-0001, which is the model that performs super resolution 3x upscale on a 360x640 image
在这里插入图片描述
三个模型对比：
在这里插入图片描述

2.2.2 2-0.bmp

在这里插入图片描述
1.single-image-super-resolution-1032, which is the model that
performs super resolution 4x upscale on a 270x480 image
在这里插入图片描述
整体对比：
在这里插入图片描述
细节对比：
在这里插入图片描述
2.single-image-super-resolution-1033, which is the model that
performs super resolution 3x upscale on a 360x640 image
在这里插入图片描述
整体对比：
在这里插入图片描述
细节对比：
在这里插入图片描述
1033和1032对比：
在这里插入图片描述
3.text-image-super-resolution-0001, which is the model that performs super resolution 3x upscale on a 360x640 image
在这里插入图片描述

2.2.3 1-bmp.bmp

在这里插入图片描述
1033：
在这里插入图片描述
png和bmp对比：
在这里插入图片描述

2.2.4 3.bmp

在这里插入图片描述
1033：
在这里插入图片描述
细节对比：
在这里插入图片描述

三.以Object Detection C++ Demo演示模型优化器(Model Optimizer)

demo：[官方文档]

在这里插入图片描述

3.1模型转换流程

在这里插入图片描述
yolo具体操作就看参考博客或者官方文档吧
参考博客：[1][2][yolov4]
openvino官方文档：[官方教你yolov1-v3转模型]
在这里插入图片描述

3.2不同模型配合openvino效果

3.2.1 yolov3

在这里插入图片描述

3.2.2 yolov4

在这里插入图片描述

3.2.3 SSD预训练模型

找了很多ssd转换模型的方法，没找到，结果openvino提供的预训练模型就是ssd
参考博客：[1]
官方预训练模型：person-detection-retail-0013
在这里插入图片描述

3.2.4 yolov5 openvino暂时无法直接支持

原因详见他人博客

四.Openvino程序移植

和普通c++程序可以将exe和所需dll打包，直接放入他人电脑中直接运行不同的是。openvino需要一定的环境，但不需要所有的环境。
详情可见：他人博客
一般是缺什么dll，去找到复制粘贴就好啦
如果出现：plugins.xml:1:0: File was not found
在这里插入图片描述
把这里的所有东西带上
在这里插入图片描述
一个超分辨率的程序携带的所有东西
这个文件夹，去哪个电脑都能跑
文件夹链接: 提取码: qwww

YOLOv10 OpenVINO C++ 推理源码
11-15
使用 OpenVINO 实现 YOLOv10 对象检测，以便在 C++ 中进行高效、准确的实时推理。 支持ONNX和OpenVINO IR模型格式 支持FP32和精度FP16​INT8 支持加载动态形状的模型 已在 Ubuntu 18.04、、上测试20.04。22.04 依赖...
openvino Demo
02-18
openvino demo资源。
速度起飞！AI大模型用OpenVINO优化响应速度的小妙招
英特尔开发人员专区
01-26 4575
本文介绍了在使用OpenVINO™工具套件部署AI推理时，如何利用OpenVINO™提供的多种方式去优化程序启动初次推理的响应时间，包括了使用AUTO Plugin，使用模型缓存或者说使用mmap方式读取模型。
YOLO入门教程（二）——OpenVINO™部署YOLO目标检测模型与异步推理实现150FPS+实时检测【含教程源码 + 环境配置】
吾门的博客
08-21 1963
本文教程主要介绍如何将YOLO目标检测模型的pt格式转换为onnx格式，并在Window环境下用C#调用模型并推理
【开源大模型本地化部署开发】OpenVINO加速大模型推理
最新发布
人工智能(AI)技术，大模型技术，深度学习，机器学习，计算机视觉，AI工具实践应用等分享
02-25 758
OpenVINO（Open Visual Inference and Neural Network Optimization） 是英特尔推出的一款深度学习推理优化工具，旨在为各种硬件平台（如 CPU、GPU、VPU、FPGA 等）提供高效的神经网络推理支持。它支持多个深度学习框架（如 TensorFlow、PyTorch、Caffe 等）并提供一整套用于加速推理过程的工具。 OpenVINO 通过模型优化、硬件加速和推理引擎的组合，提高了机器学习和计算机视觉任务的执行效率，特别是在资源受限的设备上。
OpenVino入门
Cream_Cicilian的博客
12-17 2582
OpenVino入门一.下载安装1.1下载1.2 安装1.2.1解压安装程序1.2.2 按部就班安装1.2.3 安装依赖项1.2.4 设置环境变量1.3 验证安装二.OpenVINO Demos的运行2.1 编译 build_demos_msvc.bat 文件2.2 执行 exe 文件前必要准备2.2.1 添加环境变量 他人博客参考： 1.https://yuki-ho.blog.csdn.net/article/details/104176481 2.https://blog.csdn.net/u011
openvino的入门--c++部署的图像分类为例
qq_42178122的博客
06-09 3973
OpenVINO是英特尔基于自身现有的硬件平台开发的一种可以加快高性能计算机视觉和深度学习视觉应用开发速度工具套件，本文以图像分类的案例手把手叫你如何使用OPENVINO
openvino初级课程
qq_52521944的博客
07-12 679
openvino初级课的内容简单介绍
OpenVINO基础知识
我爱加菲猫
07-03 3740
一 关于OpenCV 截至2020-04-06，OpenCV的最新版本是4.3.0。OpenCV 自3.3开始加入对深度学习推理的支持，即OpenCV DNN模块。至今为止已经支持大多数主流深度学习框架，如TensorFlow、Caffe、Torch、DarkNet、ONNX 和 OpenVINO 格式的网络模型。 二 关于OpenVINO OpenVINO是英特尔推出的视觉推理加速工具包。应用在Intel的CPU及其GPU上。OpenCV 3.4.1版本加入了英特尔推理引擎后端（英特尔推理引擎是OpenV
OpenVINO入门笔记
Tosonw的博客
06-17 5167
一、简介 官方原文：https://software.intel.com/zh-cn/openvino-toolkit/ 使用英特尔®分布式OpenVINO™工具包开发模拟人类视觉的应用程序和解决方案。该工具包基于卷积神经网络（CNN），可扩展英特尔®硬件（包括加速器）的工作负载，并最大限度地提高性能。 在边缘启用基于CNN的深度学习推理 支持跨计算机视觉加速器的异构执行 - CPU，GPU，英...
openvino_practice:练习git，Travis CI和Intel OpenVINO
05-23
英特尔OpenVINO实践 这是一组交互式模块，可以帮助您学习和练习： git，GitHub :bar_chart: 在检查您的进度 入门 每个任务都是子文件夹中的单独文件夹。 要启动新模块，请始终执行以下操作： 讨价还价到基本分支 ...
YOLOv5 OpenVINO IR模型
05-25
YOLOv5 OpenVINO IR模型是针对计算机视觉任务，特别是目标检测的一种高效解决方案。YOLO，全称为You Only Look Once，是一种实时的目标检测系统，以其速度和精度在业界受到广泛应用。而OpenVINO（Open Visual ...
OpenVINO运行Tensorflow模型
11-20
在VS2017中配置OpenVINO环境，并运行Tensorlfow训练的MobileNet，包括Tensorflow模型转为OpenVINO模型，VS2017运行OpenVINO模型等,配置OpenCV等，详情请阅读我的博客【OpenVINO运行Tensorflow模型】
【OpenVINO初级】面向视觉应用
weixin_74923758的博客
07-22 1320
第一种是空间冗余，天空中相同的矩形位置所有像素都是几乎相同的颜色，所以我们不需要存储这几张图片中该矩形位置的所有像素，只需要存储矩形中所有像素的颜色平均值。在显示的时候，我们把这个颜色应用于整个矩形中的每一个像素。另一种是时间冗余，他们在屏幕中的位置不断变化，但依然是相同的，因此基本上不需要重复存储这些像素。当然一些帧包含独特且关键的新信息，所以我们需要储存这一帧的所有像素，这些帧称为I帧。在I帧之间我们可以只记录两帧之间的差异。差异的称为P帧。它们包含了如何从之前的I 帧生成此帧的方法。
OpenVINO之一：OpenVINO概述
热门推荐
mingo_敏
04-14 4万+
OpenVINO之一：OpenVINO概述
openvino是啥
artistkeepmonkey的博客
03-17 1635
英特尔发布的开源框架，用于深度学习的推理优化与模型部署。 openvino具体使用方法还是看官方文档比较好https://docs.openvino.ai/ 支持多种框架：tensorflow caffe pytorch mxnet keras onnx 特点：对于因特尔的cpu加速效果最好 使用过程参考下图 ...
初识OpenVINO
m0_57055443的博客
01-29 4548
英特尔OpenVINO，全称Open Visual Inference Neural Network Optimization，是一种用于深度神经网络中实现模型优化和推理加速的开源工具套件。
OpenVINO（intel官方）初级考试考试题库
赚钱养家
11-12 2988
Open Visual Inference & Neural Network Optimization，是英特尔®公司于2018年发布开源且免费商用的软件包，主要应用于计算机视觉，实现神经网络模型优化和推理计算(Inference)加速，助力AI开发者快速进行应用程序或解决方案开发，可解决视觉模拟、自动语音识别、自然语言处理、推荐系统等多种任务。 在官网可免费报名初级课程，看完9个视频，并完成选择题即可获得初级证书。官网链接如下： 51OpenLab-一站式ICT创新服务平台 本贴记录了选择题
OpenVINO介绍
hou610433155的博客
05-26 2250
OpenVINO是英特尔推出的一款全面的工具套件，用于快速部署应用和解决方案，支持计算机视觉的CNN网络结构超过150余种。 OpenVINO是一个Pipeline工具集，同时可以兼容各种开源框架训练好的模型，拥有算法模型上线部署的各种能力，只要掌握了该工具，你可以轻松的将预训练模型在Intel的CPU上快速部署起来。 https://zhuanlan.zhihu.com/p/91882515 官方文档：https://docs.openvinotoolkit.org/latest/inde.
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值