学校大创项目做了关于车辆违章检测的模型，现在简单记录一下~~~
项目主要的模块为车辆目标检测+车辆违章行为检测+车牌识别+微信小程序开发
现在主要介绍车辆违章行为检测部分，微信小程序开发见我的另一篇文章Django+uwsgi+nginx微信小程序环境搭建
选取网络
在项目中违章行为识别的思想主要是分类问题，可以简化为二分类（违章+非违章），或者复杂一点的多分类（将违章的情况细分为压实线、占用自行车道、占用人行横道等）
当然更好的方法是通过检测一些可能造成违章的标识，如禁止停车、自行车道标志、白色实线等，但考虑到复杂程度，我还是选择了分类【笑哭】
最终选取了较简单的Mobilenet网络，其中心思想是深度可分卷积，所以速度很快，并非常适合分类问题。
Mobilenet 深度可分卷积
准备数据集
由于涉及个人隐私等问题，与交管部门沟通无果，只好通过网络爬虫和自己拍摄来收集数据集。。。
因为数量较少，所以在训练时使用了数据增强
数据集中违章与非违章的比例约为1：2
训练集与数据集的比例约为10：1，没有设置验证集【数据实在是太少了呜呜呜...】
所有图片都转化为灰度图,代码如下
import cv2 as cv
img = cv.imread(image)
img=cv.cvtColor(img,cv.COLOR_RGB2GRAY)
将数据集组织好后，放入./data文件夹下
网络训练 Pytorch
使用github上Mobilenet公布的源码：pytorch-mobilenet-master
启动训练代码：
CUDA_VISIBLE_DEVICES=3 python main.py -a mobilenet --resume mobilenet_sgd.pth.tar --lr 0.01 ./data > log.txt
网络结构
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
def conv_bn(inp, oup, stride):
return nn.Sequential(
nn.Conv2d(inp, oup, 3, stride, 1, bias=False),#inp:input channel,oup:output channel
nn.BatchNorm2d(oup),
nn.ReLU(inplace=True)
)
def conv_dw(inp, oup, stride):
return nn.Sequential(
nn.Conv2d(inp, inp, 3, stride, 1, groups=inp, bias=False),
nn.BatchNorm2d(inp),
nn.ReLU(inplace=True),
nn.Conv2d(inp, oup, 1, 1, 0, bias=False),
nn.BatchNorm2d(oup),
nn.ReLU(inplace=True),
)
#哈哈哈哈在这里可见pytorch真是简单啊~~~
self.model = nn.Sequential(
conv_bn( 3, 32, 2),
conv_dw( 32, 64, 1),
conv_dw( 64, 128, 2),
conv_dw(128, 128, 1),
conv_dw(128, 256, 2),
conv_dw(256, 256, 1),
conv_dw(256, 512, 2),
conv_dw(512, 512, 1),
conv_dw(512, 512, 1),
conv_dw(512, 512, 1),
conv_dw(512, 512, 1),
conv_dw(512, 512, 1),
conv_dw(512, 1024, 2),
conv_dw(1024, 1024, 1),
nn.AvgPool2d(7),
)
self.fc1 = nn.Linear(1024, 2) #这里将输出改为2，因为是二分类
def forward(self, x):
x = self.model(x)
x = x.view(-1, 1024)
x = self.fc1(x)
return x
参数设置
parser = argparse.ArgumentParser(description='PyTorch ImageNet Training')
#数据集存放的位置
parser.add_argument('data', metavar='DIR',
help='path to dataset')
#使用的网络结构 -a mobilenet
parser.add_argument('--arch', '-a', metavar='ARCH', default='resnet18',
choices=model_names,
help='model architecture: ' +
' | '.join(model_names) +
' (default: resnet18)')
parser.add_argument('-j', '--workers', default=4, type=int, metavar='N',
help='number of data loading workers (default: 4)')
#训练的epoch总数
parser.add_argument('--epochs', default=90, type=int, metavar='N',
help='number of total epochs to run')
#每次训练从第几个epoch开始
parser.add_argument('--start-epoch', default=0, type=int, metavar='N',
help='manual epoch number (useful on restarts)')
#设置batch-size
parser.add_argument('-b', '--batch-size', default=32, type=int,
metavar='N', help='mini-batch size (default: 32)')
#设置学习率
parser.add_argument('--lr', '--learning-rate', default=0.1, type=float,
metavar='LR', help='initial learning rate')
#设置动量
parser.add_argument('--momentum', default=0.9, type=float, metavar='M',
help='momentum')
parser.add_argument('--weight-decay', '--wd', default=1e-4, type=float,
metavar='W', help='weight decay (default: 1e-4)')
parser.add_argument('--print-freq', '-p', default=10, type=int,
metavar='N', help='print frequency (default: 10)')
#设置选用的预训练模型 项目中使用mobilenet提供的模型：mobilenet_sgd.pth.tar
parser.add_argument('--resume', default='', type=str, metavar='PATH',
help='path to latest checkpoint (default: none)')
parser.add_argument('-e', '--evaluate', dest='evaluate', action='store_true',
help='evaluate model on validation set')
parser.add_argument('--pretrained', dest='pretrained', action='store_true',
help='use pre-trained model')
加载预训练模型
pretrained_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict}
注意只挑选共同存在的部分加载
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch=0
best_prec1 = checkpoint['best_prec1']
pretrained_dict=checkpoint['state_dict']
model_dict = model.state_dict()
#注意这里！因为对网络结构进行了修改，所以这里加载resume时，只挑选共同存在的部分加载！！
pretrained_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict}
model_dict.update(pretrained_dict)
model.load_state_dict(model_dict)
print("=> loaded checkpoint '{}' (epoch {})"
.format(args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
cudnn.benchmark = True
数据集加载
直接调用pytorch用来导入数据的API，附上Pytorch中文文档
traindir = os.path.join(args.data, 'train')#训练集
valdir = os.path.join(args.data, 'val')#测试集
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
#直接调用pytorch用来导入数据的API，很方便
train_loader = torch.utils.data.DataLoader(
datasets.ImageFolder(traindir, transforms.Compose([
transforms.RandomResizedCrop(224),#resize 为224*224
transforms.RandomHorizontalFlip(),#数据增强 随机翻转
transforms.ToTensor(),
normalize,#正则化
])),
batch_size=args.batch_size, shuffle=True,
num_workers=args.workers, pin_memory=True)
val_loader = torch.utils.data.DataLoader(
datasets.ImageFolder(valdir, transforms.Compose([
#transforms.Resize(256),
transforms.CenterCrop(224),#选取中间部分的224*224
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size, shuffle=False,
num_workers=args.workers, pin_memory=True)
测试
我自己重新书写了test文件,其中测试用图放在./data/figure下
测试命令：CUDA_VISIBLE_DEVICES=3 python test.py
代码分析
def test():
model = Net()
#加载测试使用的训练好的网络模型
checkpoint=torch.load('./checkpoint.pth.tar')
model = torch.nn.DataParallel(model).cuda()
model.load_state_dict(checkpoint['state_dict'])
# define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss().cuda()
# Data loading code
testdir = os.path.join('./data', 'figure')
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
test_loader = torch.utils.data.DataLoader(
datasets.ImageFolder(testdir, transforms.Compose([
transforms.Resize(224), #同样进行resize到224*224
transforms.ToTensor(),
normalize,
])),
)
validate(test_loader, model, criterion)
其中validate函数具体如下：
def validate(test_loader, model, criterion):
#Computes and stores the average and current value
batch_time = AverageMeter()
losses = AverageMeter()
# switch to evaluate mode
model.eval()
for i, (input,target) in enumerate(test_loader):
target = target.cuda(async=True)
input_var = torch.autograd.Variable(input, volatile=True)
target_var = torch.autograd.Variable(target, volatile=True)
# compute output
output = model(input_var)
output=torch.nn.functional.softmax(output)
#将output转化为numpy类型，以便得到分类结果
outputb=output.data.cpu()
outputb=outputb.numpy()
if outputb[0][0]/0.4>=outputb[0][1]/0.6:
print('Not Violate')
else:
print('Violate!')
Finetune一部分层
分为四种情况，解决方法基于的原则就是:
NN中的低层特征是比较generic的，比如说线、边缘的信息，高层特征是Dataset Specific的，基于此，如果你的数据集和ImageNet差异比较大，这个时候你应该尽可能的少用pre-trained model的高层特征.
1.数据集小(比如<5000)，相似度高
这是最常见的情况，可以仅重新训练最后一层(fc layer）
2.数据集大(比如>10000)，相似度高
fine-tuning后几层，保持前面几层不变或者干脆直接使用pre-trained model作为初始化，fine-tuning整个网络
3.数据集小，相似度低
小数据集没有办法进行多层或者整个网络的fine-tuning，建议保持前几层不动，fine-tuning后几层(效果可能也不会很好)
4.数据集大，相似度低
虽然相似度低，但是数据集大，可以和2一样处理
从上面我们可以看出，数据集大有优势，否则最好是数据集和原始的相似度比较高；如果出现数据集小同时相似度低的情况，这个时候去fine-tuning后几层未必会有比较好的效果.
代码演示（只finetune最后一层fc层）
#将除最后一层的参数，其它层的参数 requires_grad 设置为 False
for param in list(model.parameters())[:-2]:
param.requires_grad = False
# define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss().cuda()
#只优化最后的分类层
optimizer = torch.optim.SGD(model.fc.parameters(), lr=0.005,
momentum=0.9,
weight_decay=1e-4)
以上就是车辆违章行为检测的主要内容。