使用python实现简单全连接神经网络

最近在学习神经网络的相关知识，特在此做一个笔记。

python语言的功能很强大，可以使用很少的代码实现很多功能，因此大家如果想研究深度学习的话，一定要懂得python语言。

这篇笔记记录我的第一次使用python编写神经网络代码的过程，其中代码基本是借鉴neural networks and deep learning上的知识，这本书对神经网络学习有很大帮助，浅显易懂的深入了CNN的知识，初学者可以研究一下。

好了，多的不说，直接上代码：

这里我做的是最简单的mnist手写字的识别，首先是数据库处理。

这里我下载了42028张mnist图片，每张图片大小是28*28，需要的可以到这里下载。

一般需要把数据转化为pkl文件，便于存储和以后的使用。

import os
import cPickle
import numpy
from PIL import Image
import commondata	#自己定义的文件，里面有一些公用的变量

dirname = 'train'		#图片根目录
myfile = 'train.pkl'		#生成的文件名称

number = 0			#图片个数
for filename in os.listdir(dirname):
filename1 = dirname + '/' + filename
for filename2 in os.listdir(filename1):
number += 1				</span>

pictures = numpy.empty((number,commondata.ImageWidth*commondata.ImageHeight))	#图片文件
lables = numpy.empty(number)							#标签文件

index = 0
lable = 0

for filename in os.listdir(dirname):
filename1 = dirname + '/' + filename
for filename2 in os.listdir(filename1):
filename2 = filename1 + '/' + filename2
image = Image.open(filename2)
image = image.convert('L')					#为了简便，先统一转化为灰度图片
image = image.resize((commondata.ImageHeight,commondata.ImageWidth))
image_narray = numpy.asarray(image,dtype = 'float64')/256
pictures[index] = numpy.ndarray.flatten(image_narray)
lables[index] = lable
index = index + 1
lable = lable + 1

lables = lables.astype(numpy.int)
write_file=open(myfile,'wb')
cPickle.dump([pictures[:],lables[:]],write_file,-1)
write_file.close()

运行此代码，可以生成一个名字为train.pkl的文件，然后更改根目录和生成文件的名称可以得到test.pkl

生成文件后，还需要调用此文件：

import cPickle
import numpy as np
import commondata

NumClass = commondata.NumClass
ImageWidth = commondata.ImageWidth
ImageHeight = commondata.ImageHeight

def vectorized_result(j):
e = np.zeros((NumClass,1))
e[j] = 1.0
return e

def load_data():
f = open('data.pkl','rb')
training_data = cPickle.load(f)
f.close()

f = open('test.pkl','rb')
test_data = cPickle.load(f)
f.close()

return (training_data,test_data)

def load_data_wrapper():
tr_d,te_d = load_data()
training_inputs = [np.reshape(x,(ImageWidth*ImageHeight,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)
test_inputs = [np.reshape(x,(ImageWidth*ImageHeight,1)) for x in te_d[0]]
test_data = zip(test_inputs,te_d[1])
return (training_data,test_data)

这段代码的作用是读取生成的pkl文件，并以标准化的格式返回。

其中vectorized_result的作用是将一个数值转化为向量，比如在手写数字问题中，一共有10个类，需要的向量长度为10，则1应该转化为[0,1,0,0,0,0,0,0,0,0]，2应该转化为[0,0,1,0,0,0,0,0,0,0].

接下来便是最核心的代码：

import myalgorithm				#自己的算法
import numpy as np

import random

class Network(object):

def __init__(self,sizes):						#初始化，sizes的形式一般为[784,50,10,10]之类的
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):						#前向传播过程
for b,w in zip(self.biases,self.weights):
a = myalgorithm.sigmoid(np.dot(w,a)+b)
return a

def update_mini_batch(self,mini_batch,eta):				#根据一个minibatch训练样本调整参数
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):						#反向传播
nabla_b = [np.zeros(b.shape) for b in self.biases]
nabla_w = [np.zeros(w.shape) for w in self.weights]

activation = x
activations = [x]
zs = []
for b,w in zip(self.biases,self.weights):
z = np.dot(w,activation)+b
zs.append(z)
activation = myalgorithm.sigmoid(z)
activations.append(activation)

delta = self.cost_derivative(activations[-1],y)*myalgorithm.sigmoid_prime(zs[-1])
nabla_b[-1] = delta
nabla_w[-1] = np.dot(delta,activations[-2].transpose())
for l in xrange(2,self.num_layers):
z = zs[-l]
sp = myalgorithm.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):						#测试函数
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 (output_activations - y)

def SGD(self,training_data,epochs,mini_batch_size,eta,test_data = None):	#SGD算法
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)

代码解释见注释，

然后便可以训练：

import data
training_data,test_data = data.load_data_wrapper()

import network
net = network.Network([784,30,10])
net.SGD(training_data,30,10,1.5,test_data = test_data)

import cPickle
write_file = open('weight.pkl','wb')
cPickle.dump([net.weights[:],net.biases[:]],write_file,-1)
write_file.close()

训练完成后把权值存储起来。

如果想使用训练的模型进行分类，也很简单，如下代码：

import numpy
import commondata
from PIL import Image
import cPickle
import myalgorithm

filename = 'test1.jpg'			#需要分类的文件名

read_file = open('weight.pkl','rb')
weights,biases = cPickle.load(read_file)
read_file.close()

def outcome(weights,biases,a):
for b,w in zip(biases,weights):
a = myalgorithm.sigmoid(numpy.dot(w,a)+b)
return numpy.argmax(a)

def get_predict(filename):
image = Image.open(filename)
image = image.convert('L')
image = image.resize((commondata.ImageHeight,commondata.ImageWidth))
image_narray = numpy.asarray(image,dtype = 'float64')/256
image_vector = numpy.ndarray.flatten(image_narray)
test = numpy.reshape(image_vector,(commondata.ImageHeight*commondata.ImageHeight,1))
result = outcome(weights,biases,test)
print result

调用get_predict函数便可以预测图片所属的类别

整个项目代码：http://download.csdn.net/detail/zsy162534/9592826