本文章基于aidlux开发的车辆安全检测
1.我们需要了解aidlux
2. 边缘设备软件Aidlux的使用说明****
2.1 Aidlux的特点****
目前为止，我们已经了解了AI安全相关的知识以及“以数据为中心”的机器学习策略，加上第一节课学习的智慧交通和CV项目开发落地的理论知识，我们已经有了足够的知识储备，可以开始智慧交通与AI安全项目的学习了。不过在此之前，我们需要先熟悉一下Aidlux边缘设备软件，因为后续我们将在Aidlux上完成很多项目功能。
Aidlux主打的是基于ARM架构的跨生态(Android/鸿蒙+Linux)一站式AIOT应用开发平台。用比较简单的方式理解，我们平时编写训练模型，测试模型的时候，常用的是 Linux/window系统。而实际应用到现场的时候，通常会以几种形态：GPU服务器、嵌入式设备(比如Android手机、人脸识别闸机，摄像头等)、边缘设备。GPU服务器我们好理解，而Android 嵌入式设备的底层芯片，通常是ARM架构。而Linux底层也是ARM架构，并且Android又是基于Linux内核开发的操作系统，两者可以共享Linux内核。因此就产生了从底层开发一套应用系统的方式，在此基础上同时带来原生Android和原生Linux使用体验。
因此基于ARM芯片，开发了Aidlux平台，可以在安卓手机上直接下载Aidlux使用。同时基于 ARM芯片，比如高通骁龙的855芯片和865芯片，也开发了AidBox边缘设备，提供7T OPS和15TOPS算力，可以直接在设备上使用。
而使用这些设备平台开发的时候，和在Linux上开发都是通用的，即Linux上开发的Python代 码，可以在安卓手机、边缘设备上转换后无缝使用。
那么为什么可以无缝使用呢？
常规的方式，应用在手机Android时，需要将PC上编写的代码，封装成Android SO库（C++）。经过测试后，封装JNI调用SO库，最终在Android上使用Java调用JNI，最终再进行测试发布。因此我们可以看到，这样的流程需要一系列的工作人员参与，比如C++、Java、Python的工程师。Aidlux将其中的整个开发流程，全部打通，通过Aidlux平台，可以将PC端编写的代码，快速应用到Android系统上。
那么有了Android和Linux双系统开发的基础，就可以做很多的事情了。而AI算法应用，就是比较典型的一种。不过这里就涉及到，芯片对于AI算法的优化加速的能力。Aidlux内部一方面内置了多种深度学习框架，便于快速开发。另外对于多种算子进行了优化加速，很多算法的性能，也都能达到实时使用。
2.2 Aidlux的使用说明和详细操作实例****
因为后面的课程中，需要使用Aidlux，因此大家可以先提前下载Aidlux软件。关于Aidlux的使用说明和详细操作实例，江大白老师已经在上一次训练营的第二节课中讲过。大家可以看一下大白老师第二节课的课程内容：docs.qq.com/doc/DWEdSV2…
3.大作业流程：
利用yolov5检测出来的车辆检测结果进行对抗样本的生成，将对抗样本传进模型，通过ai检测模型可以判断这张图片是否带有恶意，以提高鲁棒性，进行一个告警功能的实现。
1. 第一步：车辆检测，生成检测框里的车图片
首先找一张有关车的图片，我们通过yolov5找到图片中车的具体位置，再通过相关函数进行裁剪，提取车辆目标区域
我们试着利用模型判断这个车的类型
2. 生成对抗样本
可以看到加入了很多的噪声
可以观察到模型输出的类型与之前不同，可以知道这对抗样本干扰到模型的准确性。
3. 对抗攻击检测模型
对抗攻击检测模型是一个能够捕捉对抗扰动的二分类模型，这里使用一个已经训练好的基于ResNet50的模型，作为检测模型。再通过喵提醒将检测模型的告警结果发送到手机公众号中。
4. 完整流程串联：
车辆检测+检测框提取+对抗样本+ai安全检测警告功能。
判断是否进行攻击，如果是，则通过公众号进行消息提醒
aidlux的部署非常方便：由于代码是同步的，所以只要这边写好，那边就直接部署好了。
import os
import torch
import requests
import time
import torch.nn as nn
from torchvision.models import mobilenet_v2,resnet18
from advertorch.utils import predict_from_logits
from advertorch.utils import NormalizeByChannelMeanStd
from robust_layer import GradientConcealment, ResizedPaddingLayer
from timm.models import create_model
from advertorch.attacks import LinfPGDAttack
from advertorch_examples.utils import ImageNetClassNameLookup
from advertorch_examples.utils import bhwc2bchw
from advertorch_examples.utils import bchw2bhwc
import torchvision.utils
from cvs import *
import cvs
import aidlite_gpu
from aidlux.utils import detect_postprocess, preprocess_img, draw_detect_res, extract_detect_res
import cv2
device = "cuda" if torch.cuda.is_available() else "cpu"
#读取图片
def get_image():
img_path = os.path.join("/home/carJiance/Lesson5_code/adv_code/duikangpicture", "vid_5_27620.jpg_0.jpg")
img_url = "farm1.static.flickr.com/230/5245623…"
def _load_image():
from skimage.io import imread
return imread(img_path) / 255.
if os.path.exists(img_path):
return _load_image()
else:
import urllib
urllib.request.urlretrieve(img_url, img_path)
return _load_image()
##模型加载
normalize = NormalizeByChannelMeanStd(
mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
常规模型加载
model = mobilenet_v2(pretrained=True)
model.eval()
model = nn.Sequential(normalize, model)
model = model.to(device)
替身模型加载
model_su = resnet18(pretrained=True)
model_su.eval()
model_su = nn.Sequential(normalize, model_su)
model_su = model_su.to(device)
def tensor2npimg(tensor):
return bchw2bhwc(tensor[0].cpu().numpy())
常规模型加载
class Model(nn.Module):
def init(self, l=290):
super(Model, self).init()
self.l = l
self.gcm = GradientConcealment()
#model = resnet18(pretrained=True)
model = mobilenet_v2(pretrained=True)
self.model = nn.Sequential(normalize, model)
def load_params(self):
pass
def forward(self, x):
#x = self.gcm(x)
#x = ResizedPaddingLayer(self.l)(x)
out = self.model(x)
return out
对抗攻击监测模型
class Detect_Model(nn.Module):
def init(self, num_classes=2):
super(Detect_Model, self).init()
self.num_classes = num_classes
#model = create_model('mobilenetv3_large_075', pretrained=False, num_classes=num_classes)
model = create_model('resnet50', pretrained=False, num_classes=num_classes)
# self.multi_PreProcess = multi_PreProcess()
pth_path = os.path.join("/home/carJiance/Lesson5_code/model", 'track2_resnet50_ANT_best_albation1_64_checkpoint.pth')
#pth_path = os.path.join("/Users/rocky/Desktop/训练营/Lesson5_code/model/", "track2_tf_mobilenetv3_large_075_64_checkpoint.pth")
state_dict = torch.load(pth_path, map_location='cpu')
is_strict = False
if 'model' in state_dict.keys():
model.load_state_dict(state_dict['model'], strict=is_strict)
else:
model.load_state_dict(state_dict, strict=is_strict)
# self.model = nn.Sequential(normalize, self.multi_PreProcess, model)
self.model = nn.Sequential(normalize, model)
def load_params(self):
pass
def forward(self, x):
# x = x[:,:,32:193,32:193]
# x = F.interpolate(x, size=(224,224), mode="bilinear", align_corners=True)
# x = self.multi_PreProcess.forward(x)
out = self.model(x)
if self.num_classes == 2:
out = out.softmax(1)
#return out[:,1:]
return out[:,1:]
model = Model().eval().to(device)
detect_model = Detect_Model().eval().to(device)
def attack():
### 数据预处理
np_img = get_image()
img = torch.tensor(bhwc2bchw(np_img))[None, :, :, :].float().to(device)
imagenet_label2classname = ImageNetClassNameLookup()
### 测试模型输出结果
pred = imagenet_label2classname(predict_from_logits(model(img)))
print("车的类型:", pred)
### 输出原label
pred_label = predict_from_logits(model_su(img))
### 对抗攻击：PGD攻击算法
adversary = LinfPGDAttack(
model_su, eps=8/255, eps_iter=2/255, nb_iter=80,
rand_init=True, targeted=False)
### 完成攻击，输出对抗样本
advimg = adversary.perturb(img, pred_label)
return advimg
AidLite初始化：调用AidLite进行AI模型的加载与推理，需导入aidlite
aidlite = aidlite_gpu.aidlite()
Aidlite模型路径
model_path = '/home/carJiance/Lesson5_code/yolov5_code/models/yolov5_car_best-fp16.tflite'
定义输入输出shape
in_shape = [1 * 640 * 640 * 3 * 4]
out_shape = [1 * 25200 * 6 * 4]
加载Aidlite检测模型：支持tflite, tnn, mnn, ms, nb格式的模型加载
aidlite.ANNModel(model_path, in_shape, out_shape, 4, 0)
def main():
# 读取图片进行推理
# 设置测试集路径
source = "/home/carJiance/Lesson5_code/adv_code/test_images"
images_list = os.listdir(source)
print(images_list)
frame_id = 0
# 读取数据集
for image_name in images_list:
frame_id += 1
print("frame_id:", frame_id)
image_path = os.path.join(source, image_name)
frame = cv2.imread(image_path)
print("数据预处理开始")
# 预处理
img = preprocess_img(frame, target_shape=(640, 640), div_num=255, means=None, stds=None)
# 数据转换：因为setTensor_Fp32()需要的是float32类型的数据，所以送入的input的数据需为float32,大多数的开发者都会忘记将图像的数据类型转换为float32
aidlite.setInput_Float32(img, 640, 640)
# 模型推理API
aidlite.invoke()
# 读取返回的结果
pred = aidlite.getOutput_Float32(0)
# 数据维度转换
pred = pred.reshape(1, 25200, 6)[0]
# 模型推理后处理
pred = detect_postprocess(pred, frame.shape, [640, 640, 3], conf_thres=0.25, iou_thres=0.45)
# 绘制推理结果
res_img = draw_detect_res(frame, pred)
# 图片裁剪，提取车辆目标区域
extract_detect_res(frame, pred, image_name)
print("图片裁剪完成")
### 数据预处理
np_img = get_image()
print("2")
img = torch.tensor(bhwc2bchw(np_img))[None, :, :, :].float().to(device)
print("3")
imagenet_label2classname = ImageNetClassNameLookup()
print("测试模型输出结果")
### 测试模型输出结果
pred = imagenet_label2classname(predict_from_logits(model(img)))
print("输出原label")
### 输出原label
pred_label = predict_from_logits(model_su(img))
print("进行输出对抗样本")
### 对抗攻击：PGD攻击算法
adversary = LinfPGDAttack(
model_su, eps=8/255, eps_iter=2/255, nb_iter=80,
rand_init=True, targeted=False)
### 完成攻击，输出对抗样本
advimg = adversary.perturb(img, pred_label)
print("完成输出对抗样本")
print("对抗攻击检测")
### 对抗攻击监测
detect_pred = detect_model(advimg)
if detect_pred > 0.5:
id = 'tLCW5i9'
# 填写喵提醒中，发送的消息，这里放上前面提到的图片外链
text = "出现对抗攻击风险！！"
ts = str(time.time()) # 时间戳
type = 'json' # 返回内容格式
request_url = "miaotixing.com/trigger?"
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.67 Safari/537.36 Edg/87.0.664.47'}
result = requests.post(request_url + "id=" + id + "&text=" + text + "&ts=" + ts + "&type=" + type,
headers=headers)
else:
pred = imagenet_label2classname(predict_from_logits(model(img)))
print("车的类型为："+pred)
print("结束")
if name=="main":
print("流程开始")
main()
print("流程结束")
