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


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




import mnist_loader

import network

training_data, validation_data, test_data = mnist_loader.load_data_wrapper()  






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


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



               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


           activation = sigmoid(z)


       # backward pass

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


       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



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

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


   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


   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


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

   e[j] = 1.0

   return e


9499 0
简述 在网络操作中,经常会由于各种原因引起网络连接超时,究竟何为网络连接超时? 网络连接超时:在程序默认的等待时间内没有得到服务器的响应 简述 超时原因 Qt 中的网络连接超时 如何处理超时 封装类 超时原因 引起网络连接超时的原因很多,下面,列举一些常见的原因: 网络断开,不过经常显示无法连接 网络阻塞,导致你不能在程序默认等待时间
3817 0
django rest_framework比较完整的自定义实现样例
里面有自定义的更新策略, 序列化时,考虑nest及显示。 很有参考意义。 然后,前端,可以考虑用angular.js或vue.js实现。 每次以token进行认证。 url.py router = DefaultRouter() router.
1480 0
1099 0
unity本地缓存 WWW.LoadFromCacheOrDownload (string url,int version) http协议 1 2 3 4 5 6 7 8...
840 0
9493 0
4174 0
TensorFlow 卷积神经网络手写数字识别数据集介绍
欢迎大家关注我们的网站和系列教程:http://www.tensorflownews.com/,学习更多的机器学习、深度学习的知识! 手写数字识别 接下来将会以 MNIST 数据集为例,使用卷积层和池化层,实现一个卷积神经网络来进行手写数字识别,并输出卷积和池化效果。
1461 0