深度学习笔记（一）：基于numpy的深度神经网络程序总览
在看完了Andrew Ng教授的deeplearning.ai课程和李飞飞教授的cs231n课程后，总觉得应该写点笔记将学习过程记录下来，但内容不少，需要时间慢慢整理，故先将学习成果记录下来，是一段深度神经网络的程序，基于python科学计算库numpy的。还有一段代码是基于tensorflow的，在 深度学习笔记（二）：基于tensorflow gpu版本的深度神经网络程序总览 中有代码。虽然tensorflow很是方便，但是总觉得封装太好，只看代码根本学习不到什么，用numpy写一遍深度神经网络后，掌握知识的程度感觉好很多。废话不多说，先贴出代码来，代码中有注释，数据集用的是经典的数字手写体识别库mnist，后续笔记会对应具体公式和算法详细记录。
源代码及数据下载链接：点击打开链接
# -*- coding: utf-8 -*-
"""
Created on Tue Sep 26 16:03:41 2017
@author: 董玮
"""
import argparse
import time
import copy
import numpy as np
import matplotlib.pyplot as plt
from tensorflow.examples.tutorials.mnist import input_data
"""
类型：抽象类
说明：规则化数据接口，一般用于数据预处理中。
"""
class interface_normalize_data(object):
"""
类型：公有成员变量
说明：规则化数据过程中，定义一个无穷小精度，用来防止数据计算中的非法操作。
"""
epsilon = 1e-8
"""
类型：抽象公有成员函数
说明：用来规则化数据。
参数：
data -- 待处理的数据。
返回值：
data -- 处理后的数据。
"""
def normalize_data(self, data):
pass
"""
类型：实体类，继承自抽象类interface_normalize_data
说明：用于中心化数据，使数据中心在坐标原点上。
"""
class mean_normalization(interface_normalize_data):
def normalize_data(self, data):
#计算数据每个维度的期望，并用每一条数据减去期望。
data = data - np.mean(data, axis = 1, keepdims = True)
return data
"""
类型：实体类，继承自抽象类interface_normalize_data
说明：用于中心化数据，并除以方差，使数据中心在坐标原点上，并且使每个维度之间的跨度相似。
"""
class variance_normalization(interface_normalize_data):
def normalize_data(self, data):
data = data - np.mean(data, axis = 1, keepdims = True)
#计算数据每个维度的方差。
variance = np.mean(np.square(data), axis = 1, keepdims = True)
#除以方差并在除数上加上无穷小精度。
data = data / (variance + self.epsilon)
return data
"""
类型：实体类，继承自抽象类interface_normalize_data
说明：用于Z-Score统计，与上述实体类的区别是除以标准差而不是方差。
"""
class zscore_normalization(interface_normalize_data):
def normalize_data(self, data):
data = data - np.mean(data, axis = 1, keepdims = True)
variance = np.mean(np.square(data), axis = 1, keepdims = True)
#除以标准差并在除数上加上无穷小精度。
data = data / np.sqrt(variance + self.epsilon)
return data
"""
类型：抽象类
说明：神经网络初始化参数接口。
"""
class interface_initialize_parameters(object):
"""
类型：公有成员变量
说明：用来定义输入层、隐藏层、输出层每层的神经元个数。
"""
structure = None
"""
类型：公有成员变量
说明：随机种子，用来产生随机数。
"""
seed = 1
"""
类型：抽象公有成员函数
说明：用来初始化参数。
"""
def initialize_parameters(self):
pass
"""
类型：实体类
说明：标准的x-avier参数初始化，继承自抽象类interface_initialize_parameters
"""
class xavier_initialize_parameters(interface_initialize_parameters):
"""
类型：公有成员函数
说明：用来初始化参数。
参数：无
返回值：
parameters -- 返回初始化后的参数。
"""
def initialize_parameters(self):
np.random.seed(self.seed)
parameters = {}
#初始化两类参数，一种是W1、W2、W3……，另一种是b1、b2、b3……。其中数字代表层数。
#W的维度为(当前层神经元数，前一层神经元数)。b的维度为(当前层神经元数，1)。
for l in range(1, len(self.structure)):
parameters["W" + str(l)] = np.random.randn(self.structure[l], self.structure[l-1]) / np.sqrt(self.structure[l-1]/2)
parameters["b" + str(l)] = np.zeros((self.structure[l], 1))
return parameters
"""
类型：实体类
说明：具有batch normalization功能的x-avier参数初始化，继承自抽象类interface_initialize_parameters
"""
class xavier_initialize_parameters_BN(interface_initialize_parameters):
"""
类型：公有成员函数
说明：用来初始化参数。
参数：无
返回值：
parameters -- 返回初始化后的参数。
"""
def initialize_parameters(self):
np.random.seed(self.seed)
parameters = {}
#因batch normalization需要，初始化三类参数，W1、W2、W3……，gamma1、gamma2、gamma3……，beta1、beta2、beta3……。其中数字代表层数。
#W的维度为(当前层神经元数，前一层神经元数)。gamma与beta的维度均为(当前层神经元数，1)。
for l in range(1, len(self.structure)):
parameters["W" + str(l)] = np.random.randn(self.structure[l], self.structure[l-1]) / np.sqrt(self.structure[l-1]/2)
parameters["gamma" + str(l)] = np.ones((self.structure[l], 1))
#parameters["gamma" + str(l)] = np.random.randn(self.structure[l], 1) / np.sqrt(self.structure[l]/2)
parameters["beta" + str(l)] = np.zeros((self.structure[l], 1))
return parameters
"""
类型：抽象类
说明：计算激活函数的值和激活函数的梯度值
"""
class interface_activation(object):
"""
类型：公有成员变量
说明：规则化数据过程中，定义一个无穷小精度，用来防止数据计算中的非法操作。
"""
epsilon = 1e-8
"""
类型：抽象公有成员函数
说明：计算激活函数的值。
"""
def activate_function(self, *arguments):
pass
"""
类型：抽象公有成员函数
说明：计算激活函数的梯度值。
"""
def derivation_activate_function(self, *arguments):
pass
"""
类型：抽象类
说明：计算代价函数的值和代价函数的梯度值
"""
class interface_cost(object):
"""
类型：公有成员变量
说明：规则化数据过程中，定义一个无穷小精度，用来防止数据计算中的非法操作。
"""
epsilon = 1e-8
"""
类型：抽象公有成员函数
说明：计算代价函数并返回代价值。
"""
def cost_function(self, *arguments):
pass
"""
类型：抽象公有成员函数
说明：计算代价函数的梯度并返回梯度值。
"""
def derivation_cost_function(self, *arguments):
pass
"""
类型：具体类
说明：relu激活函数，继承自interface_activation。
"""
class relu(interface_activation):
"""
类型：公有成员函数
说明：计算relu函数的值。
参数：
Z -- 每一层（不包括最后一层）的线性值。
返回值：
A -- 激活值。
"""
def activate_function(self, *arguments):
Z = arguments[0]
A = np.maximum(Z, 0)
return A
"""
类型：公有成员函数
说明：计算relu函数的梯度值。
参数：
dA -- 每一层（不包括最后一层）激活值的梯度值。
返回值：
A -- 线性值的梯度值。
"""
def derivation_activate_function(self, *arguments):
dA = arguments[0]
A = arguments[1]
dZ = dA * np.where(A > 0, 1, 0)
return dZ
"""
类型：具体类
说明：softmax代价函数，继承自interface_activation。
"""
class softmax(interface_cost):
"""
类型：公有成员函数
说明：计算softmax代价函数的代价值与输出层（最后一层）的激活值。
参数：
ZL -- 输出层（最后一层）的线性值。
Y -- 数据标签。
loss -- 如果需要L1或L2正则化，则此参数计算了正则化的代价值。
返回值：
cost -- 代价值。
AL -- 输出层（最后一层）的激活值。
"""
def cost_function(self, *arguments):
ZL = arguments[0]
Y = arguments[1]
loss = arguments[2]
AL = np.exp(ZL) / (np.sum(np.exp(ZL), axis=0, keepdims=True) + self.epsilon)
cost = -np.sum(Y * np.log(AL + self.epsilon)) / Y.shape[1] + loss
return cost, AL
"""
类型：公有成员函数
说明：计算softmax代价函数的梯度值与输出层（最后一层）的线性梯度值。
参数：
AL -- 输出层（最后一层）的激活值。
Y -- 数据标签。
返回值：
dZL -- 输出层（最后一层）的线性值的梯度值。
"""
def derivation_cost_function(self, *arguments):
AL = arguments[0]
Y = arguments[1]
dZL = (AL - Y) / Y.shape[1]
return dZL
"""
类型：抽象类
说明：定义神经网络训练过程中所需要的规则化功能。
"""
class interface_regularization(object):
"""
类型：公有成员变量
说明：规则化数据过程中，定义一个无穷小精度，用来防止数据计算中的非法操作。
"""
epsilon = 1e-8
"""
类型：抽象公有成员函数
说明：向前算法中所需要的规则化动作。
"""
def forward_regularization(self, *arguments):
pass
"""
类型：抽象公有成员函数
说明：计算代价函数中所需要的规则化动作。
"""
def cost_regularization(self, *arguments):
pass
"""
类型：抽象公有成员函数
说明：向后算法中所需要的规则化动作。
"""
def backward_regularization(self, *arguments):
pass
"""
类型：具体类
说明：batch normalization功能，继承自interface_regularization
"""
class batch_normlizer(interface_regularization):
"""
类型：公有成员函数
说明：batch normalization功能的向前算法。
参数：
Z -- 每一层的线性值。
返回值：
Zcenter -- Z的中心化计算，使期望位于坐标的原点。
Zvariance -- Z的方差。
Ztilde -- Z-score标准化后的Z数值。
"""
def forward_regularization(self, *arguments):
Z = arguments[0]
Zmean = np.mean(Z, axis = 1, keepdims = True)
Zcenter = Z - Zmean
Zvariance = np.mean(np.square(Zcenter), axis = 1, keepdims = True)
Ztilde = Zcenter / np.sqrt(Zvariance + self.epsilon)
return Zcenter, Zvariance, Ztilde
"""
类型：公有成员函数
说明：batch normalization不需要此步骤，设置为空函数。
"""
def cost_regularization(self, *arguments):
pass
"""
类型：公有成员函数
说明：batch normalization功能的向后算法。
参数：
dZnorm -- 每一层batch normalization线性值的梯度值。
gamma -- batch normalization的参数。
Zcenter -- Z的中心化计算，使期望位于坐标的原点。
Zvariance -- Z的方差。
返回值：
dZ -- 每一层线性值的梯度值。
"""
def backward_regularization(self, *arguments):
dZnorm = arguments[0]
gamma = arguments[1]
Zcenter = arguments[2]
Zvariance = arguments[3]
dZtilde = np.multiply(dZnorm, gamma)
dZvariance = np.sum(np.multiply(np.multiply(dZtilde, Zcenter), np.power(Zvariance+self.epsilon, -3/2)/-2), axis=1, keepdims=True)
dZmean = np.sum(np.multiply(dZtilde, -1/np.sqrt(Zvariance + self.epsilon)), axis=1, keepdims=True)
dZ = np.multiply(dZtilde, 1/np.sqrt(Zvariance + self.epsilon)) + np.multiply(dZvariance, 2*Zcenter/Zcenter.shape[1])
+ np.multiply(dZmean, 1/Zcenter.shape[1])
return dZ
"""
类型：具体类
说明：dropout功能，继承自interface_regularization
"""
class dropout(interface_regularization):
"""
类型：公有成员变量
说明：以概率keep_prob随机删除当前层的神经元节点。
"""
keep_prob = 1.
"""
类型：公有成员函数
说明：dropout向前算法，以概率keep_prob随机删除当前层的神经元节点。
参数:
A -- 当前层的激活值
返回值：
D -- 掩码矩阵。
A -- 随机删除神经元节点后的激活值。
"""
def forward_regularization(self, *arguments):
A = arguments[0]
D = np.random.rand(A.shape[0], A.shape[1])
D = (D < self.keep_prob)
A = np.multiply(A, D)
A = A / self.keep_prob
return D, A
"""
类型：公有成员函数
说明：dropout不需要此步骤，设置为空函数。
"""
def cost_regularization(self, *arguments):
pass
"""
类型：公有成员函数
说明：dropout向后算法，和向前算法相同，删除向前算法中对应的已删除神经元节点。
参数：
dA -- 当前层神经元的激活值的梯度值。
D -- 掩码矩阵。
返回值：
dA -- 随机删除神经元节点后的激活值的梯度。
"""
def backward_regularization(self, *arguments):
dA = arguments[0]
D = arguments[1]
dA = np.multiply(dA, D)
dA = dA / self.keep_prob
return dA
"""
类型：具体类
说明：L2正则化功能，继承自interface_regularization
"""
class L2(interface_regularization):
"""
类型：公有成员变量
说明：设置参数lambda，决定权值规则化在代价函数中所占的比重。
"""
lambd = 0.
"""
类型：公有成员函数
说明：L2规则化不需要此步骤，设置为空函数。
"""
def forward_regularization(self, *arguments):
pass
"""
类型：公有成员函数
说明：在代价函数中计算L2规则化的权重。
参数：
parameters -- 学习参数。
layer_number -- 层数（包含输入层、隐藏层、输出层）。
m -- 数据的数量。
返回值：
loss -- 代价函数中L2正则化所占的比重。
"""
def cost_regularization(self, *arguments):
parameters = arguments[0]
layer_number = arguments[1]
m = arguments[2]
total = 0.
for l in range(1, layer_number+1):
total += np.sum(np.square(parameters["W"+str(l)]))
total /= 2 * m
return self.lambd * total
"""
类型：公有成员函数
说明：在向后算法中计算L2规则化的权重。
参数：
W -- 当前层的学习参数。
m -- 数据的数量。
返回值：
dloss -- 向后算法中L2规则化权重部分的梯度。
"""
def backward_regularization(self, *arguments):
W = arguments[0]
m = arguments[1]
return self.lambd * W / m
"""
类型：具体类
说明：L1正则化功能，继承自interface_regularization
"""
class L1(interface_regularization):
"""
类型：公有成员变量
说明：设置参数lambda，决定权值规则化在代价函数中所占的比重。
"""
lambd = 0.
"""
类型：公有成员函数
说明：L1规则化不需要此步骤，设置为空函数。
"""
def forward_regularization(self, *arguments):
pass
"""
类型：公有成员函数
说明：在代价函数中计算L1规则化的权重。
参数：
parameters -- 学习参数。
layer_number -- 层数（包含输入层、隐藏层、输出层）。
m -- 数据的数量。
返回值：
loss -- 代价函数中L1正则化所占的比重。
"""
def cost_regularization(self, *arguments):
parameters = arguments[0]
layer_number = arguments[1]
m = arguments[2]
total = 0.
for l in range(1, layer_number+1):
total += np.sum(np.abs(parameters["W"+str(l)]))
total /= m
return self.lambd * total
"""
类型：公有成员函数
说明：在向后算法中计算L1规则化的权重。
参数：
W -- 当前层的学习参数。
m -- 数据的数量。
返回值：
dloss -- 向后算法中L1规则化权重部分的梯度。
"""
def backward_regularization(self, *arguments):
W = arguments[0]
m = arguments[1]
#此处求梯度利用绝对值求导。
return self.lambd * np.sign(W) / m
"""
类型：抽象类
说明：定义向前向后算法。
"""
class interface_propagation(object):
"""
类型：公有成员变量
说明：定义一个空字典，用来存储规则化功能，可以存储多个规则化器regularizer。
"""
regularizer = {}
"""
类型：公有成员变量
说明：规则化数据过程中，定义一个无穷小精度，用来防止数据计算中的非法操作。
"""
epsilon = 1e-8
"""
类型：公有成员变量
说明：定义一个空字典，用来存储激活函数；激活函数的梯度函数；代价函数；代价函数的梯度函数。
"""
functor = {}
"""
类型：保护成员变量
说明：定义一个空字典，用来记录在向前算法中产生的中间结果。
"""
_intermediate_caches = {}
"""
类型：抽象公有函数
说明：向前算法。
参数：
training_set -- 训练集。
training_label -- 训练标签。
parameters -- 训练参数。
"""
def forward_propagation(self, training_set, training_label, parameters):
pass
"""
类型：抽象公有函数
说明：向后算法。
参数：
training_set -- 训练集。
training_label -- 训练标签。
parameters -- 训练参数。
"""
def backward_propagation(self, training_set, training_label, parameters):
pass
"""
类型：具体类
说明：标准的向前向后算法，继承自interface_propagation。
"""
class propagation_standard(interface_propagation):
def forward_propagation(self, training_set, training_label, parameters):
caches = self._intermediate_caches
cost = None
if(len(parameters) < 2):
return cost, caches
#向前算法
caches["A0"] = training_set
Z = 0.
layer_number = len(parameters) // 2
for l in range(1, layer_number):
Z = np.dot(parameters["W"+str(l)], caches["A"+str(l-1)]) + parameters["b" + str(l)]
#激活函数
caches["A"+str(l)] = self.functor["activation"].activate_function(Z)
#添加dropout正则化功能
if("dropout" in self.regularizer.keys()):
caches["D"+str(l)], caches["A"+str(l)] = self.regularizer["dropout"].forward_regularization(caches["A"+str(l)])
Z = np.dot(parameters["W"+str(layer_number)], caches["A"+str(layer_number-1)]) + parameters["b" + str(layer_number)]
#添加L1、L2正则化功能
loss = 0.
if("L2" in self.regularizer.keys()):
loss += self.regularizer["L2"].cost_regularization(parameters, layer_number, training_set.shape[1])
if("L1" in self.regularizer.keys()):
loss += self.regularizer["L1"].cost_regularization(parameters, layer_number, training_set.shape[1])
#计算代价函数
cost, caches["A"+str(layer_number)] = self.functor["cost"].cost_function(Z, training_label, loss)
return cost
def backward_propagation(self, training_set, training_label, parameters):
caches = self._intermediate_caches
grad_parameters = {}
#向后算法。
layer_number = len(parameters) // 2
#代价函数的梯度计算。
dZ = self.functor["cost"].derivation_cost_function(caches["A"+str(layer_number)], training_label)
for l in reversed(range(1, layer_number+1)):
grad_parameters["dW"+str(l)] = np.dot(dZ, caches["A"+str(l-1)].T)
#添加L1、L2正则化功能。
if("L2" in self.regularizer.keys()):
grad_parameters["dW"+str(l)] += self.regularizer["L2"].backward_regularization(parameters["W"+str(l)], training_set.shape[1])
if("L1" in self.regularizer.keys()):
grad_parameters["dW"+str(l)] += self.regularizer["L1"].backward_regularization(parameters["W"+str(l)], training_set.shape[1])
grad_parameters["db"+str(l)] = np.sum(dZ, axis=1, keepdims=True)
if(l > 1):
dA = np.dot(parameters["W"+str(l)].T, dZ)
#添加dropout正则化功能。
if("dropout" in self.regularizer.keys()):
dA = self.regularizer["dropout"].backward_regularization(dA, caches["D"+str(l-1)])
#激活函数的梯度计算。
dZ = self.functor["activation"].derivation_activate_function(dA, caches["A"+str(l-1)])
return grad_parameters
"""
类型：具体类
说明：带有Batch normalization的向前向后算法，继承自interface_propagation。
"""
class propagation_BN(interface_propagation):
def forward_propagation(self, training_set, training_label, parameters):
caches = self._intermediate_caches
cost = None
if(len(parameters) < 2):
return cost, caches
caches["A0"] = training_set
Z = 0.
#注意，因为Batch normalization有三个学习参数，这里要除以3取整。
layer_number = len(parameters) // 3
for l in range(1, layer_number):
Z = np.dot(parameters["W"+str(l)], caches["A"+str(l-1)])
#向前算法中的Batch normalization步骤。
caches["Zcenter"+str(l)], caches["Zvariance"+str(l)], caches["Ztilde"+str(l)] = self.regularizer["batch_normlizer"].forward_regularization(Z)
Z = np.multiply(parameters["gamma" + str(l)], caches["Ztilde"+str(l)]) + parameters["beta" + str(l)]
caches["A"+str(l)] = self.functor["activation"].activate_function(Z)
if("dropout" in self.regularizer.keys()):
caches["D"+str(l)], caches["A"+str(l)] = self.regularizer["dropout"].forward_regularization(caches["A"+str(l)])
Z = np.dot(parameters["W"+str(layer_number)], caches["A"+str(layer_number-1)])
caches["Zcenter"+str(layer_number)], caches["Zvariance"+str(layer_number)], caches["Ztilde"+str(layer_number)] = self
.regularizer["batch_normlizer"].forward_regularization(Z)
Z = np.multiply(parameters["gamma" + str(layer_number)], caches["Ztilde"+str(layer_number)]) + parameters["beta" + str(layer_number)]
loss = 0.
if("L2" in self.regularizer.keys()):
loss += self.regularizer["L2"].cost_regularization(parameters, layer_number, training_set.shape[1])
if("L1" in self.regularizer.keys()):
loss += self.regularizer["L1"].cost_regularization(parameters, layer_number, training_set.shape[1])
cost, caches["A"+str(layer_number)] = self.functor["cost"].cost_function(Z, training_label, loss)
return cost
def backward_propagation(self, training_set, training_label, parameters):
caches = self._intermediate_caches
grad_parameters = {}
#注意，因为Batch normalization有三个学习参数，这里要除以3取整。
layer_number = len(parameters) // 3
dZnorm = self.functor["cost"].derivation_cost_function(caches["A"+str(layer_number)], training_label)
for l in reversed(range(1, layer_number+1)):
grad_parameters["dgamma"+str(l)] = np.sum(np.multiply(dZnorm, caches["Ztilde"+str(l)]), axis=1, keepdims=True)
grad_parameters["dbeta"+str(l)] = np.sum(dZnorm, axis=1, keepdims=True)
#向前算法中的Batch normalization步骤。
dZ = self.regularizer["batch_normlizer"]
.backward_regularization(dZnorm, parameters["gamma" + str(l)], caches["Zcenter"+str(l)], caches["Zvariance"+str(l)])
grad_parameters["dW"+str(l)] = np.dot(dZ, caches["A"+str(l-1)].T)
if("L2" in self.regularizer.keys()):
grad_parameters["dW"+str(l)] += self.regularizer["L2"].backward_regularization(parameters["W"+str(l)], training_set.shape[1])
if("L1" in self.regularizer.keys()):
grad_parameters["dW"+str(l)] += self.regularizer["L1"].backward_regularization(parameters["W"+str(l)], training_set.shape[1])
if(l > 1):
dA = np.dot(parameters["W"+str(l)].T, dZ)
if("dropout" in self.regularizer.keys()):
dA = self.regularizer["dropout"].backward_regularization(dA, caches["D"+str(l-1)])
dZnorm = self.functor["activation"].derivation_activate_function(dA, caches["A"+str(l-1)])
return grad_parameters
"""
类型：抽象类
说明：定义优化算法。
"""
class interface_optimization(object):
"""
类型：公有成员变量
说明：规则化数据过程中，定义一个无穷小精度，用来防止数据计算中的非法操作。
"""
epsilon = 1e-8
"""
类型：公有成员变量
说明：定义优化算法的学习率。
"""
learning_rate = 1e-3
"""
类型：抽象公有成员函数
说明：定义优化算法的初始化工作。
"""
def initialization(self, *arguments):
pass
"""
类型：抽象公有成员函数
说明：定义优化算法的计算步骤。
"""
def optimization(self, *arguments):
pass
"""
类型：具体类
说明：标准的梯度下降算法。
"""
class gradient_descent_standard(interface_optimization):
def initialization(self, *arguments):
pass
def optimization(self, *arguments):
parameters = arguments[0]
grads = arguments[1]
L = len(parameters) // 2
for l in range(1, L+1):
parameters["W"+str(l)] = parameters["W"+str(l)] - self.learning_rate * grads["dW"+str(l)]
parameters["b"+str(l)] = parameters["b"+str(l)] - self.learning_rate * grads["db"+str(l)]
return parameters
"""
类型：具体类
说明：带有Batch normalization的梯度下降算法。
"""
class gradient_descent_BN(interface_optimization):
def initialization(self, *arguments):
pass
def optimization(self, *arguments):
parameters = arguments[0]
grads = arguments[1]
L = len(parameters) // 3
for l in range(1, L+1):
parameters["W"+str(l)] = parameters["W"+str(l)] - self.learning_rate * grads["dW"+str(l)]
parameters["gamma" + str(l)] = parameters["gamma"+str(l)] - self.learning_rate * grads["dgamma"+str(l)]
parameters["beta"+str(l)] = parameters["beta"+str(l)] - self.learning_rate * grads["dbeta"+str(l)]
return parameters
"""
类型：具体类
说明：标准的adam算法。
"""
class adam_standard(interface_optimization):
__v = {}
__s = {}
__t = 0
beta1 = 0.9
beta2 = 0.999
def initialization(self, *arguments):
parameters = arguments[0]
v = self.__v
s = self.__s
self.__t = 0
L = len(parameters) // 2
for l in range(1, L+1):
v["dW" + str(l)] = np.zeros(parameters["W" + str(l)].shape)
v["db" + str(l)] = np.zeros(parameters["b" + str(l)].shape)
s["dW" + str(l)] = np.zeros(parameters["W" + str(l)].shape)
s["db" + str(l)] = np.zeros(parameters["b" + str(l)].shape)
def optimization(self, *arguments):
parameters = arguments[0]
grads = arguments[1]
v = self.__v
s = self.__s
self.__t += 1
v_corrected = {}
s_corrected = {}
L = len(parameters) // 2
for l in range(1, L+1):
v["dW" + str(l)] = self.beta1 * v["dW" + str(l)] + (1-self.beta1) * grads['dW' + str(l)]
v["db" + str(l)] = self.beta1 * v["db" + str(l)] + (1-self.beta1) * grads['db' + str(l)]
v_corrected["dW" + str(l)] = v["dW" + str(l)] / (1 - np.power(self.beta1, self.__t))
v_corrected["db" + str(l)] = v["db" + str(l)] / (1 - np.power(self.beta1, self.__t))
s["dW" + str(l)] = self.beta2 * s["dW" + str(l)] + (1-self.beta2) * np.power(grads['dW' + str(l)], 2)
s["db" + str(l)] = self.beta2 * s["db" + str(l)] + (1-self.beta2) * np.power(grads['db' + str(l)], 2)
s_corrected["dW" + str(l)] = s["dW" + str(l)] / (1 - np.power(self.beta2, self.__t))
s_corrected["db" + str(l)] = s["db" + str(l)] / (1 - np.power(self.beta2, self.__t))
parameters["W" + str(l)] = parameters["W" + str(l)]
- self.learning_rate * (v_corrected["dW" + str(l)] / (np.sqrt(s_corrected["dW" + str(l)]) + self.epsilon))
parameters["b" + str(l)] = parameters["b" + str(l)]
- self.learning_rate * (v_corrected["db" + str(l)] / (np.sqrt(s_corrected["db" + str(l)]) + self.epsilon))
return parameters
"""
类型：具体类
说明：带有Batch normalization的adam算法。
"""
class adam_BN(interface_optimization):
__v = {}
__s = {}
__t = 0
beta1 = 0.9
beta2 = 0.999
def initialization(self, *arguments):
parameters = arguments[0]
v = self.__v
s = self.__s
self.__t = 0
L = len(parameters) // 3
for l in range(1, L+1):
v["dW" + str(l)] = np.zeros(parameters["W" + str(l)].shape)
v["dgamma" + str(l)] = np.zeros(parameters["gamma" + str(l)].shape)
v["dbeta" + str(l)] = np.zeros(parameters["beta" + str(l)].shape)
s["dW" + str(l)] = np.zeros(parameters["W" + str(l)].shape)
s["dgamma" + str(l)] = np.zeros(parameters["gamma" + str(l)].shape)
s["dbeta" + str(l)] = np.zeros(parameters["beta" + str(l)].shape)
def optimization(self, *arguments):
parameters = arguments[0]
grads = arguments[1]
v = self.__v
s = self.__s
self.__t += 1
v_corrected = {}
s_corrected = {}
L = len(parameters) // 3
for l in range(1, L+1):
v["dW" + str(l)] = self.beta1 * v["dW" + str(l)] + (1-self.beta1) * grads['dW' + str(l)]
v["dgamma" + str(l)] = self.beta1 * v["dgamma" + str(l)] + (1-self.beta1) * grads['dgamma' + str(l)]
v["dbeta" + str(l)] = self.beta1 * v["dbeta" + str(l)] + (1-self.beta1) * grads['dbeta' + str(l)]
v_corrected["dW" + str(l)] = v["dW" + str(l)] / (1 - np.power(self.beta1, self.__t))
v_corrected["dgamma" + str(l)] = v["dgamma" + str(l)] / (1 - np.power(self.beta1, self.__t))
v_corrected["dbeta" + str(l)] = v["dbeta" + str(l)] / (1 - np.power(self.beta1, self.__t))
s["dW" + str(l)] = self.beta2 * s["dW" + str(l)] + (1-self.beta2) * np.power(grads['dW' + str(l)], 2)
s["dgamma" + str(l)] = self.beta2 * s["dgamma" + str(l)] + (1-self.beta2) * np.power(grads['dgamma' + str(l)], 2)
s["dbeta" + str(l)] = self.beta2 * s["dbeta" + str(l)] + (1-self.beta2) * np.power(grads['dbeta' + str(l)], 2)
s_corrected["dW" + str(l)] = s["dW" + str(l)] / (1 - np.power(self.beta2, self.__t))
s_corrected["dgamma" + str(l)] = s["dgamma" + str(l)] / (1 - np.power(self.beta2, self.__t))
s_corrected["dbeta" + str(l)] = s["dbeta" + str(l)] / (1 - np.power(self.beta2, self.__t))
parameters["W" + str(l)] = parameters["W" + str(l)]
- self.learning_rate * (v_corrected["dW" + str(l)] / (np.sqrt(s_corrected["dW" + str(l)]) + self.epsilon))
parameters["gamma" + str(l)] = parameters["gamma" + str(l)]
- self.learning_rate * (v_corrected["dgamma" + str(l)] / (np.sqrt(s_corrected["dgamma" + str(l)]) + self.epsilon))
parameters["beta" + str(l)] = parameters["beta" + str(l)]
- self.learning_rate * (v_corrected["dbeta" + str(l)] / (np.sqrt(s_corrected["dbeta" + str(l)]) + self.epsilon))
return parameters
"""
类型：抽象类
说明：定义决策方法。
"""
class interface_decision(object):
epsilon = 1e-8
"""
类型：公有成员变量
说明：定义决策计算中的激活函数。
"""
activation = None
"""
类型：抽象公有成员函数
说明：定义预测方法。
"""
def prediction(self, *arguments):
pass
"""
类型：抽象公有成员函数
说明：定义计算精度的方法。
"""
def accuracy(self, *arguments):
pass
"""
类型：具体类
说明：定义标准的决策方法。
"""
class decider_standard(interface_decision):
def prediction(self, *arguments):
decision_set = arguments[0]
parameters = arguments[1]
A = decision_set
layer_number = len(parameters) // 2
for l in range(1, layer_number):
A = self.activation.activate_function(np.dot(parameters["W"+str(l)], A) + parameters["b" + str(l)])
ZL = np.dot(parameters["W"+str(layer_number)], A) + parameters["b" + str(layer_number)]
AL = np.exp(ZL) / np.sum(np.exp(ZL), axis=0, keepdims=True)
return np.argmax(AL, 0)
def accuracy(self, *arguments):
decision_set = arguments[0]
decision_label = arguments[1]
parameters = arguments[2]
bool_array = np.equal(self.prediction(decision_set, parameters), np.argmax(decision_label, 0))
acc = np.sum(bool_array == True) / len(bool_array)
return acc
"""
类型：具体类
说明：定义带Batch normalization的决策方法。
"""
class decider_BN(interface_decision):
def prediction(self, *arguments):
decision_set = arguments[0]
parameters = arguments[1]
A = decision_set
layer_number = len(parameters) // 3
for l in range(1, layer_number):
Z = np.dot(parameters["W"+str(l)], A)
Zmean = np.mean(Z, axis=1, keepdims=True)
Zvariance = np.mean(np.square(Z - Zmean), axis=1, keepdims=True)
Ztilde = (Z - Zmean) / np.sqrt(Zvariance + self.epsilon)
Znorm = np.multiply(parameters["gamma" + str(l)], Ztilde) + parameters["beta" + str(l)]
A = self.activation.activate_function(Znorm)
ZL = np.dot(parameters["W"+str(layer_number)], A)
Zmean = np.mean(ZL, axis=1, keepdims=True)
Zvariance = np.mean(np.square(ZL - Zmean), axis=1, keepdims=True)
Ztilde = (ZL - Zmean) / np.sqrt(Zvariance + self.epsilon)
Znorm = np.multiply(parameters["gamma" + str(layer_number)], Ztilde) + parameters["beta" + str(layer_number)]
AL = np.exp(Znorm) / np.sum(np.exp(Znorm), axis=0, keepdims=True)
return np.argmax(AL, 0)
def accuracy(self, *arguments):
decision_set = arguments[0]
decision_label = arguments[1]
parameters = arguments[2]
bool_array = np.equal(self.prediction(decision_set, parameters), np.argmax(decision_label, 0))
acc = np.sum(bool_array == True) / len(bool_array)
return acc
"""
类型：抽象类
说明：定义学习率衰减方法。
"""
class interface_learning_rate(object):
"""
类型：公有成员变量
说明：定义每几步衰减一次。
"""
epoch_step = 10
"""
类型：公有成员变量
说明：衰退比率。
"""
k = 0.1
"""
类型：保护成员变量
说明：迭代次数，用于自加操作。
"""
_t = 0
def learning_rate_decay(self, *arguments):
pass
"""
类型：具体类
说明：指数学习率衰减方法。
"""
class exponential_decay(interface_learning_rate):
def learning_rate_decay(self, *arguments):
recent_epoch = arguments[0]
learning_rate = arguments[1]
if(recent_epoch % self.epoch_step == 0):
self._t += 1
learning_rate = learning_rate * np.exp(-self.k * self._t)
return learning_rate
"""
类型：具体类
说明：除以t的学习率衰减方法。
"""
class div_t_decay(interface_learning_rate):
def learning_rate_decay(self, *arguments):
recent_epoch = arguments[0]
learning_rate = arguments[1]
if(recent_epoch % self.epoch_step == 0):
self._t += 1
learning_rate = learning_rate / (1 + self.k * self._t)
return learning_rate
"""
类型：抽象类
说明：定义一个工厂类，用来生产学习模型过程中所需要的模块。
"""
class interface_factory(object):
"""
类型：公有成员变量
说明：数据预处理规则化模块。
"""
normalizer = None
"""
类型：公有成员变量
说明：学习参数初始化模块。
"""
initializer = None
"""
类型：公有成员变量
说明：向前向后学习算法模块。
"""
propagator = None
"""
类型：公有成员变量
说明：优化算法模块。
"""
optimizer = None
"""
类型：公有成员变量
说明：决策模块。
"""
decider = None
"""
类型：公有成员变量
说明：学习率衰减模块。
"""
decay_rater = None
"""
类型：公有成员变量
说明：数据批量优化算法说需要的batch大小，即每次训练从训练集里抽样的个数。
"""
minibatch_size = 512
"""
类型：公有成员变量
说明：epoch个数，即需要训练整个数据集多少遍。
"""
num_epochs = 100
"""
类型：抽象公有成员函数
说明：创建一个工厂，该工厂生产训练和测试数据过程中所需要的模块。
"""
def create_workpiece(self, *arguments):
pass
"""
类型：具体类
说明：工厂版本v1，不带Batch normalization功能，激活函数为relu，最后一层激活函数为softmax，代价函数用的是交叉熵损失函数，优化算法为adam，学习率为指数衰减。
"""
class factory_v1(interface_factory):
"""
类型：公有成员函数
说明：创建一个工厂，该工厂生产训练和测试数据过程中所需要的模块。
参数：
arguments[0] -- 数值计算精度 - epsilon
arguments[1] -- 网络结构 - structure
arguments[2] -- 随机种子 - seed
arguments[3] -- 学习率 - learning_rate
arguments[4] -- adam参数 - beta1
arguments[5] -- adam参数 - beta2
arguments[6] -- batch的大小 - minibatch_size
arguments[7] -- epoch个数 - num_epochs
arguments[8] -- 衰减步数 - epoch_step
arguments[9] -- 衰减率 - k
"""
def create_workpiece(self, *arguments):
epsilon = arguments[0]
self.normalizer = zscore_normalization()
self.normalizer.epsilon = epsilon
structure = arguments[1]
seed = arguments[2]
self.initializer = xavier_initialize_parameters()
self.initializer.structure = structure
self.initializer.seed = seed
self.propagator = propagation_standard()
self.propagator.epsilon = epsilon
self.propagator.functor["activation"] = relu()
self.propagator.functor["activation"].epsilon = epsilon
self.propagator.functor["cost"] = softmax()
self.propagator.functor["cost"].epsilon = epsilon
learning_rate = arguments[3]
beta1 = arguments[4]
beta2 = arguments[5]
self.optimizer = adam_standard()
self.optimizer.epsilon = epsilon
self.optimizer.learning_rate = learning_rate
self.optimizer.beta1 = beta1
self.optimizer.beta2 = beta2
self.decider = decider_standard()
self.decider.epsilon = epsilon
self.decider.activation = relu()
self.minibatch_size = arguments[6]
self.num_epochs = arguments[7]
epoch_step = arguments[8]
rate_k = arguments[9]
self.decay_rater = exponential_decay()
self.decay_rater.epoch_step = epoch_step
self.decay_rater.k = rate_k
return self
"""
类型：具体类
说明：工厂版本v2，带Batch normalization功能，激活函数为relu，最后一层激活函数为softmax，代价函数用的是交叉熵损失函数，优化算法为adam，学习率为指数衰减。
"""
class factory_v2(interface_factory):
"""
类型：公有成员函数
说明：创建一个工厂，该工厂生产训练和测试数据过程中所需要的模块。
参数：
arguments[0] -- 数值计算精度 - epsilon
arguments[1] -- 网络结构 - structure
arguments[2] -- 随机种子 - seed
arguments[3] -- 学习率 - learning_rate
arguments[4] -- adam参数 - beta1
arguments[5] -- adam参数 - beta2
arguments[6] -- batch的大小 - minibatch_size
arguments[7] -- epoch个数 - num_epochs
arguments[8] -- 衰减步数 - epoch_step
arguments[9] -- 衰减率 - k
"""
def create_workpiece(self, *arguments):
epsilon = arguments[0]
self.normalizer = zscore_normalization()
self.normalizer.epsilon = epsilon
structure = arguments[1]
seed = arguments[2]
self.initializer = xavier_initialize_parameters_BN()
self.initializer.structure = structure
self.initializer.seed = seed
self.propagator = propagation_BN()
self.propagator.epsilon = epsilon
bn = batch_normlizer()
bn.epsilon = epsilon
self.propagator.regularizer = {'batch_normlizer': bn}
self.propagator.functor["activation"] = relu()
self.propagator.functor["activation"].epsilon = epsilon
self.propagator.functor["cost"] = softmax()
self.propagator.functor["cost"].epsilon = epsilon
learning_rate = arguments[3]
beta1 = arguments[4]
beta2 = arguments[5]
self.optimizer = adam_BN()
self.optimizer.epsilon = epsilon
self.optimizer.learning_rate = learning_rate
self.optimizer.beta1 = beta1
self.optimizer.beta2 = beta2
self.decider = decider_BN()
self.decider.epsilon = epsilon
self.decider.activation = relu()
self.minibatch_size = arguments[6]
self.num_epochs = arguments[7]
epoch_step = arguments[8]
rate_k = arguments[9]
self.decay_rater = exponential_decay()
self.decay_rater.epoch_step = epoch_step
self.decay_rater.k = rate_k
return self
"""
类型：具体类
说明：工厂版本v3，带Batch normalization功能，带dropout规则化，激活函数为relu，最后一层激活函数为softmax，代价函数用的是交叉熵损失函数，
优化算法为adam，学习率为指数衰减。
"""
class factory_v3(interface_factory):
"""
类型：公有成员函数
说明：创建一个工厂，该工厂生产训练和测试数据过程中所需要的模块。
参数：
arguments[0] -- 数值计算精度 - epsilon
arguments[1] -- 网络结构 - structure
arguments[2] -- 随机种子 - seed
arguments[3] -- 学习率 - learning_rate
arguments[4] -- adam参数 - beta1
arguments[5] -- adam参数 - beta2
arguments[6] -- batch的大小 - minibatch_size
arguments[7] -- epoch个数 - num_epochs
arguments[8] -- 衰减步数 - epoch_step
arguments[9] -- 衰减率 - k
arguments[10] -- dropout保持概率 - keep_prob
"""
def create_workpiece(self, *arguments):
epsilon = arguments[0]
self.normalizer = zscore_normalization()
self.normalizer.epsilon = epsilon
structure = arguments[1]
seed = arguments[2]
self.initializer = xavier_initialize_parameters_BN()
self.initializer.structure = structure
self.initializer.seed = seed
self.propagator = propagation_BN()
self.propagator.epsilon = epsilon
bn = batch_normlizer()
bn.epsilon = epsilon
self.propagator.regularizer['batch_normlizer'] = bn
self.propagator.functor["activation"] = relu()
self.propagator.functor["activation"].epsilon = epsilon
self.propagator.functor["cost"] = softmax()
self.propagator.functor["cost"].epsilon = epsilon
learning_rate = arguments[3]
beta1 = arguments[4]
beta2 = arguments[5]
self.optimizer = adam_BN()
self.optimizer.epsilon = epsilon
self.optimizer.learning_rate = learning_rate
self.optimizer.beta1 = beta1
self.optimizer.beta2 = beta2
self.decider = decider_BN()
self.decider.epsilon = epsilon
self.decider.activation = relu()
self.minibatch_size = arguments[6]
self.num_epochs = arguments[7]
epoch_step = arguments[8]
rate_k = arguments[9]
self.decay_rater = exponential_decay()
self.decay_rater.epoch_step = epoch_step
self.decay_rater.k = rate_k
d = dropout()
d.epsilon = epsilon
d.keep_prob = arguments[10]
self.propagator.regularizer['dropout'] = d
return self
"""
类型：抽象类
说明：定义一个工厂类，用来生产学习模型过程中所需要的模块。
"""
class interface_train_model(object):
"""
类型：公有成员变量
说明：学习参数。
"""
parameters = None
"""
类型：公有成员变量
说明：训练集。
"""
training_set = None
"""
类型：公有成员变量
说明：训练标签。
"""
training_label = None
"""
类型：公有成员变量
说明：验证集。
"""
validation_set = None
"""
类型：公有成员变量
说明：验证标签。
"""
validation_label = None
"""
类型：公有成员变量
说明：测试集。
"""
test_set = None
"""
类型：公有成员变量
说明：测试标签。
"""
test_label = None
"""
类型：公有成员变量
说明：工厂对象。
"""
factory = None
"""
类型：抽象公有成员函数
说明：预测方法。
"""
def prediction(self, *arguments):
pass
"""
类型：抽象公有成员函数
说明：计算训练集精度。
"""
def training_accuracy(self, *arguments):
pass
"""
类型：抽象公有成员函数
说明：计算验证集精度。
"""
def validation_accuracy(self, *arguments):
pass
"""
类型：抽象公有成员函数
说明：计算测试集精度。
"""
def test_accuracy(self, *arguments):
pass
"""
类型：抽象公有成员函数
说明：训练模型方法。
"""
def training_model(self, *arguments):
pass
"""
类型：具体类
说明：定义深度神经网络。
"""
class deep_neural_networks(interface_train_model):
"""
类型：初始化函数
说明：初始化工厂对象。
"""
def __init__(self, factory):
self.factory = factory
def prediction(self, *arguments):
return self.factory.decider.prediction(self.test_set, self.parameters)
def training_accuracy(self, *arguments):
return self.factory.decider.accuracy(self.training_set, self.training_label, self.parameters)
def validation_accuracy(self, *arguments):
return self.factory.decider.accuracy(self.validation_set, self.validation_label, self.parameters)
def test_accuracy(self, *arguments):
return self.factory.decider.accuracy(self.test_set, self.test_label, self.parameters)
def training_model(self, *arguments):
#定义深度神经网络结构
self.factory.initializer.structure = np.append(np.array([self.training_set.shape[0]]), self.factory.initializer.structure)
#定义一轮epoch需要多少batch
num_minibatches = int(self.training_set.shape[1] / self.factory.minibatch_size) + 1
#定义数据预处理步骤
if(self.factory.normalizer != None):
self.training_set = self.factory.normalizer.normalize_data(self.training_set)
self.validation_set = self.factory.normalizer.normalize_data(self.validation_set)
#定义学习参数及超参数初始化步骤
self.parameters = self.factory.initializer.initialize_parameters()
seed = self.factory.initializer.seed
self.factory.optimizer.initialization(self.parameters)
costs = []
training_accuracies = []
validation_accuracies = []
#在验证集上表现最好的学习参数
best_parameters = {}
#最好学习参数时，训练集的精度
best_training_acc = 0.
#最好学习参数时，验证集的精度
best_validation_acc = 0.
start = time.clock()
#epoch学习过程
for iter_epoch in range(1, self.factory.num_epochs + 1):
cost = 0
#minibatch学习过程
for iter_batch in range(1, num_minibatches + 1):
seed += 1
(minibatch_X, minibatch_Y) = self.__random_mini_batches(self.factory.minibatch_size, seed)
cost += self.factory.propagator.forward_propagation(minibatch_X, minibatch_Y, self.parameters)
grads = self.factory.propagator.backward_propagation(minibatch_X, minibatch_Y, self.parameters)
self.factory.optimizer.optimization(self.parameters, grads)
if(self.factory.decay_rater != None):
self.factory.optimizer.learning_rate = self.factory.decay_rater.learning_rate_decay(iter_epoch, self.factory.optimizer.learning_rate)
cost /= num_minibatches
costs.append(cost)
training_acc = self.training_accuracy()
training_accuracies.append(training_acc)
validation_acc = self.validation_accuracy()
validation_accuracies.append(validation_acc)
if(validation_acc > best_validation_acc):
best_training_acc = training_acc
best_validation_acc = validation_acc
best_parameters = copy.deepcopy(self.parameters)
print ("Cost after epoch %i: %f" % (iter_epoch, cost))
print ("Training accuracy after epoch %i: %f" % (iter_epoch, training_acc))
print ("Validation accuracy after epoch %i: %f" % (iter_epoch, validation_acc))
end = time.clock()
self.factory.initializer.seed = seed
self.parameters = best_parameters
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('epochs')
plt.title("Learning rate =" + str(self.factory.optimizer.learning_rate))
plt.show()
plt.plot(np.squeeze(training_accuracies))
plt.ylabel('training accracy')
plt.xlabel('epochs')
plt.title("Learning rate =" + str(self.factory.optimizer.learning_rate))
plt.show()
plt.plot(np.squeeze(validation_accuracies))
plt.ylabel('validation accracy')
plt.xlabel('epochs')
plt.title("Learning rate =" + str(self.factory.optimizer.learning_rate))
plt.show()
print ("Accuracy of total Training set: %f%%" % (best_training_acc * 100))
print ("Accuracy of total Validation set: %f%%" % (best_validation_acc * 100))
print ("Training of total Time: %f Minutes" % ((end - start) / 60))
"""
类型：私有成员函数
说明：从训练数据集和标签集中随机抽取minibatch。
参数：
X_train -- 训练数据集。
Y_train -- 训练标签集。
minibatch_size -- minibatch大小。
seed -- 随机种子。
返回值：
元组 -- 返回一个minibatch，包括训练数据和对应的标签数据。
"""
def __random_mini_batches(self, minibatch_size, seed):
np.random.seed(seed)
shuffle_array = np.random.randint(0, self.training_set.shape[1], minibatch_size)
return (self.training_set[:, shuffle_array], self.training_label[:, shuffle_array])
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--data_dir', type=str, default='/tmp/tensorflow/mnist/input_data',
help='Directory for storing input data')
FLAGS, unparsed = parser.parse_known_args()
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
struct = [512, 256, 128, 64, 32, 16, 10]
factory = factory_v2()
factory.create_workpiece(1e-8, struct, 1, 1e-3, 0.9, 0.999, 512, 100, 5, 0.01)
dnn = deep_neural_networks(factory)
dnn.training_set = mnist.train.images.T
dnn.training_label = mnist.train.labels.T
dnn.validation_set = mnist.test.images.T
dnn.validation_label = mnist.test.labels.T
dnn.training_model()
main()运行结果：
