[人工智能]识别四位纯数字的卷积神经网络（精确率可达100%）

#本人正好在学习图像识别，正好借这个机会，写一个四位纯数字的验证码识别模型，供一起学习的小伙伴参考。
#源码如下（有详细的标注，如有不懂，请在下方评论区留言；数据集用的是接近1W张的纯四位数验证码图片，如有需要，请在下方留言）：

import tensorflow as tf
import numpy as np
import cv2
import os
import random


#图片的文件夹路径
images_dir=r"captcha/images2/"
images_files=os.listdir(images_dir)

#返回one_hot编码
def one_hot_encode(text):
    zeros=np.zeros([40])
    for i,j in enumerate(text):
        k=ord(j)#返回字符串对应的十进制整数
        if k<48 or k>57:
            raise ValueError("字符不匹配")
        k=k-48
        zeros[i*10+k]=1
    return zeros

#返回一对图片和one_hot标签
def return_a_couple_image_label(images_dir,images_files):
    file=random.choice(images_files)
    image=os.path.join(images_dir,file)
    image=cv2.imread(image,cv2.IMREAD_GRAYSCALE)#将文件进行读取并且转化成灰度图
    image=np.reshape(image,[24,72])
    result=np.zeros([24,72],dtype=np.float32)#一定要进行指定类型，否则会类型不匹配，会出现bug
    
    #代码的重中之重，可以尝试着去掉这行代码，看看有啥差别！！！可以使模型的大大优化，降低训练的时间，提高精度
    #同样，类型一定得指定，因为图片的原始数据是32位，零矩阵也是32位，dtype得用32位来指定
    #归一化，将image的数据迁移到[4,10]的这个零矩阵里来，范围指定0-1之间
    cv2.normalize(image,result,0,1,cv2.NORM_MINMAX,dtype=cv2.CV_32F)
    
    label1=file[0:4]
    label=one_hot_encode(label1)
    return result,label

#返回一个批次的图片和标签
def return_batch_image_label(batch_size,images_dir,images_files):
    images_list=[]
    labels_list=[]
    for i in range(batch_size):
        image,label=return_a_couple_image_label(images_dir,images_files)
        images_list.append(image)
        labels_list.append(label)
        
    return np.array(images_list),np.array(labels_list)
    
#将一个批次的one_hot标签转文本
def return_text(one_hot_label_list):
    total_labels_list=[]
    for i in one_hot_label_list:
        label_text=""
        one_hot_label=np.reshape(i,[4,10])
        label_list=list(np.argmax(one_hot_label,1))
        for item in label_list:
            label_text=label_text+str(item)
        total_labels_list.append(label_text)
    return total_labels_list

x=tf.placeholder(dtype=tf.float32,shape=[None,24,72])
y=tf.placeholder(dtype=tf.float32,shape=[None,40])

#放入卷积的图片格式[batch_size,height,width,channal]
X=tf.reshape(x,[-1,24,72,1])

#卷积层1（卷积核w的stddev方差最好指定一下，可以使得模型的loss值大大降低）
# w1=tf.Variable(tf.random_normal(shape=[3,3,1,32]))
# b1=tf.Variable(tf.random_normal(shape=[32]))
w1=tf.Variable(tf.random_normal(shape=[3,3,1,32],stddev=0.1))
b1=tf.Variable(tf.random_normal(shape=[32],stddev=0.1))
conv1=tf.nn.conv2d(input=X,filter=w1,strides=[1,1,1,1],padding="SAME")
conv1=tf.nn.relu(conv1)
conv1=tf.nn.max_pool(value=conv1,ksize=[1,2,2,1],strides=[1,2,2,1],padding="SAME")

#卷积层2
# w2=tf.Variable(tf.random_normal(shape=[3,3,32,64]))
# b2=tf.Variable(tf.random_normal(shape=[64]))
w2=tf.Variable(tf.random_normal(shape=[3,3,32,64],stddev=0.1))
b2=tf.Variable(tf.random_normal(shape=[64],stddev=0.1))
conv2=tf.nn.conv2d(input=conv1,filter=w2,strides=[1,1,1,1],padding="SAME")
conv2=tf.nn.relu(conv2)
conv2=tf.nn.max_pool(value=conv2,ksize=[1,2,2,1],strides=[1,2,2,1],padding="SAME")

#卷积层3
# w3=tf.Variable(tf.random_normal(shape=[3,3,64,64]))
# b3=tf.Variable(tf.random_normal(shape=[64]))
w3=tf.Variable(tf.random_normal(shape=[3,3,64,64],stddev=0.1))
b3=tf.Variable(tf.random_normal(shape=[64],stddev=0.1))
conv3=tf.nn.conv2d(input=conv2,filter=w3,strides=[1,1,1,1],padding="SAME")
conv3=tf.nn.relu(conv3)
conv3=tf.nn.max_pool(value=conv3,ksize=[1,2,2,1],strides=[1,2,2,1],padding="SAME")

conv3=tf.reshape(conv3,[-1,3*9*64])

#全连接层1
fw1=tf.Variable(tf.random_normal(shape=[3*9*64,1024]))
fb1=tf.Variable(tf.random_normal(shape=[1024]))
f1=tf.matmul(conv3,fw1)+fb1
f1=tf.nn.dropout(f1,keep_prob=0.9)

#输出层
fw2=tf.Variable(tf.random_normal(shape=[1024,40]))
fb2=tf.Variable(tf.random_normal(shape=[40]))
f2=tf.matmul(f1,fw2)+fb2

#loss值
loss=tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(labels=y,logits=f2))
train_step=tf.train.AdamOptimizer(1e-3).minimize(loss)

Y=tf.reshape(y,[-1,4,10])
predict=tf.reshape(f2,[-1,4,10])

#精确率
accuracy=tf.equal(tf.argmax(Y,2),tf.argmax(predict,2))
accuracy=tf.reduce_mean(tf.cast(accuracy,tf.float32))

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for i in range(2000):
        x_batch,y_batch=return_batch_image_label(100,images_dir,images_files)#获得一个批次的图片和标签
        
        loss_,step_=sess.run([loss,train_step],feed_dict={x:x_batch,y:y_batch})
        if(i+1)%100==0:#每过100个迭代，打印一次损失值与精确率
            acc=sess.run(accuracy,feed_dict={x:x_batch,y:y_batch})
            print(f"Iter{i+1} loss:{loss_} acc:{acc}")
            if int(acc)==1:
                break

#迭代次数：损失值与精确率
#Iter100 loss:2.754988670349121 acc:0.08749999850988388
#Iter200 loss:1.8096842765808105 acc:0.17749999463558197
#Iter300 loss:1.4139013290405273 acc:0.30250000953674316
#Iter400 loss:1.0008692741394043 acc:0.5199999809265137
#Iter500 loss:0.7027642726898193 acc:0.6650000214576721
#Iter600 loss:0.46572282910346985 acc:0.7799999713897705
#Iter700 loss:0.2582074999809265 acc:0.8675000071525574
#Iter800 loss:0.1750810295343399 acc:0.9325000047683716
#Iter900 loss:0.0971144586801529 acc:0.9624999761581421
#Iter1000 loss:0.10952772200107574 acc:0.9750000238418579
#Iter1100 loss:0.056641630828380585 acc:0.9900000095367432
#Iter1200 loss:0.04902639612555504 acc:0.9950000047683716
#Iter1300 loss:0.01670563593506813 acc:0.987500011920929
#Iter1400 loss:0.014091072604060173 acc:1.0