学校大创项目做了关于车辆违章检测的模型，现在简单记录一下~~~
项目主要的模块为车辆目标检测+车辆违章行为检测+车牌识别+微信小程序开发
选取网络
在项目中违章行为识别的思想主要是分类问题，可以简化为二分类（违章+非违章），或者复杂一点的多分类（将违章的情况细分为压实线、占用自行车道、占用人行横道等）
当然更好的方法是通过检测一些可能造成违章的标识，如禁止停车、自行车道标志、白色实线等，但考虑到复杂程度，我还是选择了分类【笑哭】
最终选取了较简单的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 mobilenetparser.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-sizeparser.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.tarparser.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)
以上就是车辆违章行为检测的主要内容。
作者：飞翔的小瓜瓜
链接：https://www.jianshu.com/p/cb7888f52cf3