个人中心
gpt4 book ai didi

python构建深度神经网络（续）

转载 作者：qq735679552 更新时间：2022-09-28 22:32:09 25 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章python构建深度神经网络（续）由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

这篇文章在前一篇文章：python构建深度神经网络（DNN）的基础上，添加了一下几个内容:

1) 正则化项 。

2） 调出中间损失函数的输出 。

3） 构建了交叉损失函数 。

4） 将训练好的网络进行保存，并调用用来测试新数据 。

1  数据预处理 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2017-03-12 15:11
# @Author : CC
# @File : net_load_data.py
 
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 网络定义和训练 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2017-03-28 10:18
# @Author : CC
# @File : net_network2.py
 
from numpy import *
import numpy as np
import operator
import json
# import sys
 
class QuadraticCost():
  """定义二次代价函数类的方法"""
  @staticmethod
  def fn(a,y):
   cost = 0.5 * np.linalg.norm(a - y) * * 2
   return cost
  @staticmethod
  def delta(z,a,y):
   delta = (a - y) * sig_derivate(z)
   return delta
 
class CrossEntroyCost():
  """定义交叉熵函数类的方法"""
  @staticmethod
  def fn(a, y):
   cost = np. sum (np.nan_to_num( - y * np.log(a) - ( 1 - y) * np.log( 1 - a))) # not a number---0, inf---larger number
   return cost
  @staticmethod
  def delta(z, a, y):
   delta = (a - y)
   return delta
 
class Network( object ):
  """定义网络结构和方法"""
  def __init__( self ,sizes,cost):
   self .num_layer = len (sizes)
   self .sizes = sizes
   self .cost = cost
   # print "self.cost.__name__:",self.cost.__name__ # CrossEntropyCost
   self .default_weight_initializer()
  def default_weight_initializer( self ):
   """权值初始化"""
   self .bias = [np.random.rand(x, 1 ) for x in self .sizes[ 1 :]]
   self .weight = [np.random.randn(y, x) / float (np.sqrt(x)) for (x, y) in zip ( self .sizes[: - 1 ], self .sizes[ 1 :])]
 
  def large_weight_initializer( self ):
   """权值另一种初始化"""
   self .bias = [np.random.rand(x, 1 ) for x in self .sizes[ 1 :]]
   self .weight = [np.random.randn(y, x) for x, y in zip ( self .sizes[: - 1 ], self .sizes[ 1 :])]
  def forward( self ,a):
   """forward the network"""
   for w,b in zip ( self .weight, self .bias):
    a = sigmoid(np.dot(w,a) + b)
   return a
 
  def SGD( self ,train_data,min_batch_size,epochs,eta,test_data = False ,
    lambd = 0 ,
    monitor_train_cost = False ,
    monitor_train_accuracy = False ,
    monitor_test_cost = False ,
    monitor_test_accuracy = False
    ):
   """1)Set the train_data,shuffle;
    2) loop the epoches,
    3) set the min_batches,and rule of update"""
   if test_data: n_test = len (test_data)
   n = len (train_data)
   for i in xrange (epochs):
    random.shuffle(train_data)
    min_batches = [train_data[k:k + min_batch_size] for k in xrange ( 0 ,n,min_batch_size)]
 
    for min_batch in min_batches: # 每次提取一个批次的样本
     self .update_minbatch_parameter(min_batch,eta,lambd,n)
    train_cost = []
    if monitor_train_cost:
     cost1 = self .total_cost(train_data,lambd,cont = False )
     train_cost.append(cost1)
     print "epoche {0},train_cost: {1}" . format (i,cost1)
    if monitor_train_accuracy:
     accuracy = self .accuracy(train_data,cont = True )
     train_cost.append(accuracy)
     print "epoche {0}/{1},train_accuracy: {2}" . format (i,epochs,accuracy)
    test_cost = []
    if monitor_test_cost:
     cost1 = self .total_cost(test_data,lambd)
     test_cost.append(cost1)
     print "epoche {0},test_cost: {1}" . format (i,cost1)
    test_accuracy = []
    if monitor_test_accuracy:
     accuracy = self .accuracy(test_data)
     test_cost.append(accuracy)
     print "epoche:{0}/{1},test_accuracy:{2}" . format (i,epochs,accuracy)
   self .save(filename = "net_save" ) #保存网络网络参数
 
  def total_cost( self ,train_data,lambd,cont = True ):
   cost1 = 0.0
   for x,y in train_data:
    a = self .forward(x)
    if cont: y = vectors(y) #将测试样本标签化为矩阵
    cost1 + = ( self .cost).fn(a,y) / len (train_data)
   cost1 + = lambd / len (train_data) * np. sum (np.linalg.norm(weight) * * 2 for weight in self .weight) #加上权值项
   return cost1
  def accuracy( self ,train_data,cont = False ):
   if cont:
    output1 = [(np.argmax( self .forward(x)),np.argmax(y)) for (x,y) in train_data]
   else :
    output1 = [(np.argmax( self .forward(x)), y) for (x, y) in train_data]
   return sum ( int (out1 = = y) for (out1, y) in output1)
  def update_minbatch_parameter( self ,min_batch, eta,lambd,n):
   """1) determine the weight and bias
    2) calculate the the delta
    3) update the data """
   able_b = [np.zeros(b.shape) for b in self .bias]
   able_w = [np.zeros(w.shape) for w in self .weight]
   for x,y in min_batch: #每次只取一个样本？
    deltab,deltaw = self .backprop(x,y)
    able_b = [a_b + dab for a_b, dab in zip (able_b,deltab)] #实际上对dw,db做批次累加，最后小批次取平均
    able_w = [a_w + daw for a_w, daw in zip (able_w, deltaw)]
   self .weight = [weight - eta * (dw) / len (min_batch) - eta * (lambd * weight) / n for weight, dw in zip ( self .weight,able_w) ]
   #增加正则化项：eta*lambda/m *weight
   self .bias = [bias - eta * db / len (min_batch) for bias, db in zip ( self .bias, able_b)]
 
  def backprop( self ,x,y):
   """" 1) clacu the forward value
    2) calcu the delta： delta =(y-f(z)); deltak = delta*w(k)*fz(k-1)'
    3) clacu the delta in every layer: deltab=delta; deltaw=delta*fz(k-1)"""
   deltab = [np.zeros(b.shape) for b in self .bias]
   deltaw = [np.zeros(w.shape) for w in self .weight]
   zs = []
   activate = x
   activates = [x]
   for w,b in zip ( self .weight, self .bias):
    z = np.dot(w, activate) + b
    zs.append(z)
    activate = sigmoid(z)
    activates.append(activate)
    # backprop
   delta = self .cost.delta(zs[ - 1 ],activates[ - 1 ],y) #调用不同代价函数的方法求梯度
   deltab[ - 1 ] = delta
   deltaw[ - 1 ] = np.dot(delta ,activates[ - 2 ].transpose())
   for i in xrange ( 2 , self .num_layer):
    z = zs[ - i]
    delta = np.dot( self .weight[ - i + 1 ].transpose(),delta) * sig_derivate(z)
    deltab[ - i] = delta
    deltaw[ - i] = np.dot(delta,activates[ - i - 1 ].transpose())
   return (deltab,deltaw)
 
  def save( self ,filename):
   """将训练好的网络采用json(java script object notation)将对象保存成字符串保存，用于生产部署
   encoder=json.dumps(data)
   python 原始类型(没有数组类型)向 json 类型的转化对照表：
    python    json
    dict    object
   list/tuple   arrary
   int/long/float  number
   .tolist() 将数组转化为列表
   >>> a = np.array([[1, 2], [3, 4]])
   >>> list(a)
   [array([1, 2]), array([3, 4])]
   >>> a.tolist()
   [[1, 2], [3, 4]]
   """
   data = { "sizes" : self .sizes, "weight" : [weight.tolist() for weight in self .weight],
     "bias" : ([bias.tolist() for bias in self .bias]),
     "cost" : str ( self .cost.__name__)}
   # 保存网络训练好的权值，偏置，交叉熵参数。
   f = open (filename, "w" )
   json.dump(data,f)
   f.close()
 
def load_net(filename):
  """采用data=json.load(json.dumps(data))进行解码，
  decoder = json.load(encoder)
  编码后和解码后键不会按照原始data的键顺序排列，但每个键对应的值不会变
  载入训练好的网络用于测试"""
  f = open (filename, "r" )
  data = json.load(f)
  f.close()
  # print "data[cost]", getattr(sys.modules[__name__], data["cost"])#获得属性__main__.CrossEntropyCost
  # print "data[cost]", data["cost"], data["sizes"]
  net = Network(data[ "sizes" ], cost = data[ "cost" ]) #网络初始化
  net.weight = [np.array(w) for w in data[ "weight" ]] #赋予训练好的权值,并将list--->array
  net.bias = [np.array(b) for b in data[ "bias" ]]
  return net
 
def sig_derivate(z):
  """derivate sigmoid"""
  return sigmoid(z) * ( 1 - sigmoid(z))
 
def sigmoid(x):
  sigm = 1.0 / ( 1.0 + exp( - x))
  return sigm
 
def vectors(y):
  """赋予标签"""
  label = np.zeros(( 10 , 1 ))
  label[y] = 1.0 #浮点计算
  return label

3） 网络测试 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#!/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_network2 as net
cost = net.QuadraticCost
cost = net.CrossEntroyCost
lambd = 0
net1 = net.Network([ 784 , 50 , 10 ],cost)
min_batch_size = 30
eta = 3.0
epoches = 2
net1.SGD(train_data,min_batch_size,epoches,eta,test_data,
    lambd,
    monitor_train_cost = True ,
    monitor_train_accuracy = True ,
    monitor_test_cost = True ,
    monitor_test_accuracy = True
    )
print "complete"

4 调用训练好的网络进行测试 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2017-03-28 17:27
# @Author : CC
# @File : forward_test.py
 
import numpy as np
# 对训练好的网络直接进行调用，并用测试样本进行测试
import net_load_data #导入测试数据
import net_network2 as net
train_data,validation_data,test_data = net_load_data.data_transform()
net = net.load_net(filename = "net_save" )  #导入网络
output = [(np.argmax(net.forward(x)),y) for (x,y) in test_data] #测试
print sum ( int (y1 = = y2) for (y1,y2) in output)  #输出最终值

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

原文链接：http://blog.csdn.net/Ychan_cc/article/details/67640185 。

最后此篇关于python构建深度神经网络（续）的文章就讲到这里了,如果你想了解更多关于python构建深度神经网络（续）的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

25 4 0
文章推荐： JavaScript判断textarea值是否为空并给出相应提示
文章推荐： Firefox下无法正常显示年份的解决方法
文章推荐： 通过软文连接 从知乎引来大量的IP
文章推荐： php基于curl实现随机ip地址抓取内容的方法
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com