PyTorch + OpenVINO™ 深度学习笔记
Xayah Lv3

一、前言

PyTorch开源深度学习框架,目的是加速从研究原型到产品开发的过程。其SDK主要基于Python。而其模型训练支持CPUGPU、支持分布式训练云部署,针对深度学习特定领域有不同的丰富的扩展库

深度学习项目的开发大致可以分为两个阶段

  • 第一个阶段是训练阶段。这个阶段最重要的事情就是数据采集模型设计训练参数调试找到合适的模型并努力训练到满足或者超过项目实际需要的精度
  • 第二个阶段是部署阶段。这个阶段最重要的事情就是把模型移植部署各种不同的计算设备上,尽可能地实现模型规模的小型化推理预测过程加速

相比于PyTorchTensorFlow等为开发者所熟知的训练框架推理部署的框架却显得有些默默无闻,但是它在深度学习模型落地过程中发挥着不可替代的作用。正是在这样的背景之下,英特尔2018年发布了专门针对CPUiGPU(集成显卡)FPGAARM硬件单元加速模型部署加速推理框架OpenVINO™

OpenVINO™英特尔发布的一套支持快速开发视觉语音识别自然语言处理应用的框架,受益于人工智能技术的快速发展,框架采用了最新的人工智能神经网络包括卷积神经网络循环神经网络注意力机制网络等模型。实现视觉非视觉任务的底层硬件加速、达到最佳性能,支持人工智能应用从云端边缘部署推理全链路技术。

二、PyTorch

1. 安装

建议使用 Conda 安装 PyTorch ,本篇笔记也将以Conda安装方式为例。笔者的环境是Windows11 + Anaconda + CUDA11.6,而LinuxMac平台的环境配置大同小异,这里就不过多赘述。

1) CUDA版本

CUDA11+为例,首先需要安装CUDA驱动
安装完成后,检测安装版本

1
nvidia-smi
  • 安装CUDA版本
    1
    conda install pytorch torchvision torchaudio cudatoolkit=11.3 -c pytorch

2) CPU版本

若没有NVIDIA系显卡或其不支持CUDA加速,则可选择安装仅CPU版本。

  • 安装仅CPU版本
    1
    conda install pytorch torchvision torchaudio cpuonly -c pytorch

2. 检验

终端进入Python3控制台(笔者python命令默认链接Python3

1
python

导入PyTorch

1
import torch

测试torch.rand()函数

1
torch.rand(5, 3)

安装成功,则会出现类似于以下的输出

测试是否支持CUDA

1
2
import torch
torch.cuda.is_available()

3. 概念

很多人学习深度学习框架面临的第一个问题就是其专业术语跟基本的编程概念传统面向对象编程不同,这是初学者面临的第一个学习障碍

主流面向对象编程语言中,结构化代码最常见的关键字ifelsewhilefor关键字,而在深度学习框架编程模式主要是基于计算图张量数据自动微分优化器等组件构成。

面向对象编程运行的结果交互式可视化的,而深度学习通过训练模型生成模型文件,然后再使用模型预测本质数据流图的方式工作。所以学习深度学习框架首先必须理清深度学习编程计算图张量数据自动微分优化器这些基本术语概念,下面分别解释如下:

1) 张量

张量(Tensor)深度学习框架中需要理解最重要的一个概念张量的本质是数据,在深度学习框架中一切的数据都可以看成张量

深度学习中的计算图是以张量数据输入,通过算子运算,实现对整个计算图参数评估优化。但是到底什么是张量?可以看下面这张图:

上图中标量向量数组3D4D5D数据矩阵在深度学习框架中都被称为张量。可见在深度学习框架中所有的数据都是张量形式存在,张量深度学习数据组织与存在一种数据类型

2) 算子/操作数

深度学习主要是针对张量数据操作。这些数据操作简单复杂,多数都是以矩阵计算的形式存在。最常见的矩阵操作就是加减乘除,此外卷积池化激活也是模型构建中非常有用的算子/操作数Pytorch支持自定义算子操作,可以通过自定义算子实现复杂的网络结构,构建一些特殊的网络模型张量算子/操作数一起构成了计算图,它们是也是计算图基本组成要素

3) 计算图

深度学习基于计算图完成模型构建,实现数据在各个计算图节点之间流动,最终输出。因此计算图又被称为数据流图

根据构建计算图的方式不同还可以分为静态图动态图Pytorch默认是基于动态图的方式构建计算图

动态图采用类似Python语法,可以随时运行灵活修改调整

静态图则是效率优先,但是在图构建完成之前无法直接运行

可以看出动态图更加趋向于开发者平时接触的面向对象的编程方式,也更容易被开发者理解与接受。

下图是一个简单的计算图示例:

图中最底层三个节点表示计算图输入张量数据节点(a、b、c),剩下节点表示操作,带箭头的线段表示数据的流向

4) 自动微分

使用Pytorch构建神经网络(计算图)模型之后,一般都是通过反向传播进行训练反向传播算法使用损失函数功能神经网络中每个参数根据梯度进行参数值调整

为了计算这些梯度完成参数调整深度学习框架中都会自带一个叫做自动微分内置模块,来自动计算神经网络模型训练时的各个参数梯度值并完成参数值更新,这种技术就是深度学习框架中的自动微分

4. PyTorch基础操作

1) 张量的定义与声明

张量PyTorch深度学习框架中表示数据,有几种不同的方式来创建声明张量数据

a. 常量声明

1
2
3
4
import torch

a = torch.tensor([[2., 3.], [4., 5.]])
print(a, a.dtype)

输出

1
2
tensor([[2., 3.],
[4., 5.]]) torch.float32

其中torch.tensor()默认的数据类型flaot32,这点从a.dtype打印结果上也得了印证

b. 转换声明

torch.tensor函数支持从NumPy数组直接转换为张量数据

1
2
3
4
5
import numpy as np
import torch

a = torch.tensor(np.array([[1, 2], [3, 4], [5, 6], [7, 8]]))
print(a, a.dtype)

输出

1
2
3
4
tensor([[1, 2],
[3, 4],
[5, 6],
[7, 8]], dtype=torch.int32) torch.int32

函数返回的数据类型将会根据NumPy数组自动识别。

c. 初始化声明

PyTorch框架支持类似MATLAB数组初始化方式,可以定义数组的维度,然后初始化为零

1
2
3
4
import torch

a = torch.zeros([2, 4], dtype=torch.float32)
print(a, a.dtype)

输出

1
2
tensor([[0., 0., 0., 0.],
[0., 0., 0., 0.]]) torch.float32

可使用torch.ones()函数初始化为1

1
2
3
4
import torch

a = torch.ones([2, 4], dtype=torch.float32)
print(a, a.dtype)

输出

1
2
tensor([[1., 1., 1., 1.],
[1., 1., 1., 1.]]) torch.float32

d. 随机初始化声明

实际的开发中,经常需要随机初始化一些张量,可通过torch.rand()等函数实现

1
2
3
4
5
6
7
8
9
10
11
import torch

v1 = torch.rand((2, 3)) # 数组大小: 2x3
print("v1: ", v1)

torch.initial_seed() # 随机初始化种子
v2 = torch.rand((2, 3)) # 数组大小: 2x3
print("v2: ", v2)

v3 = torch.randint(0, 255, (4, 4)) # 随机范围: 0~255, 数组大小: 4x4
print("v3: ", v3)

输出

1
2
3
4
5
6
7
8
v1:  tensor([[0.6751, 0.0717, 0.4391],
[0.8088, 0.1570, 0.1111]])
v2: tensor([[0.4927, 0.1516, 0.3794],
[0.9748, 0.6124, 0.1192]])
v3: tensor([[ 60, 88, 33, 53],
[193, 155, 76, 148],
[ 86, 47, 177, 192],
[ 65, 247, 252, 145]])

2) 张量的操作

a. 计算图操作

以上图为例,用代码将它实现出来:

1
2
3
4
5
6
7
8
import torch

a = torch.tensor([[2., 3.], [4., 5.]])
b = torch.tensor([[10, 20], [30, 40]])
c = torch.tensor([[0.1], [0.2]])
x = a + b
y = torch.matmul(x, c)
print("y: ", y)

输出

1
2
y:  tensor([[ 5.8000],
[12.4000]])

b. 数据类型转换

可用如下代码进行常见的数据类型转换

1
2
3
4
5
6
7
import torch

m = torch.tensor([1., 2., 3., 4., 5., 6], dtype=torch.float32)
print(m, m.dtype) # 原类型为float32
print(m.double(), m.double().dtype) # 转换为float64
print(m.int(), m.int().dtype) # 转换为int32
print(m.long(), m.long().dtype) # 转换为int64

输出

1
2
3
4
tensor([1., 2., 3., 4., 5., 6.]) torch.float32
tensor([1., 2., 3., 4., 5., 6.], dtype=torch.float64) torch.float64
tensor([1, 2, 3, 4, 5, 6], dtype=torch.int32) torch.int32
tensor([1, 2, 3, 4, 5, 6]) torch.int64

c. 维度转换

可用如下代码进行常见的维度转换

1
2
3
4
5
6
7
8
9
10
11
12
import torch

a = torch.arange(12.) # 创建一个(0)~(12-1)区间顺序增长的一维张量
print("a: ", a)
b = torch.reshape(a, (3, 4)) # 转换为3x4
print("b: ", b)
c = torch.reshape(a, (-1, 6)) # 转换为?x6, ?从列数6推理得到
print("c: ", c)
d = torch.reshape(a, (-1,)) # 转换为1行
print("d: ", d)
e = torch.reshape(a, (1, 1, 3, 4)) # 转换为1x1x3x4
print("e: ", e)

输出

1
2
3
4
5
6
7
8
9
10
a:  tensor([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10., 11.])
b: tensor([[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.]])
c: tensor([[ 0., 1., 2., 3., 4., 5.],
[ 6., 7., 8., 9., 10., 11.]])
d: tensor([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11.])
e: tensor([[[[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.]]]])

除此之外,还可以使用基于tensor维度转换函数tensor.view()

1
2
3
4
5
6
7
8
9
10
11
12
import torch

a = torch.arange(12.) # 创建一个(0)~(12-1)区间顺序增长的一维张量
print("a: ", a)
b = a.view(3, 4) # 转换为3x4
print("b: ", b)
c = a.view(-1, 6) # 转换为?x6, ?从列数6推理得到
print("c: ", c)
d = a.view(-1, ) # 转换为1行
print("d: ", d)
e = a.view(1, 1, 3, 4) # 转换为1x1x3x4
print("e: ", e)

输出

1
2
3
4
5
6
7
8
9
10
a:  tensor([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10., 11.])
b: tensor([[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.]])
c: tensor([[ 0., 1., 2., 3., 4., 5.],
[ 6., 7., 8., 9., 10., 11.]])
d: tensor([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11.])
e: tensor([[[[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.]]]])

d. 通道交换

通道交换PyTorch处理张量数据常用操作之一。

1
2
3
4
5
6
7
8
import torch

x = torch.randn(3, 4, 5) # 随机生成3x4x5的张量
print("x: ", x)
print("Size of x: ", x.size())
y = x.transpose(0, 1) # 对x的0维和1维进行交换(类似于转置)
print("y: ", y)
print("Size of y: ", y.size())

输出

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
x:  tensor([[[-0.9932, -2.1915, -0.8266, -1.8298,  0.5624],
[ 0.2394, -0.3014, 0.3355, 0.9116, 1.1046],
[-0.2292, -0.2218, -0.8415, -1.7220, -0.5911],
[-0.0927, -0.2388, 0.3639, -2.3732, -0.7759]],

[[ 0.0079, -0.1990, -0.9282, 1.2543, -0.7065],
[-0.5910, 0.5737, -1.9680, 0.8392, 0.4500],
[ 0.8449, 1.4641, -0.4619, -0.3084, 0.0082],
[ 0.2436, 0.1285, -0.1126, 1.7058, 0.5177]],

[[-1.4615, -1.5110, 0.3243, 0.5885, 0.2760],
[-0.4879, -1.6806, -0.3202, -2.1921, 1.8557],
[-1.3212, -0.0511, -0.8245, 1.1485, -0.6952],
[-0.0165, -0.2692, 0.3099, -0.1915, -0.3242]]])
Size of x: torch.Size([3, 4, 5])
y: tensor([[[-0.9932, -2.1915, -0.8266, -1.8298, 0.5624],
[ 0.0079, -0.1990, -0.9282, 1.2543, -0.7065],
[-1.4615, -1.5110, 0.3243, 0.5885, 0.2760]],

[[ 0.2394, -0.3014, 0.3355, 0.9116, 1.1046],
[-0.5910, 0.5737, -1.9680, 0.8392, 0.4500],
[-0.4879, -1.6806, -0.3202, -2.1921, 1.8557]],

[[-0.2292, -0.2218, -0.8415, -1.7220, -0.5911],
[ 0.8449, 1.4641, -0.4619, -0.3084, 0.0082],
[-1.3212, -0.0511, -0.8245, 1.1485, -0.6952]],

[[-0.0927, -0.2388, 0.3639, -2.3732, -0.7759],
[ 0.2436, 0.1285, -0.1126, 1.7058, 0.5177],
[-0.0165, -0.2692, 0.3099, -0.1915, -0.3242]]])
Size of y: torch.Size([4, 3, 5])

e. 寻找最大值

寻找最大值PyTorch处理张量数据常用操作之一。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import torch

x = torch.tensor([2., 3., 4., 12., 3., 5., 8., 1.])
print("x: ", x)
print("Max of x: ", torch.argmax(x)) # 求x的最大值索引

y = x.view(-1, 2)
print("y: ", y)
print("Max of y: ", torch.argmax(y)) # 求x的最大值索引(展开为1维)
print("Max of y: ", torch.argmax(y, 0)) # 求x的0维最大值索引
print("Max of y: ", torch.argmax(y, 1)) # 求x的1维最大值索引
print("Max of y: ", y.argmax()) # 求x的最大值索引(展开为1维)
print("Max of y: ", y.argmax(0)) # 求x的0维最大值索引
print("Max of y: ", y.argmax(1)) # 求x的1维最大值索引

输出

1
2
3
4
5
6
7
8
9
10
11
12
x:  tensor([ 2.,  3.,  4., 12.,  3.,  5.,  8.,  1.])
Max of x: tensor(3)
y: tensor([[ 2., 3.],
[ 4., 12.],
[ 3., 5.],
[ 8., 1.]])
Max of y: tensor(3)
Max of y: tensor([3, 1])
Max of y: tensor([1, 1, 1, 0])
Max of y: tensor(3)
Max of y: tensor([3, 1])
Max of y: tensor([1, 1, 1, 0])

f. CPU与GPU运算支持

PyTorch支持CPUGPU计算,默认创建的tensorCPU版本的,要想使用GPU版本,首先需要检测GPU支持,然后转换为GPU数据,或者直接创建为GPU版本数据

1
2
3
4
5
6
7
8
9
10
11
12
13
import torch

gpu = torch.cuda.is_available()
for i in range(torch.cuda.device_count()):
print("name: ", torch.cuda.get_device_name(i))
x = torch.randn(2, 3)
if gpu:
print("x: ", x)
print("x.device: ", x.device)
print("x.cuda(): ", x.cuda())
print("x.cuda().device: ", x.cuda().device)
y = torch.tensor([1, 2, 3, 4], device="cuda:0")
print("y: ", y)

输出

1
2
3
4
5
6
7
8
name:  NVIDIA GeForce RTX 2060
x: tensor([[-0.1489, -1.4650, 0.3720],
[ 0.8687, 0.0330, -0.4909]])
x.device: cpu
x.cuda(): tensor([[-0.1489, -1.4650, 0.3720],
[ 0.8687, 0.0330, -0.4909]], device='cuda:0')
x.cuda().device: cuda:0
y: tensor([1, 2, 3, 4], device='cuda:0')

5. 线性回归预测

线性回归的本质就是根据给出二维数据集拟合生成一条直线,如下图:

左图是一组圆点表示的二维坐标点数据集直线是根据线性回归算法生成的。
右图则是根据坐标点数据集生成的一个非线性回归例子。
现在我们已经可以很直观地了解什么是线性回归了,但线性回归是怎么找到这条直线的?
我们可以通过PyTorch构建一个简单的计算图不断学习,最终得到一个足够逼近真实直线参数方程,这个过程被称为线性回归学习/训练过程。

1) 原理

最常见的直线方程如下:

假设有一组二维坐标点数据集

x 1 2 0.5 2.5 2.6 3.1
y 3.7 4.6 1.65 5.68 5.98 6.95

随机赋值初始kb两个参数,根据直线方程,通过x可以得到对应的,它跟 真实值y 之间的差值称为损失,最常见的损失是均值平方损失(MSE),表示如下:

假设当前参数A(k, b)新参数B(k, b),我们可以通过下面的公式更新kb两个参数:

其中η称为学习率grad(η)是对应的参数梯度,可根据深度学习框架自动微分机制得到。这样就实现了线性回归模型构建训练过程,最终可根据输入的迭代次数运行并输出回归直线的两个参数,从而完成线性回归的求解。

2) 实现

PyTorch提供了丰富的函数,可以帮助我们快速搭建线性回归模型并完成训练预测

a. 构建数据集

1
2
3
4
import numpy as np

x = np.array([1, 2, 0.5, 2.5, 2.6, 3.1], dtype=np.float32).reshape((-1, 1))
y = np.array([3.7, 4.6, 1.65, 5.68, 5.98, 6.95], dtype=np.float32).reshape(-1, 1)

b. 构建线性回归模型

1
2
3
4
5
6
7
8
# 继承torch.nn.Module
class LinearRegressionModel(torch.nn.Module):
def __init__(self, input_dim, output_dim):
super(LinearRegressionModel, self).__init__()
self.linear = torch.nn.Linear(input_dim, output_dim) # 对应直线方程y = kx + b

def forward(self, x):
return self.linear(x) # 重载forward(), 根据模型计算并返回预测结果

c. 创建损失功能与优化器

1
2
3
4
5
6
data_input_dim = 1  # 输入维度为1
data_output_dim = 1 # 输出维度为1
model = LinearRegressionModel(data_input_dim, data_output_dim) # 实例化
criterion = torch.nn.MSELoss() # 均值平方损失
learning_rate = 0.01 # 学习率
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate) # 优化器, 求解参数梯度

d. 迭代训练

1
2
3
4
5
6
7
8
9
10
11
# 迭代训练
for index in range(100):
# 将NumPy数组转为torch变量
input_x = torch.from_numpy(data_x).requires_grad_() # 需要为其计算梯度
input_y = torch.from_numpy(data_y)
optimizer.zero_grad() # 梯度置零
output_y = model(input_x) # 得到输出
loss = criterion(output_y, input_y) # 计算损失
loss.backward() # 计算梯度,反向传播
optimizer.step() # 更新参数
print('迭代索引: {}, 损失: {}'.format(index, loss.item()))

e. 绘制结果

1
2
3
4
5
predicted_y = model(torch.from_numpy(data_x).requires_grad_()).data.numpy()  # 得到预测结果
plt.plot(data_x, data_y, 'go', label='True data', alpha=0.5) # 绘制数据集
plt.plot(data_x, predicted_y, '--', label='Predictions', alpha=0.5) # 绘制回归直线
plt.legend()
plt.show()

最终完整代码为:

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
import numpy as np
import torch
from matplotlib import pyplot as plt

data_x = np.array([1, 2, 0.5, 2.5, 2.6, 3.1], dtype=np.float32).reshape((-1, 1))
data_y = np.array([3.7, 4.6, 1.65, 5.68, 5.98, 6.95], dtype=np.float32).reshape(-1, 1)


# 继承torch.nn.Module
class LinearRegressionModel(torch.nn.Module):
def __init__(self, input_dim, output_dim):
super(LinearRegressionModel, self).__init__()
self.linear = torch.nn.Linear(input_dim, output_dim) # 对应直线方程y = kx + b

def forward(self, x):
return self.linear(x) # 重载forward(), 根据模型计算并返回预测结果


data_input_dim = 1 # 输入维度为1
data_output_dim = 1 # 输出维度为1
model = LinearRegressionModel(data_input_dim, data_output_dim) # 实例化
criterion = torch.nn.MSELoss() # 均值平方损失
learning_rate = 0.01 # 学习率
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate) # 优化器, 求解参数梯度

# 迭代训练
for index in range(100):
# 将NumPy数组转为torch变量
input_x = torch.from_numpy(data_x).requires_grad_() # 需要为其计算梯度
input_y = torch.from_numpy(data_y)
optimizer.zero_grad() # 梯度置零
output_y = model(input_x) # 得到输出
loss = criterion(output_y, input_y) # 计算损失
loss.backward() # 计算梯度,反向传播
optimizer.step() # 更新参数
print('迭代索引: {}, 损失: {}'.format(index, loss.item()))

predicted_y = model(torch.from_numpy(data_x).requires_grad_()).data.numpy() # 得到预测结果
plt.plot(data_x, data_y, 'go', label='True data', alpha=0.5) # 绘制数据集
plt.plot(data_x, predicted_y, '--', label='Predictions', alpha=0.5) # 绘制回归直线
plt.legend()
plt.show()

最终得到

三、OpenVINO™

1. 概念

OpenVINO™ ToolKit主要功能包含:

  1. 支持边缘卷积神经网络推理加速
  2. 支持在英特尔CPUHD卡NCS2FPGA等设备上的混合执行/异构计算执行
  3. 通过大量的预训练模型库做到加速产品原型市场化的过程
  4. 支持传统的计算机视觉标准库,包括OpenCVOpenCL

人工智能应用/模型的开发在第二阶段模型部署中,可以借助OpenVINO™ ToolKit压缩量化推理加速能力达到模型推理时的最佳性能(速度与精度)。相比第一阶段第二阶段更为重要,它决定模型最终是否可以实现商业目标,带来商业价值英特尔发布的开源版本OpenVINO™ ToolKit支持从云端边缘模型部署,通过自身人工智能技术优势着力解决人工智能落地环节商业痛点

上图中矩形框内的部分是OpenVINO™的核心功能矩形框外表示第三方提供的模型与上层应用

2. 功能与组件

深度学习模型优化器(Deep Learning Model Optimizer)

跨平台命令行工具包,支持导入来自主流深度学习框架模型模型文件可能由TensorFlowPyTorchCaffeMXNetONNX深度学习框架工具生成。模型优化器支持对导入模型转换优化导出

深度学习推理引擎(Deep Learning Inference Engine)

一个统一的API接口层,支持对深度学习模型高效推理,支持跨操作系统多种底层硬件异构模式推理计算,这些硬件包括Intel CPUIntel集成显卡NCS2计算棒VPUFPGA等。

推理引擎样例(Inference Engine Sample)

一系列的示例代码文件,通过控制台运行演示如何在第三方应用集成推理引擎开发。

深度学习工作台(Deep Learning Workbench)

一个基于WEB端智能化图形交互界面,允许你更加灵活地尝试OpenVINO™提供各种组件功能

后训练优化工具(Post-Training Optimization Tool)

一个验证执行量化INT8精度的工具,此功能包含在模型优化器命令行文件夹下面。

开放的模型库(Open Model Zoo)

OMZ主要有两个部分
第一部分Demos教程,主要包括PythonC++SDK教程,教程主要涉及计算机视觉语音识别相关的内容。
第二部分模型,包含Intel提供其它公开支持OpenVINO™部署推理模型总数超过240+,对于很多常见的视觉任务无需再训练模型直接使用模型通过推理引擎部署即可。
需要注意的是public(非Intel提供)部分的模型,需要开发者自己转换IR格式中间文件,才能通过推理引擎部署调用

OpenCV组件

OpenVINO™ ToolKit在支持深度学习模型部署的同时,还把OpenCV作为支持传统视觉算法处理的组件,集成到了OpenVINO™ ToolKit中,因而可以自动获取OpenCV框架的支持,这对熟悉OpenCV框架的开发者来说是一个大大的福利!并且OpenVINO™提供的官方教程中,图像预处理推理引擎输出的后处理图像与图形绘制等均采用了OpenCV相关函数完成,对大多数OpenCV开发者来说看这些代码毫无违和感

3. 安装

打开Intel® Distribution of OpenVINO™ Toolkit

如上图,由于后续基本上采用Python开发,所以我们选择PIP的方式安装

选择PyTorch框架,得到如下安装代码:

1
pip install openvino-dev[pytorch]==2022.1.0

未完待续…

四、参考

  • 本文标题:PyTorch + OpenVINO™ 深度学习笔记
  • 本文作者:Xayah
  • 创建时间:2022-03-22 15:36:13
  • 本文链接:http://acmezone.top/2022/03/22/PyTorch-OpenVINO™-深度学习笔记/
  • 版权声明:本博客所有文章除特别声明外,均采用 BY-NC-SA 许可协议。转载请注明出处!