今天就跟大家聊聊有关使用python怎么构建一个深度神经网络，可能很多人都不太了解，为了让大家更加了解，小编给大家总结了以下内容，希望大家根据这篇文章可以有所收获。
创新互联专注于南部网站建设服务及定制，我们拥有丰富的企业做网站经验。 热诚为您提供南部营销型网站建设，南部网站制作、南部网页设计、南部网站官网定制、小程序定制开发服务，打造南部网络公司原创品牌,更为您提供
南部网站排名全网营销落地服务。
python主要应用领域有哪些
1、云计算，典型应用OpenStack。2、WEB前端开发，众多大型网站均为Python开发。3.人工智能应用，基于大数据分析和深度学习而发展出来的人工智能本质上已经无法离开python。4、系统运维工程项目，自动化运维的标配就是python+Django/flask。5、金融理财分析，量化交易，金融分析。6、大数据分析。
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 *
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 label2 网络定义和训练
#!/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 label3） 网络测试
#!/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 调用训练好的网络进行测试
#!/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) #输出最终值
看完上述内容，你们对使用python怎么构建一个深度神经网络有进一步的了解吗？如果还想了解更多知识或者相关内容，请关注创新互联成都网站设计公司行业资讯频道，感谢大家的支持。
另外有需要云服务器可以了解下创新互联scvps.cn，海内外云服务器15元起步，三天无理由+7*72小时售后在线，公司持有idc许可证，提供“云服务器、裸金属服务器、高防服务器、香港服务器、美国服务器、虚拟主机、免备案服务器”等云主机租用服务以及企业上云的综合解决方案，具有“安全稳定、简单易用、服务可用性高、性价比高”等特点与优势，专为企业上云打造定制，能够满足用户丰富、多元化的应用场景需求。
分享文章：使用python怎么构建一个深度神经网络-创新互联
本文路径：
http://cdkjz.cn/article/dchhpo.html
