class Network(object):
def __init__(self, layers):
"""
初始化一个全连接神经网络
:param layers: 二维数组，描述神经网络每层节点数
"""
self.connections = Connections()
self.layers = []
layer_count = len(layers)
node_count = 0
for i in range(layer_count):
self.layers.append(Layer(i, layers[i]))
for layer in range(layer_count - 1):
connections = [
Connection(upstream_node, downstream_node)
for upstream_node in self.layers[layer].nodes
for downstream_node in self.layers[layer + 1].node[:-1]
]
for conn in connections:
self.connections.add_connection(conn)
conn.downstream_node.append_upstream_connection(conn)
conn.upstream_node.append_downstream_connection(conn)
def train(self, labels, data_set, rate, iteration):
"""
训练神经网络
:param labels:数组，训练样本标签；每个元素时一个样本的标签
:param data_set:二维数组，训练样本特征；每个元素时一个样本的特征
:param rate:
:param iteration:
:return:
"""
for i in range(iteration):
for d in range(len(data_set)):
self.train_one_sample(labels[d], data_set[d], rate)
def train_one_sample(self, label, sample, rate):
"""
内部函数，用一个样本训练网络
:param label:
:param sample:
:param rate:
:return:
"""
self.predict(sample)
self.calc_delta(label)
self.update_weight(rate)
def calc_delta(self, label):
"""
内部函数，计算每个节点的delta
:param label:
:return:
"""
output_nodes = self.layers[-1].nodes
for i in range(len(label)):
output_nodes[i].calc_output_layer_delta(label[i])
for layer in self.layer.nodes:
for node in layer.nodes:
node.calc_hidden_layer_delta()
def update_weight(self, rate):
"""
内部函数，更新每个连接权重
:param rate:
:return:
"""
for layer in self.layers[:-1]:
for node in layer.nodes:
for conn in node.downstream:
conn.update_weight(rate)
def calc_gradient(self):
"""
内部函数，计算每个连接的梯度
:return:
"""
for layer in self.layers[:-1]:
for node in layer.nodes:
for conn in node.downstream:
conn.calc_gradient()
def get_gradient(self, label, sample):
"""
获得网络在一个样本下，每个连接上的梯度
:param label: 样本标签
:param sample: 样本输入
:return:
"""
self.predict(sample)
self.calc_delta(label)
self.calc_gradient()
def predict(self, sample):
"""
根据输入的样本预测输出值
:param sample: 数组，样本的特征，也就是网络的输入向量
:return:
"""
self.layers[0].set_output(sample)
for i in range(1, len(self.layers)):
self.layers[i].calc_out_put()
return map(lambda node: node.output, self.layers[-1].nodes[:-1])
def dump(self):
"""
打印网络信息
:return:
"""
for layer in self.layers:
layer.dump()
class Network(object):
def __init__(self, layers):
'''
初始化一个全连接神经网络
layers: 二维数组，描述神经网络每层节点数
'''
self.connections = Connections()
self.layers = []
layer_count = len(layers)
node_count = 0
for i in range(layer_count):
self.layers.append(Layer(i, layers[i]))
for layer in range(layer_count - 1):
connections = [
Connection(upstream_node, downstream_node)
for upstream_node in self.layers[layer].nodes
for downstream_node in self.layers[layer + 1].nodes[:-1]
]
for conn in connections:
self.connections.add_connection(conn)
conn.downstream_node.append_upstream_connection(conn)
conn.upstream_node.append_downstream_connection(conn)
def train(self, labels, data_set, rate, iteration):
'''
训练神经网络
labels: 数组，训练样本标签。每个元素是一个样本的标签。
data_set: 二维数组，训练样本特征。每个元素是一个样本的特征。
'''
for i in range(iteration):
for d in range(len(data_set)):
self.train_one_sample(labels[d], data_set[d], rate)
def train_one_sample(self, label, sample, rate):
'''
内部函数，用一个样本训练网络
'''
self.predict(sample)
self.calc_delta(label)
self.update_weight(rate)
def calc_delta(self, label):
'''
内部函数，计算每个节点的delta
'''
output_nodes = self.layers[-1].nodes
for i in range(len(label)):
output_nodes[i].calc_output_layer_delta(label[i])
for layer in self.layers[-2::-1]:
for node in layer.nodes:
node.calc_hidden_layer_delta()
def update_weight(self, rate):
'''
内部函数，更新每个连接权重
'''
for layer in self.layers[:-1]:
for node in layer.nodes:
for conn in node.downstream:
conn.update_weight(rate)
def calc_gradient(self):
'''
内部函数，计算每个连接的梯度
'''
for layer in self.layers[:-1]:
for node in layer.nodes:
for conn in node.downstream:
conn.calc_gradient()
def get_gradient(self, label, sample):
'''
获得网络在一个样本下，每个连接上的梯度
label: 样本标签
sample: 样本输入
'''
self.predict(sample)
self.calc_delta(label)
self.calc_gradient()
def predict(self, sample):
'''
根据输入的样本预测输出值
sample: 数组，样本的特征，也就是网络的输入向量
'''
self.layers[0].set_output(sample)
for i in range(1, len(self.layers)):
self.layers[i].calc_output()
return map(lambda node: node.output, self.layers[-1].nodes[:-1])
def dump(self):
'''
打印网络信息
'''
for layer in self.layers:
layer.dump()
def gradient_check(network, sample_feature, sample_label):
'''
梯度检查
network: 神经网络对象
sample_feature: 样本的特征
sample_label: 样本的标签
'''
# 计算网络误差
network_error = lambda vec1, vec2: \
0.5 * reduce(lambda a, b: a + b,
map(lambda v: (v[0] - v[1]) * (v[0] - v[1]),
zip(vec1, vec2)))
# 获取网络在当前样本下每个连接的梯度
network.get_gradient(sample_feature, sample_label)
# 对每个权重做梯度检查
for conn in network.connections.connections:
# 获取指定连接的梯度
actual_gradient = conn.get_gradient()
# 增加一个很小的值，计算网络的误差
epsilon = 0.0001
conn.weight += epsilon
error1 = network_error(network.predict(sample_feature),
sample_label)
# 减去一个很小的值，计算网络的误差
conn.weight -= 2 * epsilon # 刚才加过了一次，因此这里需要减去2倍
error2 = network_error(network.predict(sample_feature),
sample_label)
# 根据式6计算期望的梯度值
expected_gradient = (error2 - error1) / (2 * epsilon)
# 打印
print 'expected gradient: \t%f\nactual gradient: \t%f' % (
expected_gradient, actual_gradient)
