OpenVINO基本操作流程

环境配置：

conda env list:可以查看有哪些环境

conda activate intel:启动某个环境

pip list：可以查看此环境下都下载了哪些软件包 

from openvino.inference_engine import IEcore#从OpenVINO推理引擎中导入IECore类
import numpy as np
import cv2


'''
1，初始化推理引擎
'''
ie = IECore()#创建一个IECore对象
for device in ie.available_devices:#遍历所有可用openVINO的计算机设备
    print(device)#打印每一个设备的名称




with open('imagenet_classes.txt') as f:#打开一个包含ImageNet类标签的文件，读取里面的每一行信息
    labels = [line.strip() for line in f.readlines()]#读取文件中的所有行并去除每行的空格
#readlines()可以把文件里的每一行信息保存在列表中，但是也会把换行符保存进去
#line.strip()可以去掉换行符
#最后把每一行信息都保存在labels(每一行是一个元素，100行则在labels列表中有100个元素)



'''
2，加载模型
'''
model_xml = "resnet18.xml"#指定模型的XML文件路径
model_bin = "resnet18.bin"#指定模型的二进制权重文件路径
#xml指明了这个模型中的层和参数，相当于搭了一个框架。而bin就是框架里的信息
#pytorch训练出来的是.pt文件，后续会通过程序先将.pt文件转为onnx，然后再转为.xml,.bin文件

net = ie.read_network(model=model_xml, weights=model_bin)#读取模型


'''
3，配置输入输出
'''
input_blob = next(iter(net.input_info))#获取模型输入层名称并保存在input_blob中
out_blob = next(iter(net.outputs))#获取模型的输出层名称

n,c,h,w = net.input_info[input_blob].input_data.shape#获取输入数据的形状
#n表示一个批次传入图片数量，c代表通道数
#通过print可以看出如果我们想要把图片传入到resnet18这个网络中，1次只能传一张，通道数为3(彩色)
#传入图片高宽需要是h w
print(n, c, h, w)

#为了匹配上述模型输入图片要求，就有了下面的对图片的处理
src = cv2.imread("1.jpg")#读取图片文件
image = cv2.resize(src, (w,h))#调整图片大小以匹配模型的输入大小
image = np.float32(image)/255.0$将图像数据归一化到[0,1]范围
#np.float32(image)将图片每一个像素值转换为浮点型，然后每个都除以255
image[:,:,] -= (np.float32(0.485), np.float32(0.456), np.float(0.406))#从图像中减去均值
image[:,:,] -= (np.float32(0.229), np.float32(0.224), np.float(0.225))#将图像数据除以标准#
#差
#image[:,:,]读取每一个像素值
image = image.transpose(2, 0, 1)#调整图像的维度顺序,将cv2读取的BGR(012)格式转换为RBG(2,0,1)


exec_net = ie.load_network(network = net, device_name = "CPU")#在CPU上加载模型
res = exec_net.infer(inputs={input_blob:[image]})#进行推断



'''
后处理
'''
res = res[out_blob]#获取推断结果
print(res.shape)#打印推断结果的形状.因为分类给的txt中有1000行，即1000个可能。所以输出的res有#1000个概率，我们只需要找到概率最大的那个即可
label_index = np.argmax(res, 1)[0]#获取最可能的类标签的索引
print(label_index, label[label_index])#打印类标签的索引和名称
cv2.putText(src, labels[label_index],(50,50),cv2.FONT_HERSHEY_SIMPLEX,1.0,(0,0,255),2,8)
#在原图上添加类标签文本
cv2.imshow("image classification", src)
cv2.waitKey(0)

图像分类案例

1，模型训练

使用OpenVINO进行实时图像分类，使用Pytorch训练一个自己的图形分类模型，然后将它部署在树莓派上，并用摄像头进行

训练自己的图形分类模型首先创建文件夹，文件夹内有自己的数据集文件夹(可以命名为Data)，Data文件夹中又有text和train文件夹，分别存放要训练的图片。除了数据集文件夹剩下的就是.py代码文件

训练模型.py

import os #os通常用来创建文件夹，遍历目录等更系统有关
import torch
import torch.nn as nn #nn用来修改网络参数
import torch.optim as optim #optim用来网络优化系统的
from torchvision import datasets, models, transforms
#datasets读取自定义数据，models用来导入预训练模型的，transforms用来数据增强等预处理

if __name__ == '__main__': #定义主函数
    #设置设备。判断当前显卡cuda能否使用，不能使用则使用cpu
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    
    #数据增强和归一化操作
    data_transforms = {
        'train':transforms.Compose(
            transforms.RandomResizedCrop(224), #对图片进行随机裁剪大小为224*224的大小
            transforms.RandomHorizontalFlip(), #随机对图片进行一个水平翻转
            transforms.ToTensor(), #把图片转变为tensor格式才能输入到网络中
            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
            #对图片数据进行归一化，前面为均值，后面是标准差
        ]),
        'test':transforms.Compose([
            transforms.Resize(256),
            transforms.CenterCrop(224),
            transforms.ToTensor(),
            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
        ]),
    }


    #加载数据集
    data_dir = r'data'#相对路径的写法，表示数据集在此.py文件同目录下的data文件中
    image_datasets = {x:datasets.ImageFolder(os.path.join(data_dir, x),
                                            data_transforms[x])
                            for x in ['train', 'test']}
    #os.path.join(data_dir,x)表示路径拼接将数据增强后的图片存入到data_dir中,data_dir称为根目            
    #录,x来自train或者test
    #此操作表示如果数据来自train则进行数据增强train里的方式，如果来自test则进行test的增强方式
    dataloaders = {x:torch.utils.data.DataLoader(image_datasets[x], batch_size=16,
                                                 shuffle=True, num_workers=4)
                            for x in ['train', 'test']}
    #dataloaders将图片传入到训练网络中，分批次传。batch_size表示一批传几张图片，shuffle表示每        
    #次传入数据前进行打乱。num_works表示用几个线程进行加载
    dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'test']}
    #dataset_sizes获取train,test中有多少张图片
    class_names = image_datasets['train'].classes
    #class_names获取每一个类别对应的名字    

    #加载预训练的ResNet18模型
    model = models.resnet18(pretrained = True)
    #用models获取预训练模型，pretrained=True表示拿到ResNet18框架之外，还把权重文件里面的数据也 
    #拿下来。在上述OpenVINO实例中我们知道ResNet18数据集有1000中，而这里我们的数据集只有cat和 
    #dog，所以输出是不一样的，所以我们要将输出的数量换为我们的数量，以下两行为替换方法
    num_ftrs = model.fc.in_features
    model.fc = nn.Linear(num_ftrs, len(class_names))
    #网络弄好了，通过下方一行代码转到设备里面进行运行
    model = model.to(device)


    criterion = nn.CrossEntropyLoss()#训练网络时用到的损失函数，分类问题用此损失函数即可
    optimizer = optim.Adam(model.parameters(), lr=0.001)
    #Adam优化器，要优化参数model.parameters()表示models的全部参数，lr表示学习率


    best_acc = 0.0#初始化最高准确率
    best_epoch = -1#初始化
    best_model_wts = None
    

    #训练模型
    num_epochs = 25 #训练轮数
    for epoch in range(num_epochs):
        #首先输出当前是第几轮
        print(f'Epoch {epoch}/{num_epochs - 1}')
        print('-' * 10)

        #如果当前过程是train则进入训练模式model.train(),否则进入到model.eval()验证模式
        for phase in ['train', 'test']:
            if phase == 'train':
                model.train()
            else:
                model.eval()

            #初始化
            running_loss = 0.0
            running_corrects = 0
            
            #读取dataloaders里面的参数
            for inputs, labels in dataloaders[phase]:
                inputs = inputs.to(device)
                labels = labels.to(device)
                   

                #每一个迭代开始之前都对梯度计算进行清零 
                optimizer.zero_grad()

                #如果是在训练阶段就打开计算梯度的工具
                with torch.set_grad_enabled(phase == 'train'):
                    outputs = model(inputs)
                    _,preds = torch.max(outputs, 1)#找到最大值并返回结果
                    loss = criterion(outputs, labels)
                
                    if phase == 'train':
                        loss.backward()#如果是在训练阶段就进行反向传播
                        optimizer.step()#并且更新优化器
                running_loss += loss.item() * inputs.size(0)#把loss值累加
                running_corrects += torch.sum(preds == labels.data)#统计正确个数
            #每一轮结束就统计一下loss值和正确率
            epoch_loss = running_loss / dataset_sizes[phase]
            epoch_acc = running_corrects.double() / dataset_sizes[phase]
            #并显示
            print(f'{phase} Loss: {epoch_loss:.4f} Acc: {epoch_acc:.4f}')
            #如果本轮正确率比以往的都高，则进行替换
            if phase == 'test' and epoch_acc >best_acc:
                best_acc = epoch_acc
                best_epoch = epoch
                best_model_wts = model.state_dict()
            
        print()
    print('Training complete!')
    print(f'Best test accuracy: {best_acc:.4f} at epoch {best_epoch}')
    torch.save(best_model_wts, f'models/best_resnet18_model_epoch_{best_epoch}.pth')

使用预训练的ResNet18对图片进行训练，并且将性能最好的权重保存在本地。如下文件

2，模型转换

先转到onnx,再转到openvino

 pytorch转onnx.py

import torch
import torchvision.models as models

#指定要加载的模型权重文件的路径
model_weights_path = 'models/best_resnet18_model_epoch_17.pth'

#加载ResNet-18模型结构
model = models.resnet18()
model.fc = torch.nn.Linear(model.fc.in_features, 2)
#从文件中加载模型权重
model.load_state_dict(torch.load(model_weights_path))

#确保模型处于评估模式，关闭Dropout和BatchNorm层
model.eval()

#创建一个模拟输入，以便ONNX导出器能够确定输入/输出格式
#这个例子假设输入图像是224X224的三通道图像
x = torch.randn(1, 3, 224, 224, requires_grad = True)

#指定ONNX文件的输出路径
onnx_file_path = r'model\resnet18_catdog.onnx'


#将模型导出为ONNX格式
torch.onnx.export(model, #运行的模型
                  x, #模型输入（或者一个元组，如果有多个输入）
                  onnx_file_path,#保存模型的文件路径
                  export_params=True,#存储训练权重和偏置
                  opset_version=10,#ONNX版本
                  do_constant_folding=True#是否执行常量折叠优化
                )
print(f'Model saved in {onnx_file_path}')

netron工具可以查看onnx里的参数 ，如下

 onnx转OpenVINO

先安装onnx ：pip install onnx==1.14.0

再用以下命令进行转换：mo --input_model .\resnet18_catdog.onnx

转换完成的文件路径会给标明(.bin .xml .mapping)

3，模型应用：单张图片分类 

from openvino.inference_engine import IEcore
import numpy as np
import cv2


ie = IECore()#创建一个IECore对象
for device in ie.available_devices:
    print(device)

#animal.txt里面存放着分类类别名，一行为一种，此示例为分类cat和dog，所以此文件一共两行
#自己编写，并放在这些.py文件的同一目录下
with open('animal_classes.txt') as f:
    labels = [line.strip() for line in f.readlines()]


#之前文件未写r，是由于resnet.xml和resnet.bin就在当前目录下，这里用r并加上路径名来指定#resnet18_catdog.xml文件(因为此xml文件不直接在该目录下，而在该目录的文件夹中)
model_xml = r"models/resnet18_catdog.xml"
model_bin = r"models/resnet18_catdog.bin"

net = ie.read_network(model=model_xml, weights=model_bin)#读取模型


input_blob = next(iter(net.input_info))#获取模型输入层名称并保存在input_blob中
out_blob = next(iter(net.outputs))#获取模型的输出层名称

n,c,h,w = net.input_info[input_blob].input_data.shape
print(n, c, h, w)


src = cv2.imread(r"resources/85.jpg")#读取图片文件
image = cv2.resize(src, (w,h))#调整图片大小以匹配模型的输入大小
image = np.float32(image)/255.0$将图像数据归一化到[0,1]范围
image[:,:,] -= (np.float32(0.485), np.float32(0.456), np.float(0.406))#从图像中减去均值
image[:,:,] -= (np.float32(0.229), np.float32(0.224), np.float(0.225))#将图像数据除以标准#
#差
#image[:,:,]读取每一个像素值
image = image.transpose(2, 0, 1)#调整图像的维度顺序,将cv2读取的BGR(012)格式转换为RBG(2,0,1)


exec_net = ie.load_network(network = net, device_name = "CPU")#在CPU上加载模型
res = exec_net.infer(inputs={input_blob:[image]})#进行推断




res = res[out_blob]
print(res.shape)
label_index = np.argmax(res, 1)[0]
print(label_index, label[label_index])
cv2.putText(src, labels[label_index],(50,50),cv2.FONT_HERSHEY_SIMPLEX,1.0,(0,0,255),2,8)
cv2.imshow("image classification", src)
cv2.waitKey(0)

4，摄像头实时分类

摄像头实时分类.py

from openvino.inference_engine import IEcore
import numpy as np
import cv2
import time #导入time库以计算FPS


ie = IECore()#创建一个IECore对象
for device in ie.available_devices:
    print(device)

with open('animal_classes.txt') as f:
    labels = [line.strip() for line in f.readlines()]


model_xml = r"models/resnet18_catdog.xml"
model_bin = r"models/resnet18_catdog.bin"

net = ie.read_network(model=model_xml, weights=model_bin)#读取模型


input_blob = next(iter(net.input_info))#获取模型输入层名称并保存在input_blob中
out_blob = next(iter(net.outputs))#获取模型的输出层名称

n,c,h,w = net.input_info[input_blob].input_data.shape

exec_net = ie.load_network(network = net, device_name = "CPU")#在CPU上加载模型

cap = cv2.VideoCapture(0)
if not cap.isOpened():
    print("Error")
    exit()

prev_time = time.time() #在循环开始前初始化时间变量
frame_count = 0
fps = 0 #初始化fps

while True:
    ret, frame = cap.read()
    if not ret:
        print("Failed to grab frame.")
        break
    frame_count +=1
    curr_time = time.time()
    delta_time = curr_time - prev_time

    if delta_time >= 1.0: #每秒更新一次FPS
        fps = frame_count / delta_time
        frame_count = 0
        prev_time = curr_time

    image = cv2.resize(src, (w,h))
    image = np.float32(image)/255.0
    image[:,:,] -= (np.float32(0.485), np.float32(0.456), np.float(0.406))
    image[:,:,] -= (np.float32(0.229), np.float32(0.224), np.float(0.225))
    image = image.transpose(2, 0, 1)


    res = exec_net.infer(inputs={input_blob:[image]})#进行推断
    res = res[out_blob]
    print(res.shape)
    label_index = np.argmax(res, 1)[0]
    print(label_index, label[label_index])
    cv2.putText(frame, {fps:.2f},(50,100),cv2.FONT_HERSHEY_SIMPLEX,1.0,(0,0,255),2,8)
    cv2.putText(frame, labels[label_index],(50,50),cv2.FONT_HERSHEY_SIMPLEX,1.0,(0,0,255),2,8)
    cv2.imshow("image classification", src)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break
cap.release()
cv2.destroyAllWindows()

5，模型加速 (异步加速)

摄像头实时分类_异步加速.py

from openvino.inference_engine import IEcore
import numpy as np
import cv2
import time #导入time库以计算FPS


ie = IECore()#创建一个IECore对象
for device in ie.available_devices:
    print(device)

with open('animal_classes.txt') as f:
    labels = [line.strip() for line in f.readlines()]


model_xml = r"models/resnet18_catdog.xml"
model_bin = r"models/resnet18_catdog.bin"

net = ie.read_network(model=model_xml, weights=model_bin)#读取模型


input_blob = next(iter(net.input_info))#获取模型输入层名称并保存在input_blob中
out_blob = next(iter(net.outputs))#获取模型的输出层名称

n,c,h,w = net.input_info[input_blob].input_data.shape

exec_net = ie.load_network(network = net, device_name = "CPU")#在CPU上加载模型

cap = cv2.VideoCapture(0)
if not cap.isOpened():
    print("Error")
    exit()

prev_time = time.time() #在循环开始前初始化时间变量
frame_count = 0
fps = 0 #初始化fps

request_id = 0 #不同点
while True:
    ret, frame = cap.read()
    if not ret:
        print("Failed to grab frame.")
        break
    frame_count +=1
    curr_time = time.time()
    delta_time = curr_time - prev_time

    if delta_time >= 1.0: #每秒更新一次FPS
        fps = frame_count / delta_time
        frame_count = 0
        prev_time = curr_time

    image = cv2.resize(src, (w,h))
    image = np.float32(image)/255.0
    image[:,:,] -= (np.float32(0.485), np.float32(0.456), np.float(0.406))
    image[:,:,] -= (np.float32(0.229), np.float32(0.224), np.float(0.225))
    image = image.transpose(2, 0, 1)


    exec_net.start_async(request_id=request_id, inputs={input_blob:[image]})#不同点

    if exec_net.requests[request_id].wait(-1) == 0:
        res = exec_net.requests[request_id].outputs[out_blob]
        label_index = np.argmax(res, 1)[0]

        cv2.putText(frame, {fps:.2f},(50,100),cv2.FONT_HERSHEY_SIMPLEX,1.0,(0,0,255),2,8)
        cv2.putText(frame, labels[label_index],(50,50),cv2.FONT_HERSHEY_SIMPLEX,1.0,(0,0,255),2,8)

    cv2.imshow("image classification", src)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break
cap.release()
cv2.destroyAllWindows()

6，如果用神经加速棒

6，树莓派部署

环境配置

 

目标检测案例

1，准备数据集

先使用labelimg标注信息，

 打开labelimg后选择Open Dir打开要标注的数据集文件夹

选择完成后，再点击Change Save Dir来选择一个文件夹保存标注完成保存到的文件夹 

一般设一个文件夹，文件夹内有images和labels文件夹，labels文件夹用来保存标注后图片，images文件夹用来保存需要标注的图片。并且labels文件夹和images文件夹下都有train和test文件夹分别用来保存要训练的图片和测试的图片

注意，labels/train文件下必须要有一个名为classes.txt的文本文件，里面记录着标签名(要检测火则写为fire) 

标注时记得打开自动保存

2，准备YOLOv5代码

下载代码的过程推荐网址：YOLOv5-6.1从训练到部署（一）：环境安装、示例检测、推理文件的导出与可视化_yolov5 6.1-CSDN博客

将代码文件和数据集文件放到同一目录下

配置完成后，在终端运行 python detect.py --weights yolov5s.pt --conf-thres 0.4 

出现如下文件图片即可

3，准备数据集配置文件

创建文件(.yaml)内容如下，将该文件放到data目录下的scripts文件下

 

path: ../fire_yolo_format #存放数据集文件路径，这里是火灾检测，所以数据集命名为这个
train: images/train #存放训练集文件路径
val: images/val #验证集文件路径
test: images/test #测试集文件路径
#以上均为根目录
#此实例文件格式如下
#fire_yolo_format文件下有images和labels文件
#image文件下有test train val 文件
#labels文件下也有 test train val 文件


#classes
nc: 1 #一共有多少类别
name: ['fire'] #类别名字

4，进行训练

使用命令 python train.py --data fire.yaml --weights yolov5s.pt --img 640进行训练#--img 640指把图片压缩成640*640大小

调参数

detect.py中有如下参数。使用--命令时可能要修改文件地址等

train.py中有如下参数。--epochs表示轮数，可以修改。--batch-size表示一次传入多少图片，通常报下图所示错误时就要把此值调小。--workers指线程,。

利用tensorboard --logdir观察日志

重新打开一个终端，进入到yolo文件目录下，再输入 tensorboard --logdir .回车即可

在--logdir后加一个点表示以当前文件所在路径为根目录打开

回车后会弹出一个网页链接，点进去即可

训练结果 

最终的训练结果会保存到runs/train/exp/,将runs/train/exp/weights/best.pt保存起来，后期推理会用到

测试

可以在终端输入python path/to/detect.py --weights yolov5s.pt --source 0 来打开摄像头测试。yolov5s.pt要指明路径，比如

python detect.py --source ./img1.jpg --weights weights/best.pt --conf-thres 0.3

python detect.py --source 0 --weights runs/train/base_n/weights/best.pt --conf-thres0.3

评估

python .\val.py --data .\data\fire.yaml --weights .\weights\best.pt --batch-size 12。输出如下

 

5，模型转换

PyTorch->ONNX

ONNX->OpenVINO

先通过Netron确认best.onnx的网络结构，如下，在点击此三个Conv，分别在右上角name查看路径

接下来开始转换 

#全输出，需要自己修改/model.24/m.0/Conv, /model.24/m.1/Conv, /model.24/m.2/Conv为上述name查询 #的结果
#input_model:需要转换的模型best.onnx
#model_name:导出名称
#s：原始网络输入将除以该值
#reverse_input_channels:RGB转变为BGR(或者从BGR转变为RGB)
#output:模型的输出操作
mo --input_model weights/best,onnx --model_name weights/fire_model -s 255 --reverse_input_channels --output /model.24/m.0/Conv,/model.24/m.1/Conv,/model.24/m.2/Conv

输出结果