python构建深度神经网络(DNN)

本文学习Neural Networks and Deep Learning 在线免费书籍,用python构建神经网络识别手写体的一个总结。

代码主要包括两三部分:

1)、数据调用和预处理

2)、神经网络类构建和方法建立

3)、代码测试文件

1)数据调用:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time  : 2017-03-12 15:11
# @Author : CC
# @File  : net_load_data.py
# @Software: PyCharm Community Edition 

from numpy import *
import numpy as np
import cPickle
def load_data():
  """载入解压后的数据,并读取"""
  with open('data/mnist_pkl/mnist.pkl','rb') as f:
    try:
      train_data,validation_data,test_data = cPickle.load(f)
      print " the file open sucessfully"
      # print train_data[0].shape #(50000,784)
      # print train_data[1].shape  #(50000,)
      return (train_data,validation_data,test_data)
    except EOFError:
      print 'the file open error'
      return None 

def data_transform():
  """将数据转化为计算格式"""
  t_d,va_d,te_d = load_data()
  # print t_d[0].shape # (50000,784)
  # print te_d[0].shape # (10000,784)
  # print va_d[0].shape # (10000,784)
  # n1 = [np.reshape(x,784,1) for x in t_d[0]] # 将5万个数据分别逐个取出化成(784,1),逐个排列
  n = [np.reshape(x, (784, 1)) for x in t_d[0]] # 将5万个数据分别逐个取出化成(784,1),逐个排列
  # print 'n1',n1[0].shape
  # print 'n',n[0].shape
  m = [vectors(y) for y in t_d[1]] # 将5万标签(50000,1)化为(10,50000)
  train_data = zip(n,m) # 将数据与标签打包成元组形式
  n = [np.reshape(x, (784, 1)) for x in va_d[0]] # 将5万个数据分别逐个取出化成(784,1),排列
  validation_data = zip(n,va_d[1])  # 没有将标签数据矢量化
  n = [np.reshape(x, (784, 1)) for x in te_d[0]] # 将5万个数据分别逐个取出化成(784,1),排列
  test_data = zip(n, te_d[1]) # 没有将标签数据矢量化
  # print train_data[0][0].shape #(784,)
  # print "len(train_data[0])",len(train_data[0]) #2
  # print "len(train_data[100])",len(train_data[100]) #2
  # print "len(train_data[0][0])", len(train_data[0][0]) #784
  # print "train_data[0][0].shape", train_data[0][0].shape #(784,1)
  # print "len(train_data)", len(train_data) #50000
  # print train_data[0][1].shape #(10,1)
  # print test_data[0][1] # 7
  return (train_data,validation_data,test_data)
def vectors(y):
  """赋予标签"""
  label = np.zeros((10,1))
  label[y] = 1.0 #浮点计算
  return label

2)网络构建

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time  : 2017-03-12 16:07
# @Author : CC
# @File  : net_network.py 

import numpy as np
import random
class Network(object):  #默认为基类?用于继承:print isinstance(network,object)
  def __init__(self,sizes):
    self.num_layers = len(sizes)
    self.sizes = sizes
    # print 'num_layers', self.num_layers
    self.weight = [np.random.randn(a1, a2) for (a1, a2) in zip(sizes[1:], sizes[:-1])] #产生一个个数组
    self.bias = [np.random.randn(a3,1) for a3 in sizes[1:]]
    # print self.weight[0].shape #(20,10) 

  def SGD(self,train_data,min_batch_size,epoches,eta,test_data=False):
    """ 1) 打乱样本,将训练数据划分成小批次
      2)计算出反向传播梯度
      3) 获得权重更新"""
    if test_data: n_test = len(test_data)
    n = len(train_data)  #50000
    random.shuffle(train_data) # 打乱
    min_batches = [train_data[k:k+min_batch_size] for k in xrange(0,n,min_batch_size)] #提取批次数据
    for k in xrange(0,epoches):  #利用更新后的权值继续更新
      random.shuffle(train_data) # 打乱
      for min_batch in min_batches: #逐个传入,效率很低
        self.updata_parameter(min_batch,eta)
      if test_data:
        num = self.evaluate(test_data)
        print "the {0}th epoches: {1}/{2}".format(k,num,len(test_data))
      else:
        print 'epoches {0} completed'.format(k) 

  def forward(self,x):
    """获得各层激活值"""
    for w,b in zip(self.weight,self.bias):
      x = sigmoid(np.dot(w, x)+b)
    return x 

  def updata_parameter(self,min_batch,eta):
    """1) 反向传播计算每个样本梯度值
      2) 累加每个批次样本的梯度值
      3) 权值更新"""
    ndeltab = [np.zeros(b.shape) for b in self.bias]
    ndeltaw = [np.zeros(w.shape) for w in self.weight]
    for x,y in min_batch:
      deltab,deltaw = self.backprop(x,y)
      ndeltab = [nb +db for nb,db in zip(ndeltab,deltab)]
      ndeltaw = [nw + dw for nw,dw in zip(ndeltaw,deltaw)]
    self.bias = [b - eta * ndb/len(min_batch) for ndb,b in zip(ndeltab,self.bias)]
    self.weight = [w - eta * ndw/len(min_batch) for ndw,w in zip(ndeltaw,self.weight)] 

  def backprop(self,x,y):
    """执行前向计算,再进行反向传播,返回deltaw,deltab"""
    # [w for w in self.weight]
    # print 'len',len(w)
    # print "self.weight",self.weight[0].shape
    # print w[0].shape
    # print w[1].shape
    # print w.shape
    activation = x
    activations = [x]
    zs = []
    # feedforward
    for w, b in zip(self.weight, self.bias):
      # print w.shape,activation.shape,b.shape
      z = np.dot(w, activation) +b
      zs.append(z)  #用于计算f(z)导数
      activation = sigmoid(z)
      # print 'activation',activation.shape
      activations.append(activation) # 每层的输出结果
    delta = self.top_subtract(activations[-1],y) * dsigmoid(zs[-1]) #最后一层的delta,np.array乘,相同维度乘
    deltaw = [np.zeros(w1.shape) for w1 in self.weight] #每一次将获得的值作为列表形式赋给deltaw
    deltab = [np.zeros(b1.shape) for b1 in self.bias]
    # print 'deltab[0]',deltab[-1].shape
    deltab[-1] = delta
    deltaw[-1] = np.dot(delta,activations[-2].transpose())
    for k in xrange(2,self.num_layers):
      delta = np.dot(self.weight[-k+1].transpose(),delta) * dsigmoid(zs[-k])
      deltab[-k] = delta
      deltaw[-k] = np.dot(delta,activations[-k-1].transpose())
    return (deltab,deltaw) 

  def evaluate(self,test_data):
    """评估验证集和测试集的精度,标签直接一个数作为比较"""
    z = [(np.argmax(self.forward(x)),y) for x,y in test_data]
    zs = np.sum(int(a == b) for a,b in z)
    # zk = sum(int(a == b) for a,b in z)
    # print "zs/zk:",zs,zk
    return zs 

  def top_subtract(self,x,y):
    return (x - y) 

def sigmoid(x):
  return 1.0/(1.0+np.exp(-x)) 

def dsigmoid(x):
  z = sigmoid(x)
  return z*(1-z)

3)网络测试

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time  : 2017-03-12 15:24
# @Author : CC
# @File  : net_test.py 

import net_load_data
# net_load_data.load_data()
train_data,validation_data,test_data = net_load_data.data_transform() 

import net_network as net
net1 = net.Network([784,30,10])
min_batch_size = 10
eta = 3.0
epoches = 30
net1.SGD(train_data,min_batch_size,epoches,eta,test_data)
print "complete"

4)结果

the 9th epoches: 9405/10000
the 10th epoches: 9420/10000
the 11th epoches: 9385/10000
the 12th epoches: 9404/10000
the 13th epoches: 9398/10000
the 14th epoches: 9406/10000
the 15th epoches: 9396/10000
the 16th epoches: 9413/10000
the 17th epoches: 9405/10000
the 18th epoches: 9425/10000
the 19th epoches: 9420/10000

总体来说这本书的实例,用来熟悉python和神经网络非常好。

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

您可能感兴趣的文章:

  • python构建深度神经网络(续)
  • python实现简单神经网络算法
  • Python实现的三层BP神经网络算法示例
  • Python实现的径向基(RBF)神经网络示例
  • Python编程实现的简单神经网络算法示例
  • python实现神经网络感知器算法
  • python机器学习之神经网络(三)
  • python机器学习之神经网络(一)
  • Python实现感知器模型、两层神经网络
  • TensorFlow平台下Python实现神经网络
(0)

相关推荐

  • python机器学习之神经网络(一)

    python有专门的神经网络库,但为了加深印象,我自己在numpy库的基础上,自己编写了一个简单的神经网络程序,是基于Rosenblatt感知器的,这个感知器建立在一个线性神经元之上,神经元模型的求和节点计算作用于突触输入的线性组合,同时结合外部作用的偏置,对若干个突触的输入求和后进行调节.为了便于观察,这里的数据采用二维数据. 目标函数是训练结果的误差的平方和,由于目标函数是一个二次函数,只存在一个全局极小值,所以采用梯度下降法的策略寻找目标函数的最小值. 代码如下: import numpy

  • Python编程实现的简单神经网络算法示例

    本文实例讲述了Python编程实现的简单神经网络算法.分享给大家供大家参考,具体如下: python实现二层神经网络 包括输入层和输出层 # -*- coding:utf-8 -*- #! python2 import numpy as np #sigmoid function def nonlin(x, deriv = False): if(deriv == True): return x*(1-x) return 1/(1+np.exp(-x)) #input dataset x = np.

  • python实现神经网络感知器算法

    现在我们用python代码实现感知器算法. # -*- coding: utf-8 -*- import numpy as np class Perceptron(object): """ eta:学习率 n_iter:权重向量的训练次数 w_:神经分叉权重向量 errors_:用于记录神经元判断出错次数 """ def __init__(self, eta=0.01, n_iter=2): self.eta = eta self.n_iter

  • Python实现的径向基(RBF)神经网络示例

    本文实例讲述了Python实现的径向基(RBF)神经网络.分享给大家供大家参考,具体如下: from numpy import array, append, vstack, transpose, reshape, \ dot, true_divide, mean, exp, sqrt, log, \ loadtxt, savetxt, zeros, frombuffer from numpy.linalg import norm, lstsq from multiprocessing impor

  • TensorFlow平台下Python实现神经网络

    本篇文章主要通过一个简单的例子来实现神经网络.训练数据是随机产生的模拟数据集,解决二分类问题. 下面我们首先说一下,训练神经网络的一般过程: 1.定义神经网络的结构和前向传播的输出结果 2.定义损失函数以及反向传播优化的算法 3.生成会话(Session)并且在训练数据上反复运行反向传播优化算法 要记住的一点是,无论神经网络的结构如何变化,以上三个步骤是不会改变的. 完整代码如下: import tensorflow as tf #导入TensorFlow工具包并简称为tf from numpy

  • python实现简单神经网络算法

    python实现简单神经网络算法,供大家参考,具体内容如下 python实现二层神经网络 包括输入层和输出层 import numpy as np #sigmoid function def nonlin(x, deriv = False): if(deriv == True): return x*(1-x) return 1/(1+np.exp(-x)) #input dataset x = np.array([[0,0,1], [0,1,1], [1,0,1], [1,1,1]]) #out

  • python机器学习之神经网络(三)

    前面两篇文章都是参考书本神经网络的原理,一步步写的代码,这篇博文里主要学习了如何使用neurolab库中的函数来实现神经网络的算法. 首先介绍一下neurolab库的配置: 选择你所需要的版本进行下载,下载完成后解压. neurolab需要采用python安装第三方软件包的方式进行安装,这里介绍一种安装方式: (1)进入cmd窗口 (2)进入解压文件所在目录下 (3)输入 setup.py install 这样,在python安装目录的Python27\Lib\site-packages下,就可

  • python构建深度神经网络(续)

    这篇文章在前一篇文章:python构建深度神经网络(DNN)的基础上,添加了一下几个内容: 1) 正则化项 2) 调出中间损失函数的输出 3) 构建了交叉损失函数 4) 将训练好的网络进行保存,并调用用来测试新数据 1  数据预处理 #!/usr/bin/env python # -*- coding: utf-8 -*- # @Time : 2017-03-12 15:11 # @Author : CC # @File : net_load_data.py from numpy import

  • Python实现感知器模型、两层神经网络

    本文实例为大家分享了Python实现感知器模型.两层神经网络,供大家参考,具体内容如下 python 3.4 因为使用了 numpy 这里我们首先实现一个感知器模型来实现下面的对应关系 [[0,0,1], --- 0 [0,1,1], --- 1 [1,0,1], --- 0 [1,1,1]] --- 1 从上面的数据可以看出:输入是三通道,输出是单通道. 这里的激活函数我们使用 sigmoid 函数 f(x)=1/(1+exp(-x)) 其导数推导如下所示: L0=W*X; z=f(L0);

  • Python实现的三层BP神经网络算法示例

    本文实例讲述了Python实现的三层BP神经网络算法.分享给大家供大家参考,具体如下: 这是一个非常漂亮的三层反向传播神经网络的python实现,下一步我准备试着将其修改为多层BP神经网络. 下面是运行演示函数的截图,你会发现预测的结果很惊人! 提示:运行演示函数的时候,可以尝试改变隐藏层的节点数,看节点数增加了,预测的精度会否提升 import math import random import string random.seed(0) # 生成区间[a, b)内的随机数 def rand(

随机推荐