草庐IT

深度学习实战之手写签名识别（100%准确率、语音播报）

陶陶name 2023-03-28 原文
手写签名在日常生活中随处可见，简单来说就是亲笔书写自己的名字，在纸质文档上使用手写签名主要用以确定签字者的身份，并表示签字者同意所签署文档中规定的内容，对文档的真实性负责，且具有法律效力。由此看见手写签名的重要性。在现实的生活中不乏有不法分子模仿其他人的字体，进而模仿他人的签名获得不发的利益。尽管会有鉴别字体的工作，但在鉴别时不仅不准确，而且还十分的消耗人力以及财力。为了解决这一客观显示存在的问题，笔者结合着人工智能的思想和并使用计算机视觉技术对手写签名进行训练，得到了高达100%的训练准确率。并将训练模型进行优化后运用实现了一套手写签名识别系统。

1.开发环境

笔者的开发环境如下，大家可以参考进行配置

  • python3.6或python3.7
  • pytorch1.0.1
  • torchvision 0.2.2.post3
  • visom
  • ubuntu16.04和windows10

2. 准备阶段

在完成了上述的环境搭建后，即可进入到准备阶段了。这里准备的有数据集的准备、以及相关代码的主备。

  • 数据集的准备
笔者这里的数据集是自己准备的，收集了六个人的手写签名，约4500张签名图片


  • 数据集的划分
笔者这里将数据集进行六分类的划分，每一类约有750张图片
数据集划分为训练数据、验证数据、测试数据
其中训练数据、验证数据、测试数据的具体划分如下图所示


  • 载入数据
在上述的步骤中已经准备好了相应的数据集，同时也划分好了训练数据、验证数据、测试数据的部分。在完成了理论的设计后，该怎么使用代码对数据进行划分呢，代码如下所示

class Data(Dataset):
def __init__(self,root,resize,mode):
super(Data,self).__init__()
# 保存参数
self.root=root
self.resize=resize
# 给每一个类做映射
self.name2label={} # "daj":0 ,"hjj":1……
for name in sorted(os.listdir(os.path.join(root))):
# 过滤掉文件夹
if not os.path.isdir(os.path.join(root,name)):
continue
# 保存在表中;将最长的映射作为最新的元素的label的值
self.name2label[name]=len(self.name2label.keys())
# print(self.name2label)
# 加载文件
self.images,self.labels=self.load_csv('images.csv')
# 裁剪数据
if mode=='train':
self.images=self.images[:int(0.6*len(self.images))] # 将数据集的60%设置为训练数据集合
self.labels=self.labels[:int(0.6*len(self.labels))] # label的60%分配给训练数据集合
elif mode=='val':
self.images = self.images[int(0.6 * len(self.images)):int(0.8 * len(self.images))] # 从60%-80%的地方
self.labels = self.labels[int(0.6 * len(self.labels)):int(0.8 * len(self.labels))]
else:
self.images = self.images[int(0.8 * len(self.images)):] # 从80%的地方到最末尾
self.labels = self.labels[int(0.8 * len(self.labels)):]
# image+label 的路径
在使用上述的代码后即可将已有的数据集的60%划分为训练数据、20%划分为验证数据、20%划分为测试数据。
# 3. 训练阶段
在完成了上述的操作后，即可进入到训练阶段。这里笔者使用的是比较经典的神经网络结构--ResNet.
由何凯明团队所提出来的。其深度残差网络（Deep Residual Network）在2015年的ImageNet上取得冠军。具体网络的特点，读者可自行Google了解，这里笔者就不再赘述。

  • 搭建ResNet网络结构
搭建的网络结构代码如下：

class ResBlk(nn.Module):

def __init__(self, ch_in, ch_out, stride=1):
super(ResBlk, self).__init__()

self.conv1 = nn.Conv2d(ch_in, ch_out, kernel_size=3, stride=stride, padding=1)
self.bn1 = nn.BatchNorm2d(ch_out)
self.conv2 = nn.Conv2d(ch_out, ch_out, kernel_size=3, stride=1, padding=1)
self.bn2 = nn.BatchNorm2d(ch_out)

self.extra = nn.Sequential()
if ch_out != ch_in:
# [b, ch_in, h, w] => [b, ch_out, h, w]
self.extra = nn.Sequential(
nn.Conv2d(ch_in, ch_out, kernel_size=1, stride=stride),
nn.BatchNorm2d(ch_out)
)


def forward(self, x):
out = F.relu(self.bn1(self.conv1(x)))
out = self.bn2(self.conv2(out))
# short cut.
# extra module: [b, ch_in, h, w] => [b, ch_out, h, w]
# element-wise add:
out = self.extra(x) + out
out = F.relu(out)

return out

class ResNet18(nn.Module):

def __init__(self, num_class):
super(ResNet18, self).__init__()

self.conv1 = nn.Sequential(
nn.Conv2d(3, 16, kernel_size=3, stride=3, padding=0),
nn.BatchNorm2d(16)
)
# followed 4 blocks
# [b, 16, h, w] => [b, 32, h ,w]
self.blk1 = ResBlk(16, 32, stride=3)
# [b, 32, h, w] => [b, 64, h, w]
self.blk2 = ResBlk(32, 64, stride=3)
# # [b, 64, h, w] => [b, 128, h, w]
self.blk3 = ResBlk(64, 128, stride=2)
# # [b, 128, h, w] => [b, 256, h, w]
self.blk4 = ResBlk(128, 256, stride=2)

# [b, 256, 7, 7]
self.outlayer = nn.Linear(256*3*3, num_class)

def forward(self, x):
x = F.relu(self.conv1(x))

# [b, 64, h, w] => [b, 1024, h, w]
x = self.blk1(x)
x = self.blk2(x)
x = self.blk3(x)
x = self.blk4(x)
# print(x.shape)
x = x.view(x.size(0), -1)
x = self.outlayer(x)

return x

def main():
blk = ResBlk(64, 128)
tmp = torch.randn(2, 64, 224, 224)
out = blk(tmp)
print('block:', out.shape)


model = ResNet18(5)
tmp = torch.randn(2, 3, 224, 224)
out = model(tmp)
print('resnet:', out.shape)

p = sum(map(lambda p:p.numel(), model.parameters()))
print('parameters size:', p)


if __name__ == '__main__':
main()
  • 训练
在完成了网络的搭建后，即可对数据进行训练。
笔者这里设置如下
batchsz=128
lr = 1e-3
epochs = 10

batchsz = 128
lr = 1e-3
epochs = 10

device = torch.device('cuda')
train_db = Data('train_data', 224, mode='train')
val_db = Data('train_data', 224, mode='val')
test_db = Data('train_data', 224, mode='test')
train_loader = DataLoader(train_db, batch_size=batchsz, shuffle=True,
num_workers=4)
val_loader = DataLoader(val_db, batch_size=batchsz, num_workers=4)
test_loader = DataLoader(test_db, batch_size=batchsz, num_workers=4)
viz = visdom.Visdom()

def evalute(model, loader):
model.eval()
correct = 0
total = len(loader.dataset)

for x, y in loader:
x, y = x.to(device), y.to(device)
with torch.no_grad():
logits = model(x)
pred = logits.argmax(dim=1)
correct += torch.eq(pred, y).sum().float().item()

return correct / total


def main():

model = ResNet18(6).to(device)
optimizer = optim.Adam(model.parameters(), lr=lr)
criteon = nn.CrossEntropyLoss()

best_acc, best_epoch = 0, 0
global_step = 0
viz.line([0], [-1], win='loss', opts=dict(title='loss'))
viz.line([0], [-1], win='val_acc', opts=dict(title='val_acc'))
for epoch in range(epochs):

if epoch % 1 == 0:
print('第 '+str(epoch+1)+' training……')
val_acc = evalute(model, val_loader)
if val_acc > best_acc:
best_epoch = epoch
best_acc = val_acc
torch.save(model.state_dict(), 'best.mdl')
viz.line([val_acc], [global_step], win='val_acc', update='append')

print('最好的准确率:', best_acc, '最好的批次:', best_epoch)

model.load_state_dict(torch.load('best.mdl'))
print('正在加载模型……')

test_acc = evalute(model, test_loader)
print('测试准确率:', test_acc)

if __name__ == '__main__':
main()
训练可视化结果如下：

这里也许读者会想有没有过拟合呢？？

可以看到，也没有出现过拟合的问题。

4. 模型使用及系统实现

将训练获得的训练模型装载，并系统的使用其进行签名的识别。
这里笔者结合着计算机视觉常用的库opencv进行使用模型。
同时笔者为了能够更加符合日常的使用，这里笔者将opencv显示进行了中文化。
其代码如下：

def prediect(img_path):
net=torch.load('model.pkl')
net=net.to(device)
torch.no_grad()
img=Image.open(img_path)
img=transform(img).unsqueeze(0)
img_ = img.to(device)
outputs = net(img_)
_, predicted = torch.max(outputs, 1)
print(classes[predicted[0]])

begin = Speak()
begin.speak(str(classes[predicted[0]]))

img = cv2.imread(img_path) # 如想读取中文名称的图片文件可用cv2.imdecode()
pil_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) # cv2和PIL中颜色的hex码的储存顺序不同，需转RGB模式
pilimg = Image.fromarray(pil_img) # Image.fromarray()将数组类型转成图片格式，与np.array()相反
draw = ImageDraw.Draw(pilimg) # PIL图片上打印汉字
font = ImageFont.truetype("simhei.ttf", 20,
encoding="utf-8") # 参数1：字体文件路径，参数2：字体大小
draw.text((0, 0), classes[predicted[0]], (255, 0, 0), font=font)
img = cv2.cvtColor(np.array(pilimg), cv2.COLOR_RGB2BGR) # 将图片转成cv2.imshow()可以显示的数组格式
cv2.imshow("show", img)
if cv2.waitKey(0)==ord(' '):
cv2.destroyAllWindows()
并使用系统进行实际的手写签名识别，其结果图下

同时在识别完成后，系统还会自动的将识别结果以语音的形式播报出来。

你听：澜江全 、狄爱景、陆春宇、王雅君……

最后申明：由于笔者知识水平有限，在问题描述上难免会有不准确的地方，还请大家谅解。希望大家多动手实践，共同进步。如若在实践的过程中出现问题，可以私信交流。


准确率手写paddingspanpadding-box数据ide数据集深度学习人工智能私藏项目实操分享

有关深度学习实战之手写签名识别（100%准确率、语音播报）的更多相关文章

  1. LC滤波器设计学习笔记（一）滤波电路入门 - 2

    目录前言滤波电路科普主要分类实际情况单位的概念常用评价参数函数型滤波器简单分析滤波电路构成低通滤波器RC低通滤波器RL低通滤波器高通滤波器RC高通滤波器RL高通滤波器部分摘自《LC滤波器设计与制作》，侵权删。前言最近需要学习放大电路和滤波电路，但是由于只在之前做音乐频谱分析仪的时候简单了解过一点点运放，所以也是相当从零开始学习了。滤波电路科普主要分类滤波器：主要是从不同频率的成分中提取出特定频率的信号。有源滤波器：由RC元件与运算放大器组成的滤波器。可滤除某一次或多次谐波，最普通易于采用的无源滤波器结构是将电感与电容串联，可对主要次谐波（3、5、7）构成低阻抗旁路。无源滤波器：无源滤波器，又称

  2. CAN协议的学习与理解 - 2

    最近在学习CAN，记录一下，也供大家参考交流。推荐几个我觉得很好的CAN学习，本文也是在看了他们的好文之后做的笔记首先是瑞萨的CAN入门，真的通透；秀！靠这篇我竟然2天理解了CAN协议！实战STM32F4CAN！原文链接：https://blog.csdn.net/XiaoXiaoPengBo/article/details/116206252CAN详解（小白教程）原文链接：https://blog.csdn.net/xwwwj/article/details/105372234一篇易懂的CAN通讯协议指南1一篇易懂的CAN通讯协议指南1-知乎(zhihu.com)视频推荐CAN总线个人知识总

  3. 深度学习部署：Windows安装pycocotools报错解决方法 - 2

    深度学习部署：Windows安装pycocotools报错解决方法1.pycocotools库的简介2.pycocotools安装的坑3.解决办法更多Ai资讯：公主号AiCharm本系列是作者在跑一些深度学习实例时，遇到的各种各样的问题及解决办法，希望能够帮助到大家。ERROR:Commanderroredoutwithexitstatus1:'D:\Anaconda3\python.exe'-u-c'importsys,setuptools,tokenize;sys.argv[0]='"'"'C:\\Users\\46653\\AppData\\Local\\Temp\\pip-instal

  4. 微信小程序开发入门与实战（Behaviors使用） - 2

    @作者:SYFStrive @博客首页:HomePage📜：微信小程序📌：个人社区（欢迎大佬们加入）👉：社区链接🔗📌：觉得文章不错可以点点关注👉：专栏连接🔗💃：感谢支持,学累了可以先看小段由小胖给大家带来的街舞👉微信小程序（🔥）目录自定义组件-behaviors    1、什么是behaviors    2、behaviors的工作方式    3、创建behavior    4、导入并使用behavior    5、behavior中所有可用的节点    6、同名字段的覆盖和组合规则总结最后自定义组件-behaviors    1、什么是behaviorsbehaviors是小程序中，用于实现

  5. ruby - 我正在学习编程并选择了 Ruby。我应该升级到 Ruby 1.9 吗？ - 2

    我完全不是程序员，正在学习使用Ruby和Rails框架进行编程。我目前正在使用Ruby1.8.7和Rails3.0.3，但我想知道我是否应该升级到Ruby1.9，因为我真的没有任何升级的“遗留”成本。缺点是什么？我是否会遇到与普通gem的兼容性问题，或者甚至其他我不太了解甚至无法预料的问题？ 最佳答案 你应该升级。不要坚持从1.8.7开始。如果您发现不支持1.9.2的gem，请避免使用它们(因为它们很可能不被维护)。如果您对gem是否兼容1.9.2有任何疑问，您可以在以下位置查看:http://www.railsplugins.or

  6. ruby - 我如何学习 ruby​​ 的正则表达式？ - 2

    如何学习ruby​​的正则表达式？(对于假人) 最佳答案 http://www.rubular.com/在Ruby中使用正则表达式时是一个很棒的工具，因为它可以立即将结果可视化。 关于ruby-我如何学习ruby​​的正则表达式？，我们在StackOverflow上找到一个类似的问题： https://stackoverflow.com/questions/1881231/

  7. 深度学习12. CNN经典网络 VGG16 - 2

    深度学习12.CNN经典网络VGG16一、简介1.VGG来源2.VGG分类3.不同模型的参数数量4.3x3卷积核的好处5.关于学习率调度6.批归一化二、VGG16层分析1.层划分2.参数展开过程图解3.参数传递示例4.VGG16各层参数数量三、代码分析1.VGG16模型定义2.训练3.测试一、简介1.VGG来源VGG（VisualGeometryGroup）是一个视觉几何组在2014年提出的深度卷积神经网络架构。VGG在2014年ImageNet图像分类竞赛亚军，定位竞赛冠军；VGG网络采用连续的小卷积核（3x3）和池化层构建深度神经网络，网络深度可以达到16层或19层，其中VGG16和VGG

  8. 机器学习——时间序列ARIMA模型(四)：自相关函数ACF和偏自相关函数PACF用于判断ARIMA模型中p、q参数取值 - 2

    文章目录1、自相关函数ACF2、偏自相关函数PACF3、ARIMA(p,d,q)的阶数判断4、代码实现1、引入所需依赖2、数据读取与处理3、一阶差分与绘图4、ACF5、PACF1、自相关函数ACF自相关函数反映了同一序列在不同时序的取值之间的相关性。公式：ACF(k)=ρk=Cov(yt,yt−k)Var(yt)ACF(k)=\rho_{k}=\frac{Cov(y_{t},y_{t-k})}{Var(y_{t})}ACF(k)=ρk​=Var(yt​)Cov(yt​,yt−k​)​其中分子用于求协方差矩阵，分母用于计算样本方差。求出的ACF值为[-1,1]。但对于一个平稳的AR模型，求出其滞

  9. Unity Shader 学习笔记（5）Shader变体、Shader属性定义技巧、自定义材质面板 - 2

    写在之前Shader变体、Shader属性定义技巧、自定义材质面板，这三个知识点任何一个单拿出来都是一套知识体系，不能一概而论，本文章目的在于将学习和实际工作中遇见的问题进行总结，类似于网络笔记之用，方便后续回顾查看，如有以偏概全、不祥不尽之处，还望海涵。1、Shader变体先看一段代码......Properties{ [KeywordEnum(on,off)]USL_USE_COL("IsUseColorMixTex?",int)=0 [Toggle(IS_RED_ON)]_IsRed("IsRed?",int)=0}......//中间省略，后续会有完整代码 #pragmamulti_c

  10. ruby-on-rails - 这个 C 和 PHP 程序员如何学习 Ruby 和 Rails？ - 2

    按照目前的情况，这个问题不适合我们的问答形式。我们希望答案得到事实、引用或专业知识的支持，但这个问题可能会引发辩论、争论、投票或扩展讨论。如果您觉得这个问题可以改进并可能重新打开，visitthehelpcenter指导。关闭9年前。我来自C、php和bash背景，很容易学习，因为它们都有相同的C结构，我可以将其与我已经知道的联系起来。然后2年前我学了Python并且学得很好，Python对我来说比Ruby更容易学。然后从去年开始，我一直在尝试学习Ruby，然后是Rails，我承认，直到现在我还是学不会，讽刺的是那些打着简单易学的烙印，但是对于我这样一个老练的程序员来说，我只是无法将它

随机推荐