Python进阶教程:使用机器学习实现手写数字识别

合集下载

Python实现识别手写数字Python图片读入与处理

Python实现识别手写数字Python图片读入与处理

Python实现识别⼿写数字Python图⽚读⼊与处理写在前⾯在上⼀篇⽂章中,我们已经讲过了我们想要写的全部思路,所以我们不再说全部的思路。

我这⼀次将图⽚的读⼊与处理的代码写了⼀下,和⼤纲写的过程⼀样,这⼀段代码分为以下⼏个部分:读⼊图⽚;将图⽚读取为灰度值矩阵;图⽚背景去噪;切割图⽚,得到⼿写数字的最⼩矩阵;拉伸/压缩图⽚,得到标准⼤⼩为100x100⼤⼩矩阵;将图⽚拉为1x10000⼤⼩向量,存⼊训练矩阵中。

所以下⾯将会对这⼏个函数进⾏详解。

代码分析基础内容⾸先我们现在最前⾯定义基础变量import osfrom skimage import ioimport numpy as np##Essential vavriable 基础变量#Standard size 标准⼤⼩N = 100#Gray threshold 灰度阈值color = 100/255其中标准⼤⼩指的是我们在最后经过切割、拉伸后得到的图⽚的尺⼨为NxN。

灰度阈值指的是在某个点上的灰度超过阈值后则变为1.接下来是这图像处理的⼀部分的主函数filenames = os.listdir(r"./num/")pic = GetTrainPicture(filenames)其中filenames得到在num⽬录下所有⽂件的名称组成的列表。

pic则是通过函数GetTrainPicture得到所有训练图像向量的矩阵。

这⼀篇⽂章主要就是围绕这个函数进⾏讲解。

GetTrainPicture函数GetTrainPicture函数内容如下#Read and save train picture 读取训练图⽚并保存def GetTrainPicture(files):Picture = np.zeros([len(files), N**2+1])#loop all pictures 循环所有图⽚⽂件for i, item in enumerate(files):#Read the picture and turn RGB to grey 读取这个图⽚并转为灰度值img = io.imread('./num/'+item, as_grey = True)#Clear the noise 清除噪⾳img[img>color] = 1#Cut the picture and get the picture of handwritten number#将图⽚进⾏切割,得到有⼿写数字的的图像img = CutPicture(img)#Stretch the picture and get the standard size 100x100#将图⽚进⾏拉伸,得到标准⼤⼩100x100img = StretchPicture(img).reshape(N**2)#Save the picture to the matrix 将图⽚存⼊矩阵Picture[i, 0:N**2] = img#Save picture's name to the matrix 将图⽚的名字存⼊矩阵Picture[i, N**2] = float(item[0])return Picture可以看出这个函数的信息量⾮常⼤,基本上今天做的所有步骤我都把封装到⼀个个函数⾥⾯了,所以这⾥我们可以看到图⽚处理的所有步骤都在这⾥。

Python手写数字识别-knn算法应用

Python手写数字识别-knn算法应用

Python⼿写数字识别-knn算法应⽤ 在上⼀篇博⽂中,我们对KNN算法思想及流程有了初步的了解,KNN是采⽤测量不同特征值之间的距离⽅法进⾏分类,也就是说对于每个样本数据,需要和训练集中的所有数据进⾏欧⽒距离计算。

这⾥简述KNN算法的特点:优点:精度⾼,对异常值不敏感,⽆数据输⼊假定缺点:计算复杂度⾼,空间复杂度⾼适⽤数据范围:数值型和标称型(具有有穷多个不同值,值之间⽆序) knn算法代码:#-*- coding: utf-8 -*-from numpy import *import operatorimport timefrom os i mport listdirdef classify(inputPoint,dataSet,labels,k):dataSetSize = dataSet.shape[0] #已知分类的数据集(训练集)的⾏数#先tile函数将输⼊点拓展成与训练集相同维数的矩阵,再计算欧⽒距离diffMat = tile(inputPoint,(dataSetSize,1))-dataSet #样本与训练集的差值矩阵sqDiffMat = diffMat ** 2 #差值矩阵平⽅sqDistances = sqDiffMat.sum(axis=1) #计算每⼀⾏上元素的和distances = sqDistances ** 0.5 #开⽅得到欧拉距离矩阵sortedDistIndicies = distances.argsort() #按distances中元素进⾏升序排序后得到的对应下标的列表#选择距离最⼩的k个点classCount = {}for i in range(k):voteIlabel = labels[ sortedDistIndicies[i] ]classCount[voteIlabel] = classCount.get(voteIlabel,0)+1#按classCount字典的第2个元素(即类别出现的次数)从⼤到⼩排序sortedClassCount = sorted(classCount.items(), key = operator.itemgetter(1), reverse = True)return sortedClassCount[0][0] 下⾯介绍如何使⽤knn算法对⼿写识别数据进⾏分类,这⾥构造的分类系统只能识别数字0到9,数字经图形处理软件处理成具有相同的⾊彩和⼤⼩,宽⾼为32x32像素,为了便于处理,已将图像转换为⽂本格式,其效果图如下: 数据集可在下载,解压后有两个⽬录,其中⽬录trainingDigits中包含了1934个例⼦,命名规则如 9_45.txt,表⽰该⽂件的分类是9,是数字9的第45个实例,每个数字⼤概有200个实例。

python课程设计手写数字识别

python课程设计手写数字识别

python课程设计手写数字识别一、教学目标本课程的目标是使学生掌握Python编程语言的基本知识,学会手写数字识别的原理和实现方法。

通过本课程的学习,学生将能够:1.理解Python编程语言的基本语法和数据结构;2.掌握机器学习的基本概念和常用算法;3.学会使用Python库实现手写数字识别模型;4.能够独立完成手写数字识别项目的开发和优化。

二、教学内容本课程的教学内容主要包括以下几个部分:1.Python编程基础:介绍Python语言的基本语法、数据类型、控制结构、函数、模块等基本知识;2.机器学习理论:讲解机器学习的基本概念、常用算法和模型,如线性回归、支持向量机、神经网络等;3.手写数字识别:介绍手写数字识别的原理和常用算法,如感知机、支持向量机、神经网络等;4.实践项目:通过实际操作,让学生学会使用Python库实现手写数字识别模型,并进行优化和调试。

三、教学方法为了提高学生的学习兴趣和主动性,本课程将采用多种教学方法相结合的方式进行教学:1.讲授法:讲解Python编程基础和机器学习理论;2.案例分析法:分析实际案例,让学生了解手写数字识别的应用场景;3.实验法:引导学生动手实践,实现手写数字识别模型;4.讨论法:学生进行小组讨论,分享学习心得和经验,互相促进。

四、教学资源为了支持教学内容和教学方法的实施,丰富学生的学习体验,我们将提供以下教学资源:1.教材:选用国内权威的Python编程和机器学习教材;2.参考书:推荐学生阅读相关的国内外经典著作;3.多媒体资料:提供在线视频教程、课件、实验代码等资源;4.实验设备:为学生提供必要的实验设备和软件环境。

五、教学评估为了全面、客观、公正地评估学生的学习成果,本课程将采用以下评估方式:1.平时表现:通过课堂参与、提问、讨论等方式评估学生的学习态度和理解程度;2.作业:布置相关的编程练习和实验报告,评估学生对知识点的掌握和实际操作能力;3.考试:安排期末考试,测试学生对课程知识的全面理解和应用能力。

Python利用逻辑回归模型解决MNIST手写数字识别问题详解

Python利用逻辑回归模型解决MNIST手写数字识别问题详解

Python利⽤逻辑回归模型解决MNIST⼿写数字识别问题详解本⽂实例讲述了Python利⽤逻辑回归模型解决MNIST⼿写数字识别问题。

分享给⼤家供⼤家参考,具体如下:1、MNIST⼿写识别问题MNIST⼿写数字识别问题:输⼊⿊⽩的⼿写阿拉伯数字,通过机器学习判断输⼊的是⼏。

可以通过TensorFLow下载MNIST⼿写数据集,通过import引⼊MNIST数据集并进⾏读取,会⾃动从⽹上下载所需⽂件。

%matplotlib inlineimport tensorflow as tfimport tensorflow.examples.tutorials.mnist.input_data as input_datamnist=input_data.read_data_sets('MNIST_data/',one_hot=True)import matplotlib.pyplot as pltdef plot_image(image): #图⽚显⽰函数plt.imshow(image.reshape(28,28),cmap='binary')plt.show()print("训练集数量:",mnist.train.num_examples,"特征值组成:",mnist.train.images.shape,"标签组成:",bels.shape)batch_images,batch_labels=mnist.train.next_batch(batch_size=10) #批量读取数据print(batch_images.shape,batch_labels.shape)print('标签值:',np.argmax(bels[1000]),end=' ') #np.argmax()得到实际值print('独热编码表⽰:',bels[1000])plot_image(mnist.train.images[1000]) #显⽰数据集中第1000张图⽚输出训练集的数量有55000个,并打印特征值的shape为(55000,784),其中784代表每张图⽚由28*28个像素点组成,由于是⿊⽩图⽚,每个像素点只有⿊⽩单通道,即通过784个数可以描述⼀张图⽚的特征值。

pytorch教程实现mnist手写数字识别代码示例

pytorch教程实现mnist手写数字识别代码示例

pytorch教程实现mnist⼿写数字识别代码⽰例⽬录1.构建⽹络2.编写训练代码3.编写测试代码4.指导程序train和test5.完整代码1.构建⽹络nn.Moudle是pytorch官⽅指定的编写Net模块,在init函数中添加需要使⽤的层,在foeword中定义⽹络流向。

下⾯详细解释各层:conv1层:输⼊channel = 1 ,输出chanael = 10,滤波器5*5maxpooling = 2*2conv2层:输⼊channel = 10 ,输出chanael = 20,滤波器5*5,dropoutmaxpooling = 2*2fc1层:输⼊320 个神经单元,输出50个神经单元fc1层:输⼊50个神经单元,输出10个神经单元class Net(nn.Module):def __init__(self):super(Net, self).__init__()self.conv1 = nn.Conv2d(1, 10, kernel_size=5)self.conv2 = nn.Conv2d(10, 20, kernel_size=5)self.conv2_drop = nn.Dropout2d()self.fc1 = nn.Linear(320, 50)self.fc2 = nn.Linear(50, 10)def forward(self, x): #x.size() = 28*28*1x = F.relu(F.max_pool2d(self.conv1(x), 2))x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2)) #x.size() =12*12*10x = x.view(-1, 320) #x.size() =1*320x = F.relu(self.fc1(x))x = F.dropout(x, training=self.training)x = self.fc2(x)return F.log_softmax(x, dim=1)2.编写训练代码model = Net() #调⽤写好的⽹络if args.cuda: #如果有GPU使⽤CPUmodel.cuda()optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum) #设置SGD随机梯度下降算法def train(epoch):model.train()for batch_idx, (data, target) in enumerate(train_loader):if args.cuda:data, target = data.cuda(), target.cuda()data, target = Variable(data), Variable(target)optimizer.zero_grad() #梯度初始化为Ooutput = model(data)loss = F.nll_loss(output, target) #简历loss functionloss.backward() #反向传播,计算梯度optimizer.step() #更新权重if batch_idx % args.log_interval == 0: #输出信息print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(epoch, batch_idx * len(data), len(train_loader.dataset),100. * batch_idx / len(train_loader), loss.data[0]))3.编写测试代码def test():model.eval()test_loss = 0correct = 0for data, target in test_loader:if args.cuda:data, target = data.cuda(), target.cuda()data, target = Variable(data, volatile=True), Variable(target)output = model(data)test_loss += F.nll_loss(output, target, size_average=False).data[0] # sum up batch loss pred = output.data.max(1, keepdim=True)[1] # get the index of the max log-probability correct += pred.eq(target.data.view_as(pred)).long().cpu().sum()test_loss /= len(test_loader.dataset)print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(test_loss, correct, len(test_loader.dataset),100. * correct / len(test_loader.dataset)))4.指导程序train和testfor epoch in range(1, args.epochs + 1):train(epoch) #训练N个epochtest() #检验在测试集上的表现5.完整代码# -*- coding: utf-8 -*-from __future__ import print_functionimport argparseimport torchimport torch.nn as nnimport torch.nn.functional as Fimport torch.optim as optimfrom torchvision import datasets, transformsfrom torch.autograd import Variable# Training settingsparser = argparse.ArgumentParser(description='PyTorch MNIST Example')parser.add_argument('--batch-size', type=int, default=64, metavar='N',help='input batch size for training (default: 64)')parser.add_argument('--test-batch-size', type=int, default=1000, metavar='N',help='input batch size for testing (default: 1000)')parser.add_argument('--epochs', type=int, default=10, metavar='N',help='number of epochs to train (default: 10)')parser.add_argument('--lr', type=float, default=0.01, metavar='LR',help='learning rate (default: 0.01)')parser.add_argument('--momentum', type=float, default=0.5, metavar='M',help='SGD momentum (default: 0.5)')parser.add_argument('--no-cuda', action='store_true', default=False,help='disables CUDA training')parser.add_argument('--seed', type=int, default=1, metavar='S',help='random seed (default: 1)')parser.add_argument('--log-interval', type=int, default=10, metavar='N',help='how many batches to wait before logging training status')args = parser.parse_args()args.cuda = not args.no_cuda and torch.cuda.is_available()torch.manual_seed(args.seed)if args.cuda:torch.cuda.manual_seed(args.seed)kwargs = {'num_workers': 1, 'pin_memory': True} if args.cuda else {}train_loader = torch.utils.data.DataLoader(datasets.MNIST('../data', train=True, download=True,transform=pose([transforms.ToTensor(),transforms.Normalize((0.1307,), (0.3081,))])),batch_size=args.batch_size, shuffle=True, **kwargs)test_loader = torch.utils.data.DataLoader(datasets.MNIST('../data', train=False, transform=pose([transforms.ToTensor(),transforms.Normalize((0.1307,), (0.3081,))])),batch_size=args.test_batch_size, shuffle=True, **kwargs)class Net(nn.Module):def __init__(self):super(Net, self).__init__()self.conv1 = nn.Conv2d(1, 10, kernel_size=5)self.conv2 = nn.Conv2d(10, 20, kernel_size=5)self.conv2_drop = nn.Dropout2d()self.fc1 = nn.Linear(320, 50)self.fc2 = nn.Linear(50, 10)def forward(self, x):print (x.size())x = F.relu(F.max_pool2d(self.conv1(x), 2))print(x.size())x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))print(x.size())x = x.view(-1, 320)x = F.relu(self.fc1(x))x = F.dropout(x, training=self.training)x = self.fc2(x)return F.log_softmax(x, dim=1)model = Net() #调⽤写好的⽹络if args.cuda: #如果有GPU使⽤CPUmodel.cuda()optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum) #设置SGD随机梯度下降算法def train(epoch):model.train()for batch_idx, (data, target) in enumerate(train_loader):if args.cuda:data, target = data.cuda(), target.cuda()data, target = Variable(data), Variable(target)optimizer.zero_grad() #梯度初始化为Ooutput = model(data)loss = F.nll_loss(output, target) #简历loss functionloss.backward() #反向传播,计算梯度optimizer.step() #更新权重if batch_idx % args.log_interval == 0: #输出信息print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(epoch, batch_idx * len(data), len(train_loader.dataset),100. * batch_idx / len(train_loader), loss.data[0]))def test():model.eval()test_loss = 0correct = 0for data, target in test_loader:if args.cuda:data, target = data.cuda(), target.cuda()data, target = Variable(data, volatile=True), Variable(target)output = model(data)test_loss += F.nll_loss(output, target, size_average=False).data[0] # sum up batch losspred = output.data.max(1, keepdim=True)[1] # get the index of the max log-probabilitycorrect += pred.eq(target.data.view_as(pred)).long().cpu().sum()test_loss /= len(test_loader.dataset)print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(test_loss, correct, len(test_loader.dataset),100. * correct / len(test_loader.dataset)))for epoch in range(1, args.epochs + 1):train(epoch)test()以上就是pytorch教程实现mnist⼿写数字识别代码⽰例的详细内容,更多关于pytorch实现mnist⼿写数字识别的资料请关注其它相关⽂章!。

python神经网络编程之手写数字识别

python神经网络编程之手写数字识别

python神经⽹络编程之⼿写数字识别⽬录写在之前⼀、代码框架⼆、准备⼯作三、框架的开始四、训练模型构建五、⼿写数字的识别六、源码七、思考写在之前⾸先是写在之前的⼀些建议:⾸先是关于这本书,我真的认为他是将神经⽹络⾥⾮常棒的⼀本书,但你也需要注意,如果你真的想⾃⼰动⼿去实现,那么你⼀定需要有⼀定的python基础,并且还需要有⼀些python数据科学处理能⼒然后希望⼤家在看这边博客的时候对于神经⽹络已经有⼀些了解了,知道什么是输⼊层,什么是输出层,并且明⽩他们的⼀些理论,在这篇博客中我们仅仅是展开⼀下代码;然后介绍⼀下本篇博客的环境等:语⾔:Python3.8.5环境:jupyter库⽂件: numpy | matplotlib | scipy⼀、代码框架我们即将设计⼀个神经⽹络对象,它可以帮我们去做数据的训练,以及数据的预测,所以我们将具有以下的三个⽅法:⾸先我们需要初始化这个函数,我们希望这个神经⽹络仅有三层,因为再多也不过是在隐藏层去做⽂章,所以先做⼀个简单的。

那么我们需要知道我们输⼊层、隐藏层和输出层的节点个数;训练函数,我们需要去做训练,得到我们需要的权重。

通过我们已有的权重,将给定的输⼊去做输出。

⼆、准备⼯作现在我们需要准备⼀下:1.将我们需要的库导⼊import numpy as npimport scipy.special as speimport matplotlib.pyplot as plt2.构建⼀个类class neuralnetwork:# 我们需要去初始化⼀个神经⽹络def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate):passdef train(self, inputs_list, targets_list):passdef query(self, inputs_list):pass3.我们的主函数input_nodes = 784 # 输⼊层的节点数hidden_nodes = 88 # 隐藏层的节点数output_nodes = 10 # 输出层的节点数learn_rate = 0.05 # 学习率n = neuralnetwork(input_nodes, hidden_nodes, output_nodes, learn_rate)4.导⼊⽂件data_file = open("E:\sklearn_data\神经⽹络数字识别\mnist_train.csv", 'r')data_list = data_file.readlines()data_file.close()file2 = open("E:\sklearn_data\神经⽹络数字识别\mnist_test.csv")answer_data = file2.readlines()file2.close()这⾥需要介绍以下这个数据集,训练集在这⾥,测试集在这⾥三、框架的开始def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate):self.inodes = inputnodes # 输⼊层节点设定self.hnodes = hiddennodes # 影藏层节点设定self.onodes = outputnodes # 输出层节点设定self.lr = learningrate # 学习率设定,这⾥可以改进的self.wih = (np.random.normal(0.0, pow(self.hnodes, -0.5),(self.hnodes, self.inodes))) # 这⾥是输⼊层与隐藏层之间的连接self.who = (np.random.normal(0.0, pow(self.onodes, -0.5),(self.onodes, self.hnodes))) # 这⾥是隐藏层与输出层之间的连接self.activation_function = lambda x: spe.expit(x) # 返回sigmoid函数Δw j,k =α∗E k ∗ sigmoid (O k )∗(1−sigmoid(O k ))⋅O j ⊤def query(self, inputs_list):inputs = np.array(inputs_list, ndmin=2).T # 输⼊进来的⼆维图像数据hidden_inputs = np.dot(self.wih, inputs) # 隐藏层计算,说⽩了就是线性代数中的矩阵的点积hidden_outputs = self.activation_function(hidden_inputs) # 将隐藏层的输出是经过sigmoid函数处理final_inputs = np.dot(self.who, hidden_outputs) # 原理同hidden_inputsfinal_outputs = self.activation_function(final_inputs) # 原理同hidden_outputsreturn final_outputs # 最终的输出结果就是我们预测的数据这⾥我们对预测这⼀部分做⼀个简单的解释:我们之前的定义输出的节点是10个,对应的是⼗个数字。

超详细PyTorch实现手写数字识别器的示例代码

超详细PyTorch实现⼿写数字识别器的⽰例代码前⾔深度学习中有很多玩具数据,mnist就是其中⼀个,⼀个⼈能否⼊门深度学习往往就是以能否玩转mnist数据来判断的,在前⾯很多基础介绍后我们就可以来实现⼀个简单的⼿写数字识别的⽹络了数据的处理我们使⽤pytorch⾃带的包进⾏数据的预处理import torchimport torchvisionimport torchvision.transforms as transformsimport numpy as npimport matplotlib.pyplot as plttransform = pose([transforms.ToTensor(),transforms.Normalize((0.5), (0.5))])trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)trainloader = torch.utils.data.DataLoader(trainset, batch_size=32, shuffle=True,num_workers=2)注释:transforms.Normalize⽤于数据的标准化,具体实现mean:均值总和后除个数std:⽅差每个元素减去均值再平⽅再除个数norm_data = (tensor - mean) / std这⾥就直接将图⽚标准化到了-1到1的范围,标准化的原因就是因为如果某个数在数据中很⼤很⼤,就导致其权重较⼤,从⽽影响到其他数据,⽽本⾝我们的数据都是平等的,所以标准化后将数据分布到-1到1的范围,使得所有数据都不会有太⼤的权重导致⽹络出现巨⼤的波动trainloader现在是⼀个可迭代的对象,那么我们可以使⽤for循环进⾏遍历了,由于是使⽤yield返回的数据,为了节约内存观察⼀下数据def imshow(img):img = img / 2 + 0.5 # unnormalizenpimg = img.numpy()plt.imshow(np.transpose(npimg, (1, 2, 0)))plt.show()# torchvision.utils.make_grid 将图⽚进⾏拼接imshow(torchvision.utils.make_grid(iter(trainloader).next()[0]))构建⽹络from torch import nnimport torch.nn.functional as Fclass Net(nn.Module):def __init__(self):super(Net, self).__init__()self.conv1 = nn.Conv2d(in_channels=1, out_channels=28, kernel_size=5) # 14self.pool = nn.MaxPool2d(kernel_size=2, stride=2) # ⽆参数学习因此⽆需设置两个self.conv2 = nn.Conv2d(in_channels=28, out_channels=28*2, kernel_size=5) # 7self.fc1 = nn.Linear(in_features=28*2*4*4, out_features=1024)self.fc2 = nn.Linear(in_features=1024, out_features=10)def forward(self, inputs):x = self.pool(F.relu(self.conv1(inputs)))x = self.pool(F.relu(self.conv2(x)))x = x.view(inputs.size()[0],-1)x = F.relu(self.fc1(x))return self.fc2(x)下⾯是卷积的动态演⽰in_channels:为输⼊通道数彩⾊图⽚有3个通道⿊⽩有1个通道out_channels:输出通道数kernel_size:卷积核的⼤⼩stride:卷积的步长padding:外边距⼤⼩输出的size计算公式h = (h - kernel_size + 2*padding)/stride + 1w = (w - kernel_size + 2*padding)/stride + 1 MaxPool2d:是没有参数进⾏运算的实例化⽹络优化器,并且使⽤GPU进⾏训练net = Net()opt = torch.optim.Adam(params=net.parameters(), lr=0.001)device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")net.to(device)Net((conv1): Conv2d(1, 28, kernel_size=(5, 5), stride=(1, 1))(pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(conv2): Conv2d(28, 56, kernel_size=(5, 5), stride=(1, 1))(fc1): Linear(in_features=896, out_features=1024, bias=True)(fc2): Linear(in_features=1024, out_features=10, bias=True))训练主要代码for epoch in range(50):for images, labels in trainloader:images = images.to(device)labels = labels.to(device)pre_label = net(images)loss = F.cross_entropy(input=pre_label, target=labels).mean()pre_label = torch.argmax(pre_label, dim=1)acc = (pre_label==labels).sum()/torch.tensor(labels.size()[0], dtype=torch.float32)net.zero_grad()loss.backward()opt.step()print(acc.detach().cpu().numpy(), loss.detach().cpu().numpy())F.cross_entropy交叉熵函数源码中已经帮助我们实现了softmax因此不需要⾃⼰进⾏softmax操作了torch.argmax计算最⼤数所在索引值acc = (pre_label==labels).sum()/torch.tensor(labels.size()[0], dtype=torch.float32)# pre_label==labels 相同维度进⾏⽐较相同返回True不同的返回False,True为1 False为0, 即可获取到相等的个数,再除总个数,就得到了Accuracy准确度了预测testset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)testloader = torch.utils.data.DataLoader(testset, batch_size=128, shuffle=True,num_workers=2)images, labels = iter(testloader).next()images = images.to(device)labels = labels.to(device)with torch.no_grad():pre_label = net(images)pre_label = torch.argmax(pre_label, dim=1)acc = (pre_label==labels).sum()/torch.tensor(labels.size()[0], dtype=torch.float32)print(acc)总结本节我们了解了标准化数据·、卷积的原理、简答的构建了⼀个⽹络,并让它去识别⼿写体,也是对前⾯章节的总汇了到此这篇关于超详细PyTorch实现⼿写数字识别器的⽰例代码的⽂章就介绍到这了,更多相关PyTorch ⼿写数字识别器内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持!。

python实现识别手写数字python图像识别算法

python实现识别⼿写数字python图像识别算法写在前⾯这⼀段的内容可以说是最难的⼀部分之⼀了,因为是识别图像,所以涉及到的算法会相⽐之前的来说⽐较困难,所以我尽量会讲得清楚⼀点。

⽽且因为在编写的过程中,把前⾯的⼀些逻辑也修改了⼀些,将其变得更完善了,所以⼀切以本篇的为准。

当然,如果想要直接看代码,代码全部放在我的GitHub中,所以这篇⽂章主要负责讲解,如需代码请⾃⾏前往GitHub。

本次⼤纲上⼀次写到了数据库的建⽴,我们能够实时的将更新的训练图⽚存⼊CSV⽂件中。

所以这次继续往下⾛,该轮到识别图⽚的内容了。

⾸先我们需要从⽂件夹中提取出需要被识别的图⽚test.png,并且把它经过与训练图⽚相同的处理得到1x10000⼤⼩的向量。

因为两者之间存在微⼩的差异,我也不是很想再往源代码之中增加逻辑了,所以我就直接把增加待识别图⽚的函数重新写⼀个命名为GetTestPicture,内容与GetTrainPicture类似,只不过少了“增加图⽚名称”这⼀个部分。

之后我们就可以开始进⾏正式图⽚识别内容了。

主要是计算待识别图⽚与所有训练图⽚的距离。

当两个图⽚距离越近的时候,说明他们越相似,那么他们很有可能写的就是同⼀个数。

所以利⽤这个原理,我们可以找出距离待识别图像最近的⼏个训练图⽚,并输出他们的数字分别是⼏。

⽐如说我想输出前三个,前三个分别是3,3,9,那就说明这个待识别图⽚很有可能是3.之后还可以对每⼀个位置加个权重,具体的就放在下⼀次再讲,本节内容已经够多了。

(第⼀篇⽂章之中我说过利⽤图⽚洞数检测。

我尝试了⼀下,认为有些不妥,具体原因放在本⽂末。

)MAIN代码所以直接把主要代码放上来,逻辑相对来说还是⽐较清晰的import osimport OperatePicture as OPimport OperateDatabase as ODimport PictureAlgorithm as PAimport csv##Essential vavriable 基础变量#Standard size 标准⼤⼩N = 100#Gray threshold 灰度阈值color = 200/255n = 10#读取原CSV⽂件reader = list(csv.reader(open('Database.csv', encoding = 'utf-8')))#清除读取后的第⼀个空⾏del reader[0]#读取num⽬录下的所有⽂件名fileNames = os.listdir(r"./num/")#对⽐fileNames与reader,得到新增的图⽚newFileNamesnewFileNames = OD.NewFiles(fileNames, reader)print('New pictures are: ', newFileNames)#得到newFilesNames对应的矩阵pic = OP.GetTrainPicture(newFileNames)#将新增图⽚矩阵存⼊CSV中OD.SaveToCSV(pic, newFileNames)#将原数据库矩阵与新数据库矩阵合并pic = bination(reader, pic)#得到待识别图⽚testFiles = os.listdir(r"./test/")testPic = OP.GetTestPicture(testFiles)#计算每⼀个待识别图⽚的可能分类result = PA.CalculateResult(testPic, pic)for item in result:for i in range(n):print('第'+str(i+1)+'个向量为'+str(item[i+n])+',距离为'+str(item[i]))相⽐上⼀篇⽂章的内容,本篇⽂章⾥只增加了下⾯的的⼀段代码,即得到待识别图⽚名称、得到待识别图⽚向量、计算分类。

【机器学习】BP神经网络实现手写数字识别

【机器学习】BP神经⽹络实现⼿写数字识别 最近⽤python写了⼀个实现⼿写数字识别的BP神经⽹络,BP的推导到处都是,但是⼀动⼿才知道,会理论推导跟实现它是两回事。

关于BP神经⽹络的实现⽹上有⼀些代码,可惜或多或少都有各种问题,在下⼿写了⼀份,连带着⼀些关于性能的分析也写在下⾯,希望对⼤家有所帮助。

加⼀些简单的说明,算不得理论推导,严格的理论推导还是要去看别的博客或书。

BP神经⽹络是⼀个有监督学习模型,是神经⽹络类算法中⾮常重要和典型的算法,三层神经⽹络的基本结构如下: 这是最简单的BP神经⽹络结构,其运⾏机理是,⼀个特征向量的各个分量按不同权重加权,再加⼀个常数项偏置,⽣成隐层各节点的值。

隐层节点的值经过⼀个激活函数激活后,获得隐层激活值,隐层激活值仿照输⼊层到隐层的过程,加权再加偏置,获得输出层值,通过⼀个激活函数得到最后的输出。

上⾯的过程称为前向过程,是信息的流动过程。

各层之间采⽤全连接⽅式,权向量初始化为随机向量,激活函数可使⽤值域为(0,1)的sigmoid函数,也可使⽤值域为(-1,1)的tanh函数,两个函数的求导都很⽅便。

BP神经⽹络的核⼼数据是权向量,经过初始化后,需要在训练数据的作⽤下⼀次次迭代更新权向量,直到权向量能够正确表达输⼊输出的映射关系为⽌。

权向量的更新是根据预测输出与真值的差来更新的,前⾯说过BP神经⽹络是⼀个有监督学习模型,对于⼀个特征向量,可以通过神经⽹络前向过程得到⼀个预测输出,⽽该特征向量的label⼜是已知的,⼆者之差就能表达预测与真实的偏差情况。

这就是后向过程,后向过程是误差流动的过程。

抛开具体的理论推导不谈,从编程来说,权值更新的后向过程分为两步。

第⼀步,为每个神经元计算偏差δ,δ是从后向前计算的,故称之为后向算法。

对输出层来说,偏差是 act(预测值-真值),act为激活函数。

对隐层⽽⾔,需要从输出层开始,逐层通过权值计算得到。

确切的说,例如对上⾯的单隐层神经⽹络⽽⾔,隐层各神经元的δ就是输出层δ乘以对应的权值,如果输出层有多个神经元,则是各输出层神经元δ按连接的权值加权⽣成隐层的神经元δ。

基于机器学习的手写数字识别研究与实现

基于机器学习的手写数字识别研究与实现随着人工智能技术的不断发展,机器学习应用越来越广泛,其中手写数字识别技术是比较基础的一个领域。

手写数字识别技术能够在各种场景下帮助我们快速准确地识别手写数字,例如银行支票识别、智能表单填写等。

随着智能设备的普及,手写数字识别技术将得到更广泛的应用。

一、手写数字识别的原理手写数字识别技术利用计算机视觉和机器学习的方法识别手写数字。

首先将手写数字图像转换为数字信号,然后通过数字信号的特征来识别数字。

数字信号通常表示为一个矩阵,矩阵的每个元素表示一个像素点,像素点的灰度值表示该点的颜色深度,因此手写数字识别的过程可以看作是将一张数字图片转换为一组数字。

二、手写数字识别的方法手写数字识别有很多方法,其中常见的有传统的模板匹配法、神经网络法和支持向量机法。

而在近年来,深度学习方法也逐渐应用于手写数字识别领域,例如卷积神经网络(Convolutional Neural Network, CNN)等算法。

模板匹配法是将待识别的数字图像与预先设定的模板图像进行比较,如果两者相似度很高就认为是同一数字。

这种方法需要预先设定模板图像,因此适用于单一的数字识别。

神经网络法和支持向量机法则是建立一个分类模型,在进行数字识别时利用该模型对数字图像进行分类。

神经网络是一种模拟大脑神经系统的算法,它利用多层神经元对数据进行特征抽取和分类;支持向量机是一种用于分类、回归和异常检测的算法,通过在高维空间中寻找一个最优分类面来实现分类。

卷积神经网络是一种通过层次化特征学习来实现数字识别的神经网络算法。

它采用多层卷积层和池化层来对输入数据进行特征学习,并使用全连接层进行分类。

卷积神经网络具有良好的特征提取和分类能力,因此在目标识别领域取得了较好的成绩。

三、基于机器学习的手写数字识别实现本文以卷积神经网络为例,介绍基于机器学习的手写数字识别的实现过程。

1、数据集获取首先需要获取手写数字数据集。

MNIST数据集是经典的手写数字数据集,包含60000张训练图像和10000张测试图像,每张图像都是28*28像素的灰度图片。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

Python进阶教程:使用机器学习实现手写数字识别在日常生活中,我们经常需要手写数字,包括填写表格、汽车牌照等等,然而如何让计算机识别手写数字成了一个问题。

随着机器学习的发展,使用Python编写代码实现手写数字识别已经不再是一个难题。

本文主要介绍如何使用机器学习实现手写数字识别,其中包括数据预处理、模型构建以及模型训练等步骤。

一、数据预处理在进行手写数字识别前,我们需要获取训练数据和测试数据。

这里,我们选用了著名的MNIST数据集。

该数据集包含60,000张训练图像和10,000张测试图像,图像大小均为28x28,像素值为0-255的灰度值。

我们可以使用Python中的numpy和matplotlib库来读取和显示图像。

代码如下:```pythonimport numpy as npimport matplotlib.pyplot as plt# 读取训练数据train_images = np.load('mnist_train_images.npy')train_labels = np.load('mnist_train_labels.npy')# 读取测试数据test_images = np.load('mnist_test_images.npy')test_labels = np.load('mnist_test_labels.npy')# 显示第一张图像和其标签plt.imshow(train_images[0], cmap='gray')plt.title('Label: ' + str(train_labels[0]))plt.show()```我们可以看到,第一张训练图像对应的标签是5。

使用同样的方法,我们可以查看其他图像以及其标签。

我们可以将每个28x28的图像展开成784维的向量,这样更方便我们后续的处理。

同时,由于像素值已经在0-255的范围内,我们可以将其归一化到0-1的范围。

代码如下:```python# 将图像展开成一维向量,并归一化train_images = train_images.reshape(-1, 28*28) \/ 255.0test_images = test_images.reshape(-1, 28*28) \/ 255.0```我们还要注意到,在进行机器学习训练过程中,我们需要将数据集分成训练集和验证集。

一般来说,我们将60,000张训练图像中的前50,000张作为训练集,后10,000张作为验证集。

代码如下:```python# 将训练数据分成训练集和验证集train_images_train = train_images[:50000]train_labels_train = train_labels[:50000]train_images_val = train_images[50000:]train_labels_val = train_labels[50000:]```二、模型构建在进行模型构建前,我们需要了解机器学习中常用的分类算法。

常见的分类算法包括逻辑回归、决策树、支持向量机和神经网络等。

而在本文中,我们将使用神经网络模型。

神经网络模型由输入层、中间层和输出层组成。

在手写数字识别中,输入层有784个神经元,对应28x28的图像。

输出层有10个神经元,对应0-9的10个数字。

我们可以采用多个中间层来提高模型性能,这里我们选用了两个中间层,分别包含128个和64个神经元。

代码如下:```pythonimport tensorflow.keras as keras# 构建神经网络模型model = keras.Sequential([yers.Dense(128, activation='relu', input_shape=(784,)), yers.Dense(64, activation='relu'),yers.Dense(10, activation='softmax')])```三、模型训练构建完模型后,我们需要定义损失函数和优化器,同时设置训练批次大小、训练轮数等参数。

在本文中,我们采用交叉熵损失函数和Adam优化器。

代码如下:```python#编译模型pile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])# 设置训练参数batch_size = 128epochs = 10# 训练模型history = model.fit(train_images_train, keras.utils.to_categorical(train_labels_train),batch_size=batch_size, epochs=epochs, validation_data=(train_images_val,keras.utils.to_categorical(train_labels_val)))```在训练过程中,我们还可以打印出模型在训练集和验证集上的准确率和损失值,以及可视化训练过程中的准确率和损失变化情况。

代码如下:```python# 输出模型在训练集和验证集上的准确率和损失值train_loss, train_accuracy = model.evaluate(train_images_train, keras.utils.to_categorical(train_labels_train), verbose=1)val_loss, val_accuracy = model.evaluate(train_images_val, keras.utils.to_categorical(train_labels_val), verbose=1)print('Training loss:', train_loss)print('Training accuracy:', train_accuracy)print('Validation loss:', val_loss)print('Validation accuracy:', val_accuracy)# 可视化训练过程中的准确率和损失变化情况plt.plot(history.history['accuracy'], label='Training accuracy') plt.plot(history.history['val_accuracy'], label='Validation accuracy')plt.title('Training and validation accuracy')plt.xlabel('Epoch')plt.ylabel('Accuracy')plt.legend()plt.show()plt.plot(history.history['loss'], label='Training loss')plt.plot(history.history['val_loss'], label='Validation loss') plt.title('Training and validation loss')plt.xlabel('Epoch')plt.ylabel('Loss')plt.legend()plt.show()```四、模型预测最后,我们可以使用训练好的模型进行手写数字识别预测。

代码如下:```python# 进行预测predictions = model.predict(test_images)# 取概率最大的标签作为预测结果predicted_labels = np.argmax(predictions, axis=1)# 输出前20个预测结果print('Prediction:', predicted_labels[:20])print('Ground truth:', test_labels[:20])# 显示预测错误的图像以及预测结果for i in range(len(predicted_labels)):if predicted_labels[i] != test_labels[i]:print('Error: predicted label is', predicted_labels[i], ', but the ground truth is', test_labels[i])plt.imshow(test_images[i].reshape(28, 28), cmap='gray')plt.title('Error: predicted label is '+str(predicted_labels[i])+', but the ground truth is '+str(test_labels[i]))plt.show()```从结果可以看出,模型在大部分图像上识别正确,但仍有一些图像识别错误。

这表明我们的模型仍有提升空间,可以进行参数调整或使用更复杂的模型来提高准确率。

经过本文的介绍,我们了解了如何使用Python和机器学习算法来实现手写数字识别。

通过对MNIST数据集的实践,我们可以更深入地了解机器学习的工作原理和使用方法,对于进一步探索机器学习应用具有很好的参考价值。

相关文档
最新文档