大家好，欢迎来到IT知识分享网。

1. 写在开始之前

在学习过目标检测和字符识别后想用yolov5、crnn+ctc做一个车牌识别项目，本意是参考大佬们的项目，怎奈钱包不允许。网上有关车牌检测的基本都是引流贴，甚至有的连用到的公共数据集都不放链接，索性我也不找了，直接找原始数据集，从头开始搞。

本文是一篇实战过程记录，仅记录我在车牌识别项目中的工作，不会牵涉过多理论知识。而且本次实战由于收集的数据集不太合适，导致效果较差，因此不建议读者直接搬用我收集的数据集。

2. 项目思路

功能：车牌识别分为车牌检测、识别两个部分，即先检测到车牌再识别检测到的车牌。不过我想在车牌检测、识别的基础上再加上车辆的检测，让项目变得更有意思一些。
思路一：找一个带有车辆、车牌标注的数据集，使用yolov5训练–>使用crnn+ctc网络训练车牌识别–>推理时将检测与识别组合在一起，以达到预期的功能。
可行性：没有找到合适的数据集，因此只能换一个思路了。
思路二：将车辆检测、车牌检测的训练分开，分别收集数据集，使用yolov5训练–>使用crnn+ctc网络训练车牌识别–>推理时将检测与识别组合在一起，以达到预期的功能。
可行性：数据集的收集较为容易，但是推理阶段的组合变得困难了。

3. 项目数据集

3.1. 车辆检测数据集

数据集名称：BITVehicle_data
数据集简介：北京理工大学实验室放出来的数据集，该数据集包含6个类别：公共汽车、微型巴士、小型货车、轿车、SUV和卡车，共9850张图片。数据集中不同时间和地点的两个相机捕获了大小为 16001200和 19201080的图像。图像包含照明条件、比例、车辆表面颜色和视点的变化。由于捕获延迟和车辆的大小，某些车辆的顶部或底部不包括在图像中。不过该数据集的标注是以.mat形式保存的，因此需要先转为适合yolov5的格式。
数据集预处理：将标注转为**.txt**格式；将源数据集分为训练数据集和评估数据集，train:val=6000:3850

import scipy.io as sio import random from shutil import copyfile def label_process(root, val_num): base_dir = root load_fn = base_dir + "labels/VehicleInfo.mat" load_data = sio.loadmat(load_fn) data = load_data['VehicleInfo'] val_index = random.sample(range(data.size), val_num) for i in range(len(data)): item = data[i] str = "" print("-" * 30) for j in range(item['vehicles'][0][0].size): # Bus, Microbus, Minivan, Sedan, SUV, and Truck vehicles = item['vehicles'][0][0][j] height = item['height'][0][0][0] width = item['width'][0][0][0] left = vehicles[0][0][0] top = vehicles[1][0][0] right = vehicles[2][0][0] bottom = vehicles[3][0][0] # 边界框内的车辆类别 vehicles_type = vehicles[4][0] if vehicles_type == 'Bus': vehicles_type = 0 elif vehicles_type == 'Microbus': vehicles_type = 1 elif vehicles_type == 'Minivan': vehicles_type = 2 elif vehicles_type == 'Sedan': vehicles_type = 3 elif vehicles_type == 'SUV': vehicles_type = 4 elif vehicles_type == 'Truck': vehicles_type = 5 # 边界框的信息描述，即(c, x, y, w, h) str += '%s %s %s %s %s' % (vehicles_type, round(float((left + (right - left) / 2) / width), 6), round(float((top + (bottom - top) / 2) / height), 6), round(float((right - left) / width), 6), round(float((bottom - top) / height), 6)) + '\n' name = item['name'][0][0] str = str[:str.rfind('\n')] print(str) if i in val_index: with open(base_dir + "val/labels/" + name[:-3] + "txt", 'w') as f: f.write(str + '\n') copyfile(base_dir + "images/" + name, base_dir + "val/images/" + name) else: with open(base_dir + "train/labels/" + name[:-3] + "txt", 'w') as f: f.write(str + '\n') copyfile(base_dir + "images/" + name, base_dir + "train/images/" + name) print('done--') if __name__ == "__main__": root = "../raw_data/BITVehicle_data/" val_num = 3850 label_process(root, val_num) 

备注：角度单一，只有俯拍角度；场景简单，每张图中只有几辆车，因此应再找一些其他角度的数据集，以提高模型的鲁棒性。

3.2. 车牌检测数据集

数据集名称：CCPD2019_data
数据集简介：CCPD是一个大型的、多样化的、经过仔细标注的中国城市车牌开源数据集。CCPD数据集主要分为CCPD2019数据集和CCPD2020(CCPD-Green)数据集。CCPD2019数据集车牌类型仅有普通车牌(蓝色车牌)，CCPD2020数据集车牌类型仅有新能源车牌(绿色车牌)。CCPD2019数据集主要采集于合肥市停车场，采集时间为上午7:30到晚上10:00，停车场采集人员手持Android POS机对停车场的车辆拍照进行数据采集。所拍摄的车牌照片涉及多种复杂环境，包括模糊、倾斜、雨天、雪天等。
标注介绍：CCPD数据集没有专门的标注文件，每张图像的文件名就是该图像对应的数据标注。如图片【025-95_113-154&383_386&473-386&473_177&454_154&383_363&402-0_0_22_27_27_33_16-37-15.jpg】，其文件名的含义如下：

025：车牌区域占整个画面的比例；95_113： 车牌水平和垂直角度, 水平95°, 竖直113°；154&383_386&473：标注框左上、右下坐标，左上(154, 383), 右下(386, 473)；86&473_177&454_154&383_363&402：标注框四个角点坐标，顺序为右下、左下、左上、右上；0_0_22_27_27_33_16：车牌号码映射关系如下: 第一个0为省份 对应省份字典provinces中的’皖’,；第二个0是该车所在地的地市一级代码，对应地市一级代码字典alphabets的’A’；后5位为字母和文字, 查看车牌号ads字典，如22为Y，27为3，33为9，16为S，最终车牌号码为皖AY339S。

数据集预处理：由于该数据集很大，我挑选了部分用于项目；从图片名字中将车牌检测的标注转为.txt格式。以下是提取ccpd车牌边界框标注的代码。

import numpy as np import os import cv2 def imgname2bbox(images_path, labels_path): dirs = os.listdir(images_path) for image in dirs: image_name = image.split(".")[0] box = image_name.split("-")[2] # 边界框信息 box = box.split("_") box = [list(map(int, i.split('&'))) for i in box] # 图片信息 image_path = f"{images_path}{image}" img = cv2.imread(image_path) with open(labels_path + image_name + ".txt", "w") as f: x_min, y_min = box[0] x_max, y_max = box[1] x_center = (x_min + x_max) / 2 / img.shape[1] y_center = (y_min + y_max) / 2 / img.shape[0] width = (x_max - x_min) / img.shape[1] height = (y_max - y_min) / img.shape[0] f.write(f"0 {x_center:.6} {y_center:.6} {width:.6} {height:.6}") if __name__ == "__main__": images_train_path = "../data/CCPD_data/train/images/" images_val_path = "../data/CCPD_data/val/images/" labels_train_path = "../data/CCPD_data/train/labels/" labels_val_path = "../data/CCPD_data/val/labels/" # 从图片名字中提取ccpd的边界框信息，即(c, x, y, w, h) dic_images = {0: images_train_path, 1: images_val_path} dic_labels = {0: labels_train_path, 1: labels_val_path} for i in dic_images: imgname2bbox(dic_images[i], dic_labels[i]) 

3.3. 车牌识别数据集

数据集名称：CCPD2019_data
数据集预处理：从CCPD2019_data裁剪出车牌图像；从图片名字中将车牌提取车牌标签（车牌信息）。

import numpy as np import os import cv2 def ccpd_data2ccpd_plate_data(images_path, plate_images_path): dirs = os.listdir(images_path) for image in dirs: # 读取图片 img = cv2.imread(f"{images_path}{image}") # 图片名字 image_name = image.split(".")[0] # 车牌的四个角点信息 points = image_name.split("-")[3] points = points.split('_') points = [list(map(int, i.split('&'))) for i in points] # 将关键点的顺序变为从左上顺时针开始 points = points[-2:] + points[:2] # 在图像上绘制车牌的四个角点 # for i, pt in enumerate(points): # cv2.circle(img, pt, 5, (0, 222, 0), -1) # 原车牌角点数组 pst1 = np.float32(points) # 变换后的车牌角点数组 x_min, x_max = min(pst1[:, 0]), max(pst1[:, 0]) y_min, y_max = min(pst1[:, 1]), max(pst1[:, 1]) pst2 = np.float32([(0, 0), (x_max - x_min, 0), (x_max - x_min, y_max - y_min), (0, y_max - y_min)]) matrix = cv2.getPerspectiveTransform(pst1, pst2) plate = cv2.warpPerspective(img, matrix, (int(x_max - x_min), int(y_max - y_min))) cv2.imwrite(f"{plate_images_path}plate_{image}", plate) # 省份列表，index对应ccpd province_list = [ "皖", "沪", "津", "渝", "冀", "晋", "蒙", "辽", "吉", "黑", "苏", "浙", "京", "闽", "赣", "鲁", "豫", "鄂", "湘", "粤", "桂", "琼", "川", "贵", "云", "西", "陕", "甘", "青", "宁", "新"] # 字母数字列表，index对应ccpd word_list = [ "A", "B", "C", "D", "E", "F", "G", "H", "J", "K", "L", "M", "N", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9"] def imgname2plate_label(images_path, plate_labels_path): dirs = os.listdir(images_path) lst = [] for image in dirs: # 图片名字 image_name = image.split(".")[0] # 车牌的文字信息 label = image_name.split("-")[4] # 读取车牌号 label = label.split("_") province = province_list[int(label[0])] words = [word_list[int(i)] for i in label[1:]] # 车牌号 label = province + "".join(words) lst.append(f"{image}---{label}") with open(plate_labels_path + "imgnames_labels.txt", "w") as f: for line in lst: f.write(f"plate_{line}\n") if __name__ == "__main__": images_train_path = "../data/CCPD_data/train/images/" images_val_path = "../data/CCPD_data/val/images/" labels_train_path = "../data/CCPD_data/train/labels/" labels_val_path = "../data/CCPD_data/val/labels/" plate_images_train_path = "../data/CCPD_plate_data/train/images/" plate_labels_train_path = "../data/CCPD_plate_data/train/labels/" plate_images_val_path = "../data/CCPD_plate_data/val/images/" plate_labels_val_path = "../data/CCPD_plate_data/val/labels/" # 从ccpd数据集中提取车牌数据集 dic_images = {0: images_train_path, 1: images_val_path} dic_plate_images = {0: plate_images_train_path, 1: plate_images_val_path} for i in dic_images: ccpd_data2ccpd_plate_data(dic_images[i], dic_plate_images[i]) dic_images = {0: images_train_path, 1: images_val_path} dic_plate_labels = {0: plate_labels_train_path, 1: plate_labels_val_path} for i in dic_images: imgname2plate_label(dic_images[i], dic_plate_labels[i]) 

备注：由于主要是在合肥采集，因此“皖”牌照居多，导致对其他省份的简称识别较差。

4. 目标检测部分

模型：yolov5_v6s
训练：kaggle
数据：车辆检测—BITVehicle_data；车牌检测—CCPD2019_data
epochs：车辆检测—30；车牌检测—30
使用kaggle训练yolov5模型的具体过程，这里不在多言，如果读者对此不熟练可阅读这篇文章：【pytorch】目标检测：一文搞懂如何利用kaggle训练yolov5模型
这里展示一下车辆检测的推理效果：

5. 字符识别部分

车牌的字符是规则文本形式，不存在弯曲、旋转等变化，比较适合运用crnn+ctc识别方法。只不过由于拍摄角度会存在透视问题，需要在推理时做一下矫正变换。
有关crnn+ctc的原理这里不再详述，推荐两篇文章，个人认为讲的很透彻。

5.1. lmdb格式的数据

将图片、标签转为lmdb格式保存（可以减少训练时的寻址时间，特别是在图片尺寸小、数量多时，优势更明显）。转换的方法也很简单，就是首先读入图像和对应的文本标签，先使用字典将该组合存储起来（cache），再利用lmdb包的put函数把字典(cache)存储的k,v写成lmdb格式存储好（cache当有了1000个元素就put一次）。

import lmdb import cv2 import numpy as np import os out_path_train = "../data/CCPD_plate_data/train/train_lmdb" in_path_train = "../data/CCPD_plate_data/train/labels/imgnames_labels.txt" root_train = "../data/CCPD_plate_data/train/images/" map_size_train = "" # 500mb out_path_val = "../data/CCPD_plate_data/val/val_lmdb" in_path_val = "../data/CCPD_plate_data/val/labels/imgnames_labels.txt" root_val = "../data/CCPD_plate_data/val/images/" map_size_val = "" # 100mb out_path = {0: out_path_train, 1: out_path_val} in_path = {0: in_path_train, 1: in_path_val} root = {0: root_train, 1: root_val} map_size = {0: map_size_train, 1: map_size_val} def checkImageIsValid(imageBin): if imageBin is None: return False try: imageBuf = np.frombuffer(imageBin, dtype=np.uint8) img = cv2.imdecode(imageBuf, cv2.IMREAD_GRAYSCALE) imgH, imgW = img.shape[0], img.shape[1] except: return False else: if imgH * imgW == 0: return False return True def writeCache(env, cache): with env.begin(write=True) as txn: for k, v in cache.items(): if isinstance(v, bytes): txn.put(k.encode(), v) else: txn.put(k.encode(), v.encode()) def createDataset(outputPath, imagePathList, labelList, root, map_size, checkValid=True): """ 为crnn的训练准备lmdb数据 :param outputPath: lmdb数据的输出路径 :param imagePathList: 图像数据的路径列表，即train.txt文件列表化 :param labelList: 图像数据对应的标签列表 :param checkValid: bool，辨别imagePathList中的路径是否为图片 :return: """ assert (len(imagePathList) == len(labelList)) nSamples = len(imagePathList) # map_size定义最大储存容量，单位是b env = lmdb.open(outputPath, map_size=int(map_size)) # 缓存字典 cache = {} # 计数器 counter = 1 for i in range(nSamples): imagePath = os.path.join(root, imagePathList[i]).split("---")[0] label = ''.join(labelList[i]) with open(imagePath, 'rb') as f: imageBin = f.read() if checkValid: if not checkImageIsValid(imageBin): print('%s is not a valid image' % imagePath) continue imageKey = 'image-%09d' % counter labelKey = 'label-%09d' % counter cache[imageKey] = imageBin cache[labelKey] = label if counter % 1000 == 0: writeCache(env, cache) cache = {} print('Written %d / %d' % (counter, nSamples)) counter += 1 print(counter) nSamples = counter - 1 cache['num-samples'] = str(nSamples) writeCache(env, cache) print('Created dataset with %d samples' % nSamples) if __name__ == '__main__': for i in range(2): out_path = out_path[i] in_path = in_path[i] root = root[i] map_size = map_size[i] outputPath = out_path if not os.path.exists(out_path): os.mkdir(out_path) with open(in_path, "r") as imgdata: imagePathList = list(imgdata) labelList = [] for line in imagePathList: word = line.split("---")[1].replace("\n", "") labelList.append(word) createDataset(outputPath, imagePathList, labelList, root, map_size=map_size) 

5.2. 字符的编码与解码

在字符识别中还需要将文字标签数字化，即我们用数字来表示每一个文字。比如“我”字对应的id是1，“l”对应的id是1000，“？”对应的id是90，如此类推，这种编解码工作使用字典数据结构存储即可，训练时先把标签编码（encode），预测时就将网络输出结果解码(decode)成文字输出。在开始编码、解码前，我们需要先明确字母表，它就是一个字符串。

alphabets = "皖沪津渝冀晋蒙辽吉黑苏浙京闽赣鲁豫鄂湘粤桂琼川贵云西陕甘青宁新ABCDEFGHIJKLMNPQRSTUVWXYZ0"

下面让我们来看一下该字母表对应的编码、解码函数。

class StrLabelConverter(object): """ 作用：字符串与标签之间的转换 注意：需要在字母表中的首位置插入‘blank’, 为CTC计算损失做准备 参数：字母表(alphabet) """ def __init__(self, alphabet): self.alphabet = '-' + alphabet self.dict = {} for i, char in enumerate(alphabet): # 字典的值‘0’是为‘blank’准备的 self.dict[char] = i + 1 def ocr_encode(self, text): """ 作用：将字符串进行编码为标签，支持single和batch模式 :param text:lmdb格式的标签，可以是single也可以是batch，是一个可迭代的对象 :return: torch.IntTensor [length_0 + length_1 + ... length_{n - 1}]: length_x，是指第x个single torch.IntTensor [n]: n个single，每个single的值m表明该single有m个字符 """ length, result = [], [] for item in text: item = item.decode("utf-8", "strict") length.append(len(item)) for char in item: index = self.dict[char] result.append(index) text = result # print(text,length) return torch.LongTensor(text), torch.LongTensor(length) def ocr_decode(self, t, length, raw=False): """ 作用：将标签进行码为字符串，支持single和batch模式 :param t: 将要进行解码的标签，可以是single也可以是batch，Tensor形式 :param length:若length含有n个元素，则表明有n个single，每个single的值m表明网络预测有m个字符 :param raw: bool，False:去重；True: 不去重 :return: 模型预测的字符串 """ if length.numel() == 1: length = length[0] assert t.numel() == length, f"text with length: {t.numel()} does not match declared length: {length}" if raw: return ''.join([self.alphabet[i] for i in t]) else: char_list = [] for i in range(length): if t[i] != 0 and (not (i > 0 and t[i - 1] == t[i])): char_list.append(self.alphabet[t[i]]) return ''.join(char_list) else: # batch模式，通过递归的方式实现该模式 assert t.numel() == length.sum(), f"texts with length: {t.numel()} does not match declared length: {length.sum()}" texts = [] index = 0 for i in range(length.numel()): l = length[i] texts.append(self.ocr_decode(t[index:index + l], torch.IntTensor([l]), raw=raw)) index += l return texts 

5.3. crnn网络设计

crnn的网络由cnn（卷积层）和rnn（循环层）组合而成，cnn负责图像特征提取、rnn负责文字的序列特征提取。由于项目的字符特性（即共有7个字符，第一个是汉字，第二个是字母，其余是字母和数字），我们是不是可以将rnn网络去除，只保留cnn网络并对cnn进行改进，以达到车牌识别的目的呢？这是笔者在进行这个项目时突然冒出的一个想法，由于时间原因并没有进行验证。这里我们就按照CRNN论文对网络进行构建，以期对crnn网络理解更加深入。

CRNN网络的构建代码：

import torch import torch.nn.functional as F class Vgg_16(torch.nn.Module): def __init__(self): super(Vgg_16, self).__init__() self.convolution1 = torch.nn.Conv2d(1, 64, 3, padding=1) self.pooling1 = torch.nn.MaxPool2d(2, stride=2) self.convolution2 = torch.nn.Conv2d(64, 128, 3, padding=1) self.pooling2 = torch.nn.MaxPool2d(2, stride=2) self.convolution3 = torch.nn.Conv2d(128, 256, 3, padding=1) self.convolution4 = torch.nn.Conv2d(256, 256, 3, padding=1) self.pooling3 = torch.nn.MaxPool2d((1, 2), stride=(2, 1)) # notice stride of the non-square pooling self.convolution5 = torch.nn.Conv2d(256, 512, 3, padding=1) self.BatchNorm1 = torch.nn.BatchNorm2d(512) self.convolution6 = torch.nn.Conv2d(512, 512, 3, padding=1) self.BatchNorm2 = torch.nn.BatchNorm2d(512) self.pooling4 = torch.nn.MaxPool2d((1, 2), stride=(2, 1)) self.convolution7 = torch.nn.Conv2d(512, 512, 2) def forward(self, x): x = F.relu(self.convolution1(x), inplace=True) x = self.pooling1(x) x = F.relu(self.convolution2(x), inplace=True) x = self.pooling2(x) x = F.relu(self.convolution3(x), inplace=True) x = F.relu(self.convolution4(x), inplace=True) x = self.pooling3(x) x = self.convolution5(x) x = F.relu(self.BatchNorm1(x), inplace=True) x = self.convolution6(x) x = F.relu(self.BatchNorm2(x), inplace=True) x = self.pooling4(x) x = F.relu(self.convolution7(x), inplace=True) return x # b*512x1x22 class RNN(torch.nn.Module): def __init__(self, class_num, hidden_unit): super(RNN, self).__init__() self.Bidirectional_LSTM1 = torch.nn.LSTM(512, hidden_unit, bidirectional=True) self.embedding1 = torch.nn.Linear(hidden_unit * 2, 512) self.Bidirectional_LSTM2 = torch.nn.LSTM(512, hidden_unit, bidirectional=True) self.embedding2 = torch.nn.Linear(hidden_unit * 2, class_num) def forward(self, x): x = self.Bidirectional_LSTM1(x) # LSTM output: output, (h_n, c_n) T, b, h = x[0].size() # x[0]: (seq_len, batch, num_directions * hidden_size) x = self.embedding1(x[0].view(T * b, h)) # pytorch view() reshape as [T * b, nOut] x = x.view(T, b, -1) # [22, b, 512] x = self.Bidirectional_LSTM2(x) T, b, h = x[0].size() x = self.embedding2(x[0].view(T * b, h)) x = x.view(T, b, -1) return x # [22,b,class_num] # output: [s,b,class_num] class CRNN(torch.nn.Module): def __init__(self, class_num, hidden_unit=256): super(CRNN, self).__init__() self.cnn = torch.nn.Sequential() self.cnn.add_module('vgg_16', Vgg_16()) self.rnn = torch.nn.Sequential() self.rnn.add_module('rnn', RNN(class_num, hidden_unit)) def forward(self, x): x = self.cnn(x) b, c, h, w = x.size() # print(x.size()) #: b,c,h,w,(64, 512, 1, 22) assert h == 1 # 特征图的高度必须是1 x = x.squeeze(2) # 去除h维度, b *512 * width x = x.permute(2, 0, 1) # [w, b, c] = [seq_len, batch, input_size] # x = x.transpose(0, 2) # x = x.transpose(1, 2) x = self.rnn(x) # print(x.size()) # (22, 64, 67) return x 

5.4. ctc损失函数

ctc损失函数（转录层）是为了解决训练时字符无法对齐的问题。ctc引入blank字符，解决有些位置没有字符的问题；通过递推，快速计算梯度。
pytorch中的ctc损失函数：CTCLoss — PyTorch 2.0 documentation

5.5. 网络的训练

下面我们来crnn+ctc网络的训练，训练过程和普通的cnn网络没有多大的区别。唯一需要注意的是ctc损失函数的构建，这里我建议读者在进行这部分代码阅读前一定要仔细阅读pytorch官方文档的ctc损失函数部分。下面是训练的核心代码：

import argparse import copy import os import lib.alphabets as alphabets import torch import random import numpy as np from lib import dataset, convert from torchvision import transforms from torch.utils.data import DataLoader from net.CRNN_Net import CRNN import torch.optim as optim from tqdm import tqdm import time train_data_path = "./data/CCPD_plate_data/train/train_lmdb" val_data_path = "./data/CCPD_plate_data/val/val_lmdb" weight = "./runs/train/trainbest_weights.pth" def parse_opt(known=False): parser = argparse.ArgumentParser() parser.add_argument('--train_data', type=str, default=train_data_path) parser.add_argument('--val_data', type=str, default=val_data_path) parser.add_argument('--image_size', type=tuple, default=(32, 100)) parser.add_argument('--batch_size', type=int, default=64) parser.add_argument('--epochs', type=int, default=2) parser.add_argument('--alphabet', type=str, default=alphabets.alphabets) parser.add_argument('--project', default='./runs/train/') parser.add_argument('--random_seed', type=int, default=111) parser.add_argument('--using_cuda', type=bool, default=True) parser.add_argument('--num_workers', type=int, default=0) parser.add_argument('--pin_memory', type=bool, default=True) parser.add_argument('--optimizer', type=str, default="RMSprop") parser.add_argument('--lr', type=float, default=0.0001) parser.add_argument('--load_weight', type=bool, default=False) parser.add_argument('--weight_path', type=str, default=weight) opt = parser.parse_known_args()[0] if known else parser.parse_args() return opt def weights_init(m): class_name = m.__class__.__name__ if class_name.find('Conv') != -1: m.weight.data.normal_(0.0, 0.02) elif class_name.find('BatchNorm') != -1: m.weight.data.normal_(1.0, 0.02) m.bias.data.fill_(0) def train_and_eval(model, epochs, loss_func, optimizer, train_loader, val_loader): # 初始化参数 lst = [] t_start = time.time() best_weights = copy.deepcopy(model.state_dict()) best_acc = 0.0 for epoch in range(epochs): logs = "-" * 100 + "\n" # train model.train() running_loss, running_acc = 0.0, 0.0 train_bar = tqdm(train_loader) train_bar.desc = f"第{epoch + 1}次训练，Processing" for inputs, labels in train_bar: logs += "*" * 50 + "\n" inputs = inputs.to(device) # 数据放到device中 optimizer.zero_grad() outputs = model(inputs) # 计算这个batch的损失值 # print(type(labels)) text, text_length = converter.ocr_encode(text=labels) # print(text) # print(text_length) text, text_length = text.to(device), text_length.to(device) # 数据放到device中 outputs_length = torch.full(size=(outputs.size(1),), fill_value=outputs.size(0), device=device, dtype=torch.long) loss = loss_func(outputs, text, outputs_length, text_length) running_loss += loss.item() * outputs.size(1) # 计算这个batch正确识别的字符数 preds_size = torch.IntTensor([outputs.size(0)] * outputs.size(1)) _, preds = outputs.max(2) preds = preds.transpose(1, 0).contiguous().view(-1) # print(preds.view(64, 22)) # print(preds_size) sim_preds = converter.ocr_decode(preds.data, preds_size.data) # print(len(sim_preds), sim_preds) counter, lst = 0, [] for i in labels: lst.append(i.decode("utf-8", "strict")) # print(lst) for pred, target in zip(sim_preds, lst): # print(pred, target) if pred == target: counter += 1 logs += f"target:{lst}\n" logs += f"pred:{sim_preds}\n" logs += "*" * 50 + "\n" running_acc = counter+running_acc # 反向传播 loss.backward() # 参数更新 optimizer.step() # 计算本epoch的损失值和正确率 train_loss = running_loss / len(train_dataset) train_acc = running_acc / len(train_dataset) train_state = f"第{epoch + 1}次训练，train_loss:{train_loss:.6f}, train_acc:{train_acc:.6f}\n" logs += train_state # eval model.eval() running_loss, running_acc = 0.0, 0.0 with torch.no_grad(): eval_bar = tqdm(val_loader) eval_bar.desc = f"第{epoch + 1}次评估，Processing" for inputs, labels in eval_bar: inputs = inputs.to(device) outputs = model(inputs).to(device) # 计算这个batch的损失值 text, text_length = converter.ocr_encode(text=labels) text, text_length = text.to(device), text_length.to(device) # 数据放到device中 outputs_length = torch.full(size=(outputs.size(1),), fill_value=outputs.size(0), device=device, dtype=torch.long) loss = loss_func(outputs, text, outputs_length, text_length) running_loss += loss.item() * outputs.size(1) # 计算这个batch正确识别的字符数 preds_size = torch.IntTensor([outputs.size(0)] * outputs.size(1)) _, preds = outputs.max(2) preds = preds.transpose(1, 0).contiguous().view(-1) sim_preds = converter.ocr_decode(preds.data, preds_size.data) counter, lst = 0, [] for i in labels: lst.append(i.decode("utf-8", "strict")) for pred, target in zip(sim_preds, lst): if pred == target: counter += 1 running_acc = counter+running_acc # 计算本epoch的损失值和正确率 val_loss = running_loss / len(val_dataset) val_acc = running_acc / len(val_dataset) val_state = f"第{epoch + 1}次评估，val_loss:{val_loss:.6f}, val_acc:{val_acc:.6f}\n" logs += val_state logs += "-" * 100 + "\n" print(logs) lst.append(logs) if val_acc > best_acc: best_acc = val_acc best_weights = copy.deepcopy(model.state_dict()) t_end = time.time() total_time = t_end - t_start result = f"{epochs}次训练与评估共计用时{total_time // 60:.0f}m{total_time % 60:.0f}s\n最高正确率是{best_acc:.6f}" print(result) lst.append(result) # 加载最佳的模型权重 model.load_state_dict(best_weights) return model, lst if __name__ == "__main__": opt = parse_opt() print(type(opt.train_data)) if not os.path.exists(opt.project): os.makedirs(opt.project) print(opt.epochs) if torch.cuda.is_available() and opt.using_cuda: device = torch.device('cuda:0') # torch.backends.cudnn.deterministic = True print("使用单个gpu进行训练") else: device = torch.device('cpu') print("使用cpu进行训练") # 随机种子 random.seed(opt.random_seed) np.random.seed(opt.random_seed) torch.manual_seed(opt.random_seed) # 数据增强 transformer = {"train": transforms.Compose([transforms.Resize((32, 100)), transforms.ToTensor(), transforms.Normalize(0.403, 0.154)]), "val": transforms.Compose([transforms.Resize((32, 100)), transforms.ToTensor(), transforms.Normalize(0.387, 0.612)])} # 制作数据集 train_dataset = dataset.LmdbDataset(root=opt.train_data, transform=transformer["train"]) train_loader = DataLoader(train_dataset, batch_size=opt.batch_size, shuffle=True, num_workers=opt.num_workers, pin_memory=opt.pin_memory) val_dataset = dataset.LmdbDataset(root=opt.val_data, transform=transformer["val"]) val_loader = DataLoader(val_dataset, batch_size=opt.batch_size, shuffle=True, num_workers=opt.num_workers, pin_memory=opt.pin_memory) n_class = len(opt.alphabet) + 1 print(f"字母表的长度是{n_class}") # 包含blank # 字符与标签转换器 converter = convert.StrLabelConverter(opt.alphabet) # crnn网络 net = CRNN(n_class) net.apply(weights_init) net = net.to(device) if opt.load_weight: net.load_state_dict(torch.load(opt.weight_path, map_location=device)) print(net) # ctc损失函数 ctc = torch.nn.CTCLoss() # 优化器 if opt.optimizer == "RMSprop": optimizer = optim.RMSprop(net.parameters(), lr=opt.lr) elif opt.optimizer == "Adadelta": optimizer = optim.Adadelta(net.parameters(), lr=opt.lr) elif opt.optimizer == "Adam": optimizer = optim.Adam(net.parameters(), lr=opt.lr) # 训练和评估 best_model, log = train_and_eval(net, opt.epochs, ctc, optimizer, train_loader, val_loader) best_weights = best_model.state_dict() torch.save(best_weights, opt.project + "best_weights.pth") with open(opt.project + "logs.txt", "w") as f: for i in log: f.write(i) 

6. 模型推理部分

由于在检测部分使用的是yolov5，而yolov5拥有一套完整的代码，因此我们可以在yolov5的.detect基础上调整得到需要的推理代码。下面是推理的核心代码：

import argparse import os import sys from pathlib import Path import numpy as np import cv2 import torch import torch.backends.cudnn as cudnn FILE = Path(__file__).resolve() ROOT = FILE.parents[0] # YOLOv5 root directory if str(ROOT) not in sys.path: sys.path.append(str(ROOT)) # add ROOT to PATH ROOT = Path(os.path.relpath(ROOT, Path.cwd())) # relative from torchvision import transforms from my_utils import correction, box_label, Annotator from crnn_ctc.net import CRNN_Net as ocr_net from crnn_ctc.lib import convert, alphabets from yolov5.utils.augmentations import letterbox from yolov5.models.common import DetectMultiBackend from yolov5.utils.datasets import IMG_FORMATS, VID_FORMATS, LoadImages, LoadStreams from yolov5.utils.general import (LOGGER, check_file, check_img_size, check_imshow, check_requirements, colorstr, increment_path, non_max_suppression, print_args, scale_coords, strip_optimizer, xyxy2xywh) from yolov5.utils.torch_utils import select_device, time_sync @torch.no_grad() def run(weights_vehicle=ROOT / 'weights/vehicle_yolov5s.pt', weights_ccpd=ROOT / 'weights/ccpd_yolov5s.pt', weights_plate=ROOT / 'weights/plate_crnn.pth', source=ROOT / 'test/images', # file/dir/URL/glob, 0 for webcam data=ROOT / 'test/coco128.yaml', # dataset.yaml path imgsz=(640, 640), # inference size (height, width) conf_thres=0.25, # confidence threshold iou_thres=0.45, # NMS IOU threshold max_det=1000, # maximum detections per image device='', # cuda device, i.e. 0 or 0,1,2,3 or cpu save_txt=False, # save results to *.txt save_img=True, classes=None, # filter by class: --class 0, or --class 0 2 3 agnostic_nms=False, # class-agnostic NMS augment=False, # augmented inference visualize=False, # visualize features project=ROOT / 'test/runs', # save results to project/name name='exp', # save results to project/name exist_ok=False, # existing project/name ok, do not increment half=False, # use FP16 half-precision inference dnn=False, # use OpenCV DNN for ONNX inference ): source = str(source) is_file = Path(source).suffix[1:] in (IMG_FORMATS + VID_FORMATS) is_url = source.lower().startswith(('rtsp://', 'rtmp://', 'http://', 'https://')) webcam = source.isnumeric() or source.endswith('.txt') or (is_url and not is_file) if is_url and is_file: source = check_file(source) # download # Directories save_dir = increment_path(Path(project) / name, exist_ok=exist_ok) # increment run (save_dir / 'labels' if save_txt else save_dir).mkdir(parents=True, exist_ok=True) # make dir # 加载vehicle模型 device = select_device(device) model = DetectMultiBackend(weights_vehicle, device=device, dnn=dnn, data=data) stride, names, pt, jit, onnx, engine = model.stride, model.names, model.pt, model.jit, model.onnx, model.engine imgsz = check_img_size(imgsz, s=stride) # check image size # 加载ccpd模型 model_ccpd = DetectMultiBackend(weights_ccpd, device=device, dnn=dnn, data=data) # 加载ocr模型 model_ocr = ocr_net.CRNN(class_num=67) model_ocr.load_state_dict(torch.load(weights_plate, map_location=device)) model_ocr.eval() # Half half &= (pt or jit or onnx or engine) and device.type != 'cpu' # FP16 supported on limited backends with CUDA if pt or jit: model.model.half() if half else model.model.float() # Dataloader if webcam: cudnn.benchmark = True # set True to speed up constant image size inference dataset = LoadStreams(source, img_size=imgsz, stride=stride, auto=pt) bs = len(dataset) # batch_size else: dataset = LoadImages(source, img_size=imgsz, stride=stride, auto=pt) bs = 1 # batch_size vid_path, vid_writer = [None] * bs, [None] * bs # 开始推理 model.warmup(imgsz=(1 if pt else bs, 3, *imgsz), half=half) # warmup model_ccpd.warmup(imgsz=(1, 3, 320, 320), half=half) dt, seen = [0.0, 0.0, 0.0], 0 # 七种边界框的颜色，六类车辆、一类车牌 np.random.seed(1) colors = np.random.randint(0, 255, size=(len(names)+1, 3)) for path, im, im0s, vid_cap, s in dataset: t1 = time_sync() im = torch.from_numpy(im).to(device) im = im.half() if half else im.float() # uint8 to fp16/32 im /= 255 # 0 - 255 to 0.0 - 1.0 if len(im.shape) == 3: im = im[None] # expand for batch dim t2 = time_sync() dt[0] += t2 - t1 # Inference visualize = increment_path(save_dir / Path(path).stem, mkdir=True) if visualize else False pred = model(im, augment=augment, visualize=visualize) t3 = time_sync() dt[1] += t3 - t2 # NMS pred = non_max_suppression(pred, conf_thres, iou_thres, classes, agnostic_nms, max_det=max_det) dt[2] += time_sync() - t3 for i, det in enumerate(pred): # 每张图片 seen += 1 if webcam: # batch_size >= 1 p, im0, frame = path[i], im0s[i].copy(), dataset.count s += f'{i}: ' else: p, im0, frame = path, im0s.copy(), getattr(dataset, 'frame', 0) p = Path(p) # to Path save_path = str(save_dir / p.name) # im.jpg s += '%gx%g ' % im.shape[2:] # print string annotator = Annotator(im0, line_width=3, pil=True, example=str(names)) if len(det): # Rescale boxes from img_size to im0 size det[:, :4] = scale_coords(im.shape[2:], det[:, :4], im0.shape).round() # Print results for c in det[:, -1].unique(): n = (det[:, -1] == c).sum() # detections per class s += f"{n} {names[int(c)]}{'s' * (n > 1)}, " # add to string # Write results for *xyxy, conf, cls in reversed(det): # 在图片中检测到的车辆边界框 pt1 = (int(xyxy[0]), int(xyxy[1])) pt2 = (int(xyxy[2]), int(xyxy[3])) # 截取锚框内的图像，源图像的拷贝是im0，锚框左上坐标是pt1，右下坐标是pt2 im0_vehicle = im0[pt1[1]:pt2[1], pt1[0]:pt2[0]] im_vehicle = letterbox(im0_vehicle, new_shape=(320, 320))[0] im_vehicle = im_vehicle.transpose((2, 0, 1))[::-1] # HWC to CHW, BGR to RGB im_vehicle = np.ascontiguousarray(im_vehicle) im_vehicle = torch.from_numpy(im_vehicle).to(device) im_vehicle = im_vehicle.half() if half else im_vehicle.float() # uint8 to fp16/32 im_vehicle /= 255 # 0 - 255 to 0.0 - 1.0 if len(im_vehicle.shape) == 3: im_vehicle = im_vehicle[None] # expand for batch dim pred_ccpd = model_ccpd(im_vehicle, augment=augment, visualize=visualize) pred_ccpd = non_max_suppression(pred_ccpd, conf_thres, iou_thres, classes, agnostic_nms, max_det=max_det) for ii, det_ccpd in enumerate(pred_ccpd): # 每个车牌 if len(det_ccpd): # Rescale boxes from 320*320 to im0_vehicle size det_ccpd[:, :4] = scale_coords(im_vehicle.shape[2:], det_ccpd[:, :4], im0_vehicle.shape).round() # Write results for *xyxy, conf, clss in reversed(det_ccpd): # 每个车牌的边界框 pt11 = (int(xyxy[0]), int(xyxy[1])) pt22 = (int(xyxy[2]), int(xyxy[3])) # 截取且矫正车牌 im0_plate = im0_vehicle[pt11[1]:pt22[1], pt11[0]:pt22[0]] # im0_plate = correction(im0_plate) # 图像灰度化且转为张量 im0_plate = cv2.cvtColor(im0_plate, cv2.COLOR_BGR2GRAY) im0_plate = cv2.resize(im0_plate, (100, 32)) im0_plate = transforms.ToTensor()(im0_plate).to(device) im0_plate = im0_plate.view(1, 1, 32, 100) result = model_ocr(im0_plate) converter = convert.StrLabelConverter(alphabets.alphabets) preds_size = torch.IntTensor([result.size(0)] * result.size(1)) _, preds = result.max(2) preds = preds.transpose(1, 0).contiguous().view(-1) plate = converter.ocr_decode(preds.data, preds_size.data) # plate标签、ccpd边界框在源图中的 坐标 color = colors[6] target = str(plate) pt1_ccpd, pt2_ccpd = (pt1[0] + pt11[0], pt1[1] + pt11[1]), ( pt1[0] + pt22[0], pt1[1] + pt22[1]) # 可视化 annotator.box_label(pt1_ccpd+pt2_ccpd, target, color=tuple(color)) # vehicle标签、边界框坐标 c = int(cls) color = colors[c] label = f'{names[c]} {conf:.2f}' pt1_vehicle, pt2_vehicle = pt1, pt2 annotator.box_label(pt1_vehicle + pt2_vehicle, label, color=tuple(color)) # 保存每一张测试结果 im0 = annotator.result() if save_img: # cv2.imshow("111", im0) # cv2.waitKey() # cv2.destroyAllWindows() if dataset.mode == 'image': cv2.imwrite(save_path, im0) else: # 'video' or 'stream' if vid_path[i] != save_path: # new video vid_path[i] = save_path if isinstance(vid_writer[i], cv2.VideoWriter): vid_writer[i].release() # release previous video writer if vid_cap: # video fps = vid_cap.get(cv2.CAP_PROP_FPS) w = int(vid_cap.get(cv2.CAP_PROP_FRAME_WIDTH)) h = int(vid_cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) else: # stream fps, w, h = 30, im0.shape[1], im0.shape[0] save_path = str(Path(save_path).with_suffix('.mp4')) # force *.mp4 suffix on results videos vid_writer[i] = cv2.VideoWriter(save_path, cv2.VideoWriter_fourcc(*'mp4v'), fps, (w, h)) vid_writer[i].write(im0) # Print time (inference-only) LOGGER.info(f'{s}Done. ({t3 - t2:.3f}s)') # Print results t = tuple(x / seen * 1E3 for x in dt) # speeds per image LOGGER.info( f'Speed: %.1fms pre-process, %.1fms inference, %.1fms NMS per image at shape {(1, 3, *imgsz)}' % t) def parse_opt(): parser = argparse.ArgumentParser() parser.add_argument('--weights_vehicle', nargs='+', type=str, default=ROOT / 'weights/vehicle_yolov5s.pt', help='model path(s)') parser.add_argument('--weights_ccpd', nargs='+', type=str, default=ROOT / 'weights/ccpd_yolov5s.pt', help='model path(s)') parser.add_argument('--weights_plate', nargs='+', type=str, default=ROOT / 'weights/plate_crnn.pth', help='model path(s)') parser.add_argument('--source', type=str, default=ROOT / 'test/video', help='file/dir/URL/glob, 0 for webcam') parser.add_argument('--data', type=str, default=ROOT / 'test/coco128.yaml', help='(optional) dataset.yaml path') parser.add_argument('--imgsz', '--img', '--img-size', nargs='+', type=int, default=[640], help='inference size h,w') parser.add_argument('--conf-thres', type=float, default=0.25, help='confidence threshold') parser.add_argument('--iou-thres', type=float, default=0.45, help='NMS IoU threshold') parser.add_argument('--max-det', type=int, default=1000, help='maximum detections per image') parser.add_argument('--device', default='', help='cuda device, i.e. 0 or 0,1,2,3 or cpu') parser.add_argument('--save-txt', action='store_true', help='save results to *.txt') parser.add_argument('--classes', nargs='+', type=int, help='filter by class: --classes 0, or --classes 0 2 3') parser.add_argument('--agnostic-nms', action='store_true', help='class-agnostic NMS') parser.add_argument('--augment', action='store_true', help='augmented inference') parser.add_argument('--visualize', action='store_true', help='visualize features') parser.add_argument('--project', default=ROOT / 'runs/detect', help='save results to project/name') parser.add_argument('--name', default='exp', help='save results to project/name') parser.add_argument('--exist-ok', action='store_true', help='existing project/name ok, do not increment') parser.add_argument('--half', action='store_true', help='use FP16 half-precision inference') parser.add_argument('--dnn', action='store_true', help='use OpenCV DNN for ONNX inference') opt = parser.parse_args() opt.imgsz *= 2 if len(opt.imgsz) == 1 else 1 # expand return opt def main(opt): check_requirements(exclude=('tensorboard', 'thop')) return run(**vars(opt)) if __name__ == "__main__": opt = parse_opt() points = main(opt) 

7. 效果展示与项目总结

7.1. 效果展示

图片

项目总结

由于1）收集的数据集较为单一，如车辆检测仅有俯瞰正视角度、车牌检测无双层牌照图片、车牌识别80%以上是安徽牌照；2）场景不够丰富，如车辆检测中最多也才有三四辆车、天气、地理环境等单一；3）数据集体量小。以上原因导致模型的鲁棒性较差，只有在监控视角、车辆较少、且车辆是正视角度才能达到理想效果，其他场景下较为拉跨。
本次项目由于数据集的原因导致成果十分不理想，建议读者重新寻找合适的数据集进行实战！
以上是本次车牌识别实战的简单记录，如果本项目对您能有所启发，不要忘了点赞哦！

为帮助更多对人工智能感兴趣的小伙伴们能够有效的系统性的学习以及论文的研究，小编特意制作整理了一份人工智能学习资料给大家，整理了很久，非常全面。

大致内容包括一些人工智能基础入门视频和文档+AI常用框架实战视频、计算机视觉、机器学习、图像识别、NLP、OpenCV、YOLO、pytorch、深度学习与神经网络等学习资料、课件源码、国内外知名精华资源、以及AI热门论文等全套学习资料。

需要以上这些文中提到的资料，请先关注作者头条【AI乔治】，回复【666】，即可免费获取~~~~

每一个专栏都是大家非常关心，和非常有价值的话题，如果我的文章对你有所帮助，还请帮忙点赞、好评、转发一下，你的支持会激励我输出更高质量的文章，非常感谢！