DL之NN:利用(本地数据集50000张数据集)调用自定义神经网络network.py实现手写数字图片识别94%准确率-阿里云开发者社区

开发者社区> 一个处女座的程序猿> 正文

DL之NN:利用(本地数据集50000张数据集)调用自定义神经网络network.py实现手写数字图片识别94%准确率

简介: DL之NN:利用(本地数据集50000张数据集)调用自定义神经网络network.py实现手写数字图片识别94%准确率
+关注继续查看

输出结果


更新……



代码设计


import mnist_loader

import network

training_data, validation_data, test_data = mnist_loader.load_data_wrapper()  

print("training_data")  

print(type(training_data))

print(list(training_data))    

print(training_data[0][0].shape)  

print(training_data[0][1].shape)  

net = network.Network([784, 30, 10])

net.SGD(training_data, 30, 10, 3.0, test_data=test_data)

import random  

import numpy as np

class Network(object):        

   def __init__(self, sizes):

       """The list ``sizes`` contains the number of neurons in the

       respective layers of the network.  For example, if the list

       was [2, 3, 1] then it would be a three-layer network, with the

       first layer containing 2 neurons, the second layer 3 neurons,

       and the third layer 1 neuron.  The biases and weights for the

       network are initialized randomly, using a Gaussian

       distribution with mean 0, and variance 1.  Note that the first

       layer is assumed to be an input layer, and by convention we

       won't set any biases for those neurons, since biases are only

       ever used in computing the outputs from later layers."""

       self.num_layers = len(sizes)

       self.sizes = sizes          

       self.biases = [np.random.randn(y, 1) for y in sizes[1:]]

 

       self.weights = [np.random.randn(y, x) for x, y in zip(sizes[:-1], sizes[1:])]

       

   def feedforward(self, a):  

       """Return the output of the network if ``a`` is input."""

       for b, w in zip(self.biases, self.weights):

           a = sigmoid(np.dot(w, a)+b)

       return a

   def SGD(self, training_data, epochs, mini_batch_size, eta, test_data=None):

       """Train the neural network using mini-batch stochastic

       gradient descent.  The ``training_data`` is a list of tuples

       ``(x, y)`` representing the training inputs and the desired

       outputs.  The other non-optional parameters are

       self-explanatory.  If ``test_data`` is provided then the

       network will be evaluated against the test data after each

       epoch, and partial progress printed out.  This is useful for

       tracking progress, but slows things down substantially."""

       if test_data:              

           n_test = len(test_data)

           n = len(training_data)

       for j in xrange(epochs):    

           random.shuffle(training_data)

           mini_batches = [training_data[k:k+mini_batch_size]

               for k in xrange(0, n, mini_batch_size)]  

           for mini_batch in mini_batches:    

               self.update_mini_batch(mini_batch, eta)

           if test_data:              

               print ("Epoch {0}: {1} / {2}".format(j, self.evaluate(test_data), n_test))

             

           else:

               print ("Epoch {0} complete".format(j))

   def update_mini_batch(self, mini_batch, eta):  

       """Update the network's weights and biases by applying

       gradient descent using backpropagation to a single mini batch.

       The ``mini_batch`` is a list of tuples ``(x, y)``, and ``eta``

       is the learning rate."""

       nabla_b = [np.zeros(b.shape) for b in self.biases]  

       nabla_w = [np.zeros(w.shape) for w in self.weights]

       for x, y in mini_batch:  

           delta_nabla_b, delta_nabla_w = self.backprop(x, y)  

           nabla_b = [nb+dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]  

           nabla_w = [nw+dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]

       self.weights = [w-(eta/len(mini_batch))*nw for w, nw in zip(self.weights, nabla_w)]

     

       self.biases = [b-(eta/len(mini_batch))*nb  for b, nb in zip(self.biases, nabla_b)]

   

   def backprop(self, x, y):  

       """Return a tuple ``(nabla_b, nabla_w)`` representing the

       gradient for the cost function C_x.  ``nabla_b`` and

       ``nabla_w`` are layer-by-layer lists of numpy arrays, similar

       to ``self.biases`` and ``self.weights``."""

       nabla_b = [np.zeros(b.shape) for b in self.biases]

       nabla_w = [np.zeros(w.shape) for w in self.weights]

       # feedforward

       activation = x

       activations = [x] # list to store all the activations, layer by layer

       zs = [] # list to store all the z vectors, layer by layer

       for b, w in zip(self.biases, self.weights):

           z = np.dot(w, activation)+b

           zs.append(z)

           activation = sigmoid(z)

           activations.append(activation)

       # backward pass

       delta = self.cost_derivative(activations[-1], y) * \

           sigmoid_prime(zs[-1])

       nabla_b[-1] = delta

       nabla_w[-1] = np.dot(delta, activations[-2].transpose())

       # Note that the variable l in the loop below is used a little

       # differently to the notation in Chapter 2 of the book.  Here,

       # l = 1 means the last layer of neurons, l = 2 is the

       # second-last layer, and so on.  It's a renumbering of the

       # scheme in the book, used here to take advantage of the fact

       # that Python can use negative indices in lists.

       for l in xrange(2, self.num_layers):

           z = zs[-l]

           sp = sigmoid_prime(z)

           delta = np.dot(self.weights[-l+1].transpose(), delta) * sp

           nabla_b[-l] = delta

           nabla_w[-l] = np.dot(delta, activations[-l-1].transpose())

       return (nabla_b, nabla_w)

   def evaluate(self, test_data):#评估,

       """Return the number of test inputs for which the neural

       network outputs the correct result. Note that the neural

       network's output is assumed to be the index of whichever

       neuron in the final layer has the highest activation."""

       test_results = [(np.argmax(self.feedforward(x)), y)

                       for (x, y) in test_data]

       return sum(int(x == y) for (x, y) in test_results)

   def cost_derivative(self, output_activations, y):  

       """Return the vector of partial derivatives \partial C_x /

       \partial a for the output activations."""

       return (output_activations-y)

def sigmoid(z):  

   """The sigmoid function."""

   return 1.0/(1.0+np.exp(-z))

def sigmoid_prime(z):

   """Derivative of the sigmoid function."""

   return sigmoid(z)*(1-sigmoid(z))

import pickle as cPickle

import gzip

import numpy as np

def load_data():

   """Return the MNIST data as a tuple containing the training data,

   the validation data, and the test data.

   The ``training_data`` is returned as a tuple with two entries.

   The first entry contains the actual training images.  This is a

   numpy ndarray with 50,000 entries.  Each entry is, in turn, a

   numpy ndarray with 784 values, representing the 28 * 28 = 784

   pixels in a single MNIST image.

   The second entry in the ``training_data`` tuple is a numpy ndarray

   containing 50,000 entries.  Those entries are just the digit

   values (0...9) for the corresponding images contained in the first

   entry of the tuple.

   The ``validation_data`` and ``test_data`` are similar, except

   each contains only 10,000 images.

   This is a nice data format, but for use in neural networks it's

   helpful to modify the format of the ``training_data`` a little.

   That's done in the wrapper function ``load_data_wrapper()``, see

   below.

   """

   f = gzip.open('../data/mnist.pkl.gz', 'rb')

   training_data, validation_data, test_data = cPickle.load(f,encoding='bytes')  #(f,encoding='bytes')

   f.close()

   return (training_data, validation_data, test_data)

def load_data_wrapper():

   """Return a tuple containing ``(training_data, validation_data,

   test_data)``. Based on ``load_data``, but the format is more

   convenient for use in our implementation of neural networks.

   In particular, ``training_data`` is a list containing 50,000

   2-tuples ``(x, y)``.  ``x`` is a 784-dimensional numpy.ndarray

   containing the input image.  ``y`` is a 10-dimensional

   numpy.ndarray representing the unit vector corresponding to the

   correct digit for ``x``.

   ``validation_data`` and ``test_data`` are lists containing 10,000

   2-tuples ``(x, y)``.  In each case, ``x`` is a 784-dimensional

   numpy.ndarry containing the input image, and ``y`` is the

   corresponding classification, i.e., the digit values (integers)

   corresponding to ``x``.

   Obviously, this means we're using slightly different formats for

   the training data and the validation / test data.  These formats

   turn out to be the most convenient for use in our neural network

   code."""

   tr_d, va_d, te_d = load_data()

   training_inputs = [np.reshape(x, (784, 1)) for x in tr_d[0]]

   training_results = [vectorized_result(y) for y in tr_d[1]]

   training_data = zip(training_inputs, training_results)

   validation_inputs = [np.reshape(x, (784, 1)) for x in va_d[0]]

   validation_data = zip(validation_inputs, va_d[1])

   test_inputs = [np.reshape(x, (784, 1)) for x in te_d[0]]

   test_data = zip(test_inputs, te_d[1])

   return (training_data, validation_data, test_data)

def vectorized_result(j):

   """Return a 10-dimensional unit vector with a 1.0 in the jth

   position and zeroes elsewhere.  This is used to convert a digit

   (0...9) into a corresponding desired output from the neural

   network."""

   e = np.zeros((10, 1))

   e[j] = 1.0

   return e


版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
纯Python实现鸢尾属植物数据集神经网络模型
本文以Python代码完成整个鸾尾花图像分类任务,没有调用任何的数据包,适合新手阅读理解,并动手实践体验下机器学习方法的大致流程。
9499 0
Qt之处理QNetworkAccessManager网络连接超时
简述 在网络操作中,经常会由于各种原因引起网络连接超时,究竟何为网络连接超时? 网络连接超时:在程序默认的等待时间内没有得到服务器的响应 简述 超时原因 Qt 中的网络连接超时 如何处理超时 封装类 超时原因 引起网络连接超时的原因很多,下面,列举一些常见的原因: 网络断开,不过经常显示无法连接 网络阻塞,导致你不能在程序默认等待时间
3817 0
django rest_framework比较完整的自定义实现样例
里面有自定义的更新策略, 序列化时,考虑nest及显示。 很有参考意义。 然后,前端,可以考虑用angular.js或vue.js实现。 每次以token进行认证。 url.py router = DefaultRouter() router.
1480 0
Flink运行时之网络通信NetworkEnvironment分析
网络环境(NetworkEnvironment)是TaskManager进行网络通信的主对象,主要用于跟踪中间结果并负责所有的数据交换。每个TaskManager的实例都包含一个网络环境对象,在TaskManager启动时创建。
1099 0
[unity3d]网络文件本地存储的四种方式
unity本地缓存 WWW.LoadFromCacheOrDownload (string url,int version) http协议 1 2 3 4 5 6 7 8...
840 0
智能数据引擎Dataphin重磅发布,提供一站式的技术管理能力
面对各行各业日趋强烈的大数据建设、管理及应用诉求,2018年2月28日MWC大会,阿里云重磅推出了智能数据构建与管理平台Dataphin——从数据接入到数据消费全链路,提供一站式的大数据能力,包括产品、技术和方法论等,致力于助力企业打造标准统一、融会贯通、资产化、服务化、闭环自优化的智能数据体系。
9493 0
Netflix开源面向稀疏数据优化的轻量级神经网络库Vectorflow
在Netflix公司,我们的机器学习科学家在多个不同的领域处理着各种各样的问题:从根据你的爱好来定制电视和推荐电影,到优化编码算法。我们有一小部分问题涉及到处理极其稀疏的数据;手头问题的总维度数很容易就能达到数千万个特征,即使每次要看的可能只是少数的非零项。
4174 0
TensorFlow 卷积神经网络手写数字识别数据集介绍
欢迎大家关注我们的网站和系列教程:http://www.tensorflownews.com/,学习更多的机器学习、深度学习的知识! 手写数字识别 接下来将会以 MNIST 数据集为例,使用卷积层和池化层,实现一个卷积神经网络来进行手写数字识别,并输出卷积和池化效果。
1461 0
+关注
一个处女座的程序猿
国内互联网圈知名博主、人工智能领域优秀创作者,全球最大中文IT社区博客专家、CSDN开发者联盟生态成员、中国开源社区专家、华为云社区专家、51CTO社区专家、Python社区专家等,曾受邀采访和评审十多次。仅在国内的CSDN平台,博客文章浏览量超过2500万,拥有超过57万的粉丝。
1701
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
文娱运维技术
立即下载
《SaaS模式云原生数据仓库应用场景实践》
立即下载
《看见新力量:二》电子书
立即下载