使用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