识别四位纯数字的卷积神经网络（精确率可达100%）

最新推荐文章于 2023-09-13 21:46:36 发布
最新推荐文章于 2023-09-13 21:46:36 发布
阅读量391 收藏 3
点赞数 3
分类专栏： Python 文章标签： tensorflow
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53465512/article/details/118442460
版权 
#模型保存
import tensorflow as tf
import matplotlib.pyplot as plt
import numpy as np
import cv2
import os
import random
import datetime

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

#划分训练集和测试集
train_files=images_files[:8000]
test_files=images_files[8000:]

#返回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
# 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.5)

#输出层
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)+
    (1e-3)*tf.nn.l2_loss(w1)+
    (1e-3)*tf.nn.l2_loss(w2)+
    (1e-3)*tf.nn.l2_loss(w3)+
    (1e-3)*tf.nn.l2_loss(fw1)+
    (1e-3)*tf.nn.l2_loss(fw2)
)


# 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))

#模型保存
saver=tf.train.Saver()

with tf.Session() as sess:
    train_acc_list=[]
    test_acc_list=[]
    Iter_list=[]
    sess.run(tf.global_variables_initializer())
    for i in range(5000):
        x_train_batch,y_train_batch=return_batch_image_label(500,images_dir,train_files)#获得一个批次训练集图片和标签
        x_test_batch,y_test_batch=return_batch_image_label(100,images_dir,test_files)#获得一个批次测试集图片和标签
        
        loss_,step_=sess.run([loss,train_step],feed_dict={x:x_train_batch,y:y_train_batch})
        
        if(i+1)%100==0:
            time=str(datetime.datetime.now()).split(" ")[-1].split(".")[0]
            acc_train=sess.run(accuracy,feed_dict={x:x_train_batch,y:y_train_batch})
            acc_test=sess.run(accuracy,feed_dict={x:x_test_batch,y:y_test_batch})
            
            train_acc_list.append(acc_train)
            test_acc_list.append(acc_test)
            Iter_list.append(i+1)
            
            print(f"Iter{i+1} ,loss:{loss_} ,train_acc:{acc_train} ,test_acc:{acc_test},时间{time}")
            
            if int(acc_train)==1:
                break
    saver.save(sess,".\\Model\\model.ckpt")#模型保存，相对路径,最好用\\的方式保存
#Iter100 ,loss:840.1920776367188 ,train_acc:0.12349999696016312 ,test_acc:0.09000000357627869,时间22:27:40
#Iter200 ,loss:760.3424072265625 ,train_acc:0.16899999976158142 ,test_acc:0.11749999970197678,时间22:28:59
#Iter300 ,loss:684.1693115234375 ,train_acc:0.2815000116825104 ,test_acc:0.20499999821186066,时间22:30:19
#Iter400 ,loss:613.4215698242188 ,train_acc:0.460999995470047 ,test_acc:0.3199999928474426,时间22:31:38
#Iter500 ,loss:548.9471435546875 ,train_acc:0.5855000019073486 ,test_acc:0.39250001311302185,时间22:32:58
#Iter600 ,loss:490.3861999511719 ,train_acc:0.6545000076293945 ,test_acc:0.4449999928474426,时间22:34:17
#Iter700 ,loss:437.27880859375 ,train_acc:0.6779999732971191 ,test_acc:0.4325000047683716,时间22:35:36
#Iter800 ,loss:389.3033752441406 ,train_acc:0.6924999952316284 ,test_acc:0.5525000095367432,时间22:36:55
#Iter900 ,loss:346.01190185546875 ,train_acc:0.7534999847412109 ,test_acc:0.5475000143051147,时间22:38:15
#Iter1000 ,loss:307.07818603515625 ,train_acc:0.7730000019073486 ,test_acc:0.5450000166893005,时间22:39:34
#Iter1100 ,loss:272.1109924316406 ,train_acc:0.8075000047683716 ,test_acc:0.5824999809265137,时间22:40:54
#Iter1200 ,loss:240.7642822265625 ,train_acc:0.8270000219345093 ,test_acc:0.6100000143051147,时间22:42:13
#Iter1300 ,loss:212.68809509277344 ,train_acc:0.8659999966621399 ,test_acc:0.625,时间22:43:33
#Iter1400 ,loss:187.6605224609375 ,train_acc:0.887499988079071 ,test_acc:0.6474999785423279,时间22:44:53
#Iter1500 ,loss:165.28846740722656 ,train_acc:0.9024999737739563 ,test_acc:0.6725000143051147,时间22:46:13
#Iter1600 ,loss:145.39093017578125 ,train_acc:0.9114999771118164 ,test_acc:0.6775000095367432,时间22:47:39
#Iter1700 ,loss:127.68877410888672 ,train_acc:0.940500020980835 ,test_acc:0.6800000071525574,时间22:49:04
#Iter1800 ,loss:111.97460174560547 ,train_acc:0.9434999823570251 ,test_acc:0.699999988079071,时间22:50:29
#Iter1900 ,loss:98.05056762695312 ,train_acc:0.9679999947547913 ,test_acc:0.7074999809265137,时间22:51:53
#Iter2000 ,loss:85.72267150878906 ,train_acc:0.9695000052452087 ,test_acc:0.7074999809265137,时间22:53:17
#Iter2100 ,loss:74.83501434326172 ,train_acc:0.9735000133514404 ,test_acc:0.7174999713897705,时间22:54:41
#Iter2200 ,loss:65.24179077148438 ,train_acc:0.9729999899864197 ,test_acc:0.7250000238418579,时间22:56:05
#Iter2300 ,loss:56.78237533569336 ,train_acc:0.9894999861717224 ,test_acc:0.75,时间22:57:29
#Iter2400 ,loss:49.353450775146484 ,train_acc:0.984499990940094 ,test_acc:0.737500011920929,时间22:58:52
#Iter2500 ,loss:42.83298110961914 ,train_acc:0.9919999837875366 ,test_acc:0.7450000047683716,时间23:00:18
#Iter2600 ,loss:37.114097595214844 ,train_acc:0.9919999837875366 ,test_acc:0.7450000047683716,时间23:01:42
#Iter2700 ,loss:32.11655044555664 ,train_acc:0.9959999918937683 ,test_acc:0.7400000095367432,时间23:03:05
#Iter2800 ,loss:27.755178451538086 ,train_acc:0.9980000257492065 ,test_acc:0.75,时间23:04:29
#Iter2900 ,loss:23.953184127807617 ,train_acc:0.9980000257492065 ,test_acc:0.7400000095367432,时间23:05:54
#Iter3000 ,loss:20.645999908447266 ,train_acc:0.9975000023841858 ,test_acc:0.7475000023841858,时间23:07:17
#Iter3100 ,loss:17.774030685424805 ,train_acc:0.9984999895095825 ,test_acc:0.7475000023841858,时间23:09:47
#Iter3200 ,loss:15.283675193786621 ,train_acc:0.9990000128746033 ,test_acc:0.75,时间23:12:24
#Iter3300 ,loss:13.129268646240234 ,train_acc:0.9984999895095825 ,test_acc:0.7475000023841858,时间23:14:56
#Iter3400 ,loss:11.267122268676758 ,train_acc:0.9994999766349792 ,test_acc:0.7475000023841858,时间23:17:36
#Iter3500 ,loss:9.66270637512207 ,train_acc:0.9994999766349792 ,test_acc:0.75,时间23:20:23
#Iter3600 ,loss:8.279025077819824 ,train_acc:0.9994999766349792 ,test_acc:0.7524999976158142,时间23:23:14
#Iter3700 ,loss:7.090017318725586 ,train_acc:0.9994999766349792 ,test_acc:0.75,时间23:26:13
#Iter3800 ,loss:6.067821502685547 ,train_acc:1.0 ,test_acc:0.75,时间23:29:22

过拟合

#模型导入和使用
import tensorflow as tf
import matplotlib.pyplot as plt
import numpy as np
import cv2
import os
import random
import datetime

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

#划分训练集和测试集
train_files=images_files[:8000]
test_files=images_files[8000:]

#返回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
# 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.5)

#输出层
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)+
    (1e-3)*tf.nn.l2_loss(w1)+
    (1e-3)*tf.nn.l2_loss(w2)+
    (1e-3)*tf.nn.l2_loss(w3)+
    (1e-3)*tf.nn.l2_loss(fw1)+
    (1e-3)*tf.nn.l2_loss(fw2)
)


# 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))

#模型保存
saver = tf.train.Saver()
with tf.Session() as sess:
    
    saver.restore(sess,".\\Model\\model.ckpt")#模型导入，得用相对路径,最好用\\的方式
    x_train_batch,y_train_batch=return_batch_image_label(10,images_dir,train_files)#获得一个批次训练集图片和标签
    
    
    predict_=sess.run(predict,feed_dict={x:x_train_batch})
    predict_=return_text(predict_)

    for i in range(10):
        print(predict_[i])
        plt.figure()
        plt.imshow(x_train_batch[i])
        plt.show()

效果图

ddq呀
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
基于卷积神经网络的验证码识别(准确率87.5%+)
HAHAJustin的博客
05-16 1万+
目录一、任务背景与目标概述二、卷积神经网络简介三、方案设计及实现过程四、实验结果及分析与讨论五、结论实现代码 一、任务背景与目标概述 随着现代网络技术的飞速发展和提高，改善了我们的生活质量，同时也给生活带来了很多便利，但随之而来的还有许多问题，例如日益严重的网络安全问题。在学习了人工神经网络的这门课之后，结合本科阶段所学习的网络安全相关知识，决定完成一个基于卷积神经网络的验证码识别程序。在进行渗透测试时，发现网站或者CMS后台后可以进行爆破。账户名和密码可以用常用字符组成字典进行暴力破解，但安全性稍高的网站
神经网络方法研究及应用,神经网络预处理标准化
ynca67269的博客
08-10 1143
3、基于MATLAB语言的网络训练与仿真建立并初始化网络% ================S1 = 24;在学习阶段应该用大量的样本进行训练学习，通过样本的大量学习对神经网络的各层网络的连接权值进行修正，使其对样本有正确的识别结果，这就像人记数字一样，网络中的神经元就像是人脑细胞，权值的改变就像是人脑细胞的相互作用的改变，神经网络在样本学习中就像人记数字一样，学习样本时的网络权值调整就相当于人记住各个数字的形象，网络权值就是网络记住的内容，网络学习阶段就像人由不认识数字到认识数字反复学习过程是一样的。..
CNN卷积神经网络实现验证码识别（准确率达99%）
qq_32865355的博客
12-11 3万+
基于python生成验证码，并用CNN进行训练识别，验证码四位，如果由数字，小写字母，大写字母组成，那么cpu要跑很久很久，所以这里的验证码只包含了四位数字，一共有10*10*10*10个可能的数据。通过卷积神经模型，准确率达到了99%，大约迭代1200次左右，运行时间不算太长！！下面附上代码和效果图！！！！具体的细节就不介绍了，最近有点忙～～～，有问题可以评论！！！我会解答！！
卷积神经网络10（卷积基础知识补充）+实操代码，手写体识别，准确率高达98+%
weixin_42989738的博客
09-07 290
对于batch 1 28 28 的图像 用10个5 * 5核进行卷积，得到batch 10 （28 - 4） * （28 - 4) 即》（batch 10 24 * 24） 经过一个2 * 2 最大池化，得到（batch 10 12 * 12） 然后又经过20个5 * 5卷积核 输出（batch 20 8 * 8） 经过一个2 * 2 最大池化，得到（batch 20 4 * 4） 最后将其展开,输送到全连接层 20 * 4 * 4 = 320 import torch from torchvisi.
卷积网络：实现手写数字是识别50轮准确率97.3%
m0_46256255的博客
09-13 185
输出： 2 torchvision内置了常用数据集和最常见的模型 输出： 3 数据批量加载 输出： 4 绘制样例 7 设置是否使用GPU 输出： 8 设置损失函数和优化器 9 定义训练函数 10 定义测试函数 11 开始训练 输出： 12 绘制损失曲线并保存 输出： 输出：
卷积神经网络 实现验证码识别 ---- 识别率 99%
Persist_bcl的博客
11-12 1365
1. 创建自己的数据集，利用数字1-10 和 26个小写字母生成我们的训练数据集。 from captcha.image import ImageCaptcha import random CHAR_SET = ['1', '2', '3', '4', '5','6', '7', '8', '9', '0','a','b','c','d','e','f','g','h','i','j','k','l','m','n'] CHAR_LEN = len(CHAR_SET) CAPTCHA_LEN = 4
基于BP神经网络和卷积神经网络的MNIST手写数字识别
01-22
本基于BP神经网络和卷积神经网络对手写数字识别进行...在Matlab环境下，编程分别对训练样本进行训练，测试样本进行测试识别，得到分类结果和正确率，然后对每种结果进行对比，可比较BP神经网络和卷积神经网络的优劣性
Python课程设计-基于卷积神经网络手写数字识别系统.zip
06-23
Python课程设计—基于卷积神经网络手写数字识别系统，经老师指导通过的高分项目。 选题 利用numpy完成手写数字数据集的识别，完成多分类问题，搭建神经网络，并且完成模型的训练以及性能评估，可视化数据 用到的...
基于Python的MNIST手写数字识别卷积神经网络设计源码
最新发布
04-06
本资源提供了一套基于Python的MNIST手写数字识别卷积神经网络的设计源码，包含49975个文件，其中包括49957个JPEG图片文件，以及4个GZ压缩文件。此外，还包括2个Markdown文档，2个Python源代码文件，以及1个Git忽略...
CNN_python_卷积神经网络_手写数字识别_
10-03
卷积神经网络（CNN，Convolutional Neural Network）是一种深度学习模型，特别适用于图像处理任务，如手写数字识别。本项目使用Python编程语言来构建一个CNN模型，以实现对MNIST数据集的手写数字识别。MNIST是机器...
python基于opencv下使用卷积神经网络的车牌识别系统 详细代码 可直接使用
08-30
大学毕业设计 使用python基于opencv开发车牌识别系统，可以实现后台传输的图片识别 使用了两个相同结构的卷积神经网络 车牌识别系统可以分为两个部分， 第一个部分是车牌定位过滤部分； 第二个部分是字符识别部分； ...
LeNet5卷积神经网络训练参数（精度0.985）
06-06
LeNet5神经网络模型在手写数字识别中的识别率很高，通过训练得到0.985精度的参数，可以用于训练更高精度的初始参数。其中卷积核选择表(O：true， X: false)： { O, X, X, X, O, O, O, X, X, O, O, O, O, X, O, O, O, O, X, X, X, O, O, O, X, X, O, O, O, O, X, O, O, O, O, X, X, X, O, O, O, X, X, O, X, O, O, O, X, O, O, O, X, X, O, O, O, O, X, X, O, X, O, O, X, X, O, O, O, X, X, O, O, O, O, X, O, O, X, O, X, X, X, O, O, O, X, X, O, O, O, O, X, O, O, O };
卷积神经网络性能优化（提高准确率）
weixin_44023658的博客
05-17 3万+
注：本文先讲解理论部分，之后会用pytorch给出示例 神经网络是一种在很多用例中能够提供最优准确率的机器学习算法。但是，很多时候我们构建的神经网络的准确率可能无法令人满意，或者无法让我们在数据科学竞赛中拿到领先名次。所以，我们总是在寻求更好的方式来改善模型的性能。有很多技术可以帮助我们达到这个目标。本文将介绍这些技术，帮助大家构建更准确的神经网络。 过拟合 过拟合，典型的表现为训练集损失远远小于验证集损失。而欠拟合则表现为训练集损失大于验证集损失。 保证神经网络在测试集上运行良好的第一步就是验证神经网络
卷积层的算力评估(MACC和FOPS)
tugouxp的专栏
02-14 2953
以比较简单的lenet网络模型为例，我们尝试推导主要算子的算力计算公式，并看一下它的各层理论算力要求。 lenet网络结构 以第二层为例，他的输入尺寸是1*28*28*1的一张feature map,卷积核为 5*5*1,stride_h和stride_w均为1， pad_h,pad_w均为0，说明不做padding，输出feature map会缩小。 卷积层的算力评估方法 卷积模型，典型的卷积层计算如下图所示： 卷积算力计算 每做一次卷积，生成一个右图中的黄色方块，假设卷积
神经网络的分类准确率是100%到底意味着什么？
staple
05-04 5943
(A,B)---n*m*2---(1,0)(0,1) 做一个网络分类A和B，随着迭代次数的增加A与B的分类准确率会不断的增加并无限的接近或达到100%。所以是否有一个物理过程与这个现象相对应？ 先引入一个假设 假设1：完全相同的两个对象无法被分成两类，与之对应的分类迭代次数为无穷大，分类准确率是50%，50%。相等收敛标准下迭代次数越大表明二者差异越小。 比如参与分类的两个对象是...
深度学习与计算机视觉系列(8)_神经网络训练与注意点
热门推荐
寒小阳
01-15 5万+
在前一节当中我们讨论了神经网络静态的部分：包括神经网络结构、神经元类型、数据部分、损失函数部分等。这个部分我们集中讲讲动态的部分，主要是训练的事情，集中在实际工程实践训练过程中要注意的一些点，如何找到最合适的参数。
神经网络训练结果不稳定,神经网络训练时间过长
shirley67269的博客
08-24 1029
绝大部分是像[0.99680.00000.00010.9970]这样的输出，所以只要输出中的某个元素大于一定的值，例如0.7，我们就认为这个元素是1，即是有某种炎。像着4个元素分别表示：是否肺炎，是否肝炎，是否肾炎，是否胆炎，1表示是，0表示不是。3，所以一般神经网络的输出要按一定的标准定义成另一种输出（像上面说的），看调整后的输出和期望输出是否一致，一致的话算正确，不一致算错误。其实神经网络的准确率的标准是自己定义的。4，用总量为n的检验样本对网络进行评价，输出调整后的输出，统计错误的个数，记为m。
全网最全-神经网络混合精度训练原理
m0_37046057的博客
12-06 1770
如图所示在网络模型训练阶段， 激活函数的梯度分布式中，有67%的精度小于2^24，直接使用FP16进行表示会截断下溢的数据，这些梯度值都会变为0。通常我们训练神经网络模型的时候默认使用的数据类型为单精度FP32。近年来，为了加快训练时间、减少网络训练时候所占用的内存，并且保存训练出来的模型精度持平的条件下，业界提出越来越多的混合精度训练的方法。这里的混合精度训练是指在训练的过程中，同时使用单精度（FP32）和半精度（FP16）。
手写数字识别实验：全连接与卷积神经网络参数调试与特征分析
为此，我们分别采用全连接神经网络和卷积神经网络进行实验，通过调试参数并观察训练误差曲线的变化，以及绘制出卷积神经网络的特征层并保存为图片，来研究两种不同网络结构在手写数字识别任务上的表现。 在数据集...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值