什么是神经网络
本文结构：
- 什么是神经网络
- 什么是神经元
- 神经网络的计算和训练
- 代码实现
1. 什么是神经网络
神经网络就是按照一定规则将多个神经元连接起来的网络
例如全连接（full connected）神经网络，它的规则包括：
- 有三种层：输入层，输出层，隐藏层。
- 同一层的神经元之间没有连接。
- full connected的含义：第N层的每个神经元和第N-1层的所有神经元相连，第N-1层神经元的输出就是第N层神经元的输入。
- 每个连接都有一个权值。
不同的神经网络，具有不同的连接规则
2. 什么是神经元
神经元和感知器的区别也是在激活函数：
感知器，它的激活函数是阶跃函数；神经元，激活函数往往选择sigmoid函数或tanh函数等
其中sigmoid函数的公式和图示如下：
sigmoid函数的求导公式：
3. 神经网络的训练
先向前计算，再向后传播
例如上面神经网络的结构
输入层，首先将输入向量的每个元素的值，赋给输入层的对应神经元
隐藏层，前一层传递过来的输入值，加权求和后，再输入到激活函数中，根据如下公式，向前计算这一层的每个神经元的值
输出层的计算和隐藏层的一样
用矩阵来表示
这个公式适用于每个隐藏层和输出层，就是W的值和f的形式会不一样，
其中W是某一层的权重矩阵，x是某层的输入向量，a是某层的输出向量
模型要学习的东西就是W。
诸如神经网络的连接方式、网络的层数、每层的节点数这些参数，不是学习出来的，而是人为事先设置的，称之为超参数。
训练它们的方法和前面感知器中用到的一样，就是要用梯度下降算法：
4. 代码实现
接下来实现一个全连接网络，采用面向对象设计。
基本模型如下：
如上图，可以分解出5个领域对象来实现神经网络：
- Network 神经网络对象，提供API接口。它由若干层对象组成以及连接对象组成。
- Layer 层对象，由多个节点组成。
- Node 节点对象计算和记录节点自身的信息（比如输出值α、误差项δ等），以及与这个节点相关的上下游的连接。
- Connection 每个连接对象都要记录该连接的权重。
- Connections 仅仅作为Connection的集合对象，提供一些集合操作
Node实现如下：
# 节点类，负责记录和维护节点自身信息以及这个节点相关的上下游连接，实现输出值和误差项的计算
class Node(object):
def __init__(self, layer_index, node_index):
'''
构造节点对象。
:param layer_index: 节点所属的层的编号
:param node_index: 节点的编号
'''
self.layer_index = layer_index
self.node_index = node_index
self.downstream = []
self.upstream = []
self.output = 0
self.delta = 0
def set_output(self, output):
'''
设置节点的输出值。如果节点属于输入层会用到这个函数。
'''
self.output = output
def append_downstream_connection(self, conn):
'''
添加一个到下游节点的连接
'''
self.downstream.append(conn)
def append_upstream_connection(self, conn):
'''
添加一个到上游节点的连接
'''
self.upstream.append(conn)
def cal_output(self):
'''
根据式1计算节点的输出
'''
output = functools.reduce(lambda ret, conn: ret + conn.upstream_node.output * conn.weight,
self.upstream, 0)
self.output = sigmoid(output)
def calc_hidden_layer_delta(self):
'''
节点属于隐藏层时，根据式4计算delta
'''
downstream_delta = functools.reduce(
lambda ret, conn: ret + conn.downstream_node.delta * conn.weight,
self.downstream, 0.0)
self.delta = self.output * (1 - self.output) * downstream_delta
def calc_output_layer_delta(self, label):
'''
节点属于输出层时，根据式3计算delta
'''
self.delta = self.output * (1 - self.output) * (label - self.output)
def __str__(self):
'''
打印节点的信息
'''
node_str = '%u-%u: output: %f delta: %f' % (self.layer_index, self.node_index, self.output, self.delta)
downstream_str = functools.reduce(lambda ret, conn: ret + '\n\t' + str(conn), self.downstream, '')
upstream_str = functools.reduce(lambda ret, conn: ret + '\n\t' + str(conn), self.upstream, '')
return node_str + '\n\tdownstream:' + downstream_str + '\n\tupstream:' + upstream_str
ConstNode对象，为了实现一个输出恒为1的节点（计算偏置项wb时需要）：
class ConstNode(object):
def __init__(self, layer_index, node_index):
'''
构造节点对象。
:param layer_index: 节点所属的层的编号。
:param node_index: 节点的编号。
'''
self.layer_index = layer_index
self.node_index = node_index
self.downstream = []
self.output = 1
def append_downstream_connection(self, conn):
'''
添加一个到下游节点的连接
'''
self.downstream.append(conn)
def calc_hidden_layer_delta(self):
'''
节点属于隐藏层时，根据式4计算delta
'''
downstream_delta = functools.reduce(
lambda ret, conn: ret + conn.downstream_node.delta * conn.weight,
self.downstream, 0.0
)
self.delta = self.output * (1 - self.output) * downstream_delta
def __str__(self):
'''
打印节点的信息
'''
node_str = '%u-%u: output: 1' % (self.layer_index, self.node_index)
downstream_str = functools.reduce(lambda ret, conn: ret + '\n\t' + str(conn), self.downstream, '')
return node_str + '\n\tdownstream:' + downstream_str
Layer对象，负责初始化一层。此外，作为Node的集合对象，提供对Node集合的操作。
class Layer(object):
def __init__(self, layer_index, node_count):
'''
初始化一层。
:param layer_index: 层编号
:param node_count: 层所包含的节点个数
'''
self.layer_index = layer_index
self.nodes = []
for i in range(node_count):
self.nodes.append(Node(layer_index, i))
self.nodes.append(ConstNode(layer_index, node_count))
def set_output(self, data):
'''
设置层的输出。当层是输入层时会用到
'''
for i in range(len(data)):
self.nodes[i].set_output(data[i])
def calc_out(self):
'''
计算层的输出向量
'''
for node in self.nodes[:-1]:
node.cal_output()
def dump(self):
'''
打印层的信息
'''
for node in self.nodes:
print(node)
Connection对象，主要职责是记录连接的权重，以及这个连接所关联的上下游节点。
class Connection(object):
def __init__(self, upstream_node, downstream_node):
'''
初始化连接，权重初始化是一个很小的随机数
:param upstream_node: 连接的上游节点
:param downstream_node: 连接的下游节点
'''
self.upstream_node = upstream_node
self.downstream_node = downstream_node
self.weight = random.uniform(-0.1, 0.1)
self.gradient = 0.0
def calc_gradient(self):
'''
计算梯度
'''
self.gradient = self.downstream_node.delta * self.upstream_node.output
def get_gradient(self):
'''
获得当前的梯度
'''
return self.gradient
def update_weight(self, rate):
'''
根据梯度下降法更新权重
'''
self.calc_gradient()
self.weight += rate * self.gradient
def __str__(self):
'''
打印连接信息
'''
return '(%u-%u) -> (%u-%u) = %f' % (
self.upstream_node.layer_index,
self.upstream_node.node_index,
self.downstream_node.layer_index,
self.downstream_node.node_index,
self.weight
)
Connections对象，提供Connection集合操作。
class Connections(object):
def __init__(self):
self.connections = []
def add_connection(self, connection):
self.connections.append(connection)
def dump(self):
for conn in self.connections:
print(conn)
Network对象，提供API。
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].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):
'''
训练神经网络
:param labels: 数组，训练样本标签。每个元素是一个样本的标签。
:param 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_data(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.calc_gradient()
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):
'''
获得网络在一个样本下，每个连接上的梯度
:param label: 样本标签
:param sample: 样本输入
'''
self.predict(sample)
self.calc_delta(label)
self.calc_gradient()
def predict(self, sample):
'''
根据输入的样本预测输出值
:param 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()
完整代码如下：
# -*-coding:utf-8-*-
import functools
from math import exp
import random
def sigmoid(inX):
return 1.0 / (1 + exp(-inX))
# 节点类，负责记录和维护节点自身信息以及这个节点相关的上下游连接，实现输出值和误差项的计算
class Node(object):
def __init__(self, layer_index, node_index):
'''
构造节点对象。
:param layer_index: 节点所属的层的编号
:param node_index: 节点的编号
'''
self.layer_index = layer_index
self.node_index = node_index
self.downstream = []
self.upstream = []
self.output = 0
self.delta = 0
def set_output(self, output):
'''
设置节点的输出值。如果节点属于输入层会用到这个函数。
'''
self.output = output
def append_downstream_connection(self, conn):
'''
添加一个到下游节点的连接
'''
self.downstream.append(conn)
def append_upstream_connection(self, conn):
'''
添加一个到上游节点的连接
'''
self.upstream.append(conn)
def cal_output(self):
'''
根据式1计算节点的输出
'''
output = functools.reduce(lambda ret, conn: ret + conn.upstream_node.output * conn.weight,
self.upstream, 0)
self.output = sigmoid(output)
def calc_hidden_layer_delta(self):
'''
节点属于隐藏层时，根据式4计算delta
'''
downstream_delta = functools.reduce(
lambda ret, conn: ret + conn.downstream_node.delta * conn.weight,
self.downstream, 0.0)
self.delta = self.output * (1 - self.output) * downstream_delta
def calc_output_layer_delta(self, label):
'''
节点属于输出层时，根据式3计算delta
'''
self.delta = self.output * (1 - self.output) * (label - self.output)
def __str__(self):
'''
打印节点的信息
'''
node_str = '%u-%u: output: %f delta: %f' % (self.layer_index, self.node_index, self.output, self.delta)
downstream_str = functools.reduce(lambda ret, conn: ret + '\n\t' + str(conn), self.downstream, '')
upstream_str = functools.reduce(lambda ret, conn: ret + '\n\t' + str(conn), self.upstream, '')
return node_str + '\n\tdownstream:' + downstream_str + '\n\tupstream:' + upstream_str
# ConstNode对象，为了实现一个输出恒为1的节点（计算偏置项wb时需要）
class ConstNode(object):
def __init__(self, layer_index, node_index):
'''
构造节点对象。
:param layer_index: 节点所属的层的编号。
:param node_index: 节点的编号。
'''
self.layer_index = layer_index
self.node_index = node_index
self.downstream = []
self.output = 1
def append_downstream_connection(self, conn):
'''
添加一个到下游节点的连接
'''
self.downstream.append(conn)
def calc_hidden_layer_delta(self):
'''
节点属于隐藏层时，根据式4计算delta
'''
downstream_delta = functools.reduce(
lambda ret, conn: ret + conn.downstream_node.delta * conn.weight,
self.downstream, 0.0
)
self.delta = self.output * (1 - self.output) * downstream_delta
def __str__(self):
'''
打印节点的信息
'''
node_str = '%u-%u: output: 1' % (self.layer_index, self.node_index)
downstream_str = functools.reduce(lambda ret, conn: ret + '\n\t' + str(conn), self.downstream, '')
return node_str + '\n\tdownstream:' + downstream_str
# Layer对象，负责初始化一层。此外，作为Node的对象，提供Node集合的操作。
class Layer(object):
def __init__(self, layer_index, node_count):
'''
初始化一层。
:param layer_index: 层编号
:param node_count: 层所包含的节点个数
'''
self.layer_index = layer_index
self.nodes = []
for i in range(node_count):
self.nodes.append(Node(layer_index, i))
self.nodes.append(ConstNode(layer_index, node_count))
def set_output(self, data):
'''
设置层的输出。当层是输入层时会用到
'''
for i in range(len(data)):
self.nodes[i].set_output(data[i])
def calc_out(self):
'''
计算层的输出向量
'''
for node in self.nodes[:-1]:
node.cal_output()
def dump(self):
'''
打印层的信息
'''
for node in self.nodes:
print(node)
# Connection对象，主要职责是记录连接的权重，以及这个连接所关联的上下游节点。
class Connection(object):
def __init__(self, upstream_node, downstream_node):
'''
初始化连接，权重初始化是一个很小的随机数
:param upstream_node: 连接的上游节点
:param downstream_node: 连接的下游节点
'''
self.upstream_node = upstream_node
self.downstream_node = downstream_node
self.weight = random.uniform(-0.1, 0.1)
self.gradient = 0.0
def calc_gradient(self):
'''
计算梯度
'''
self.gradient = self.downstream_node.delta * self.upstream_node.output
def get_gradient(self):
'''
获得当前的梯度
'''
return self.gradient
def update_weight(self, rate):
'''
根据梯度下降法更新权重
'''
self.calc_gradient()
self.weight += rate * self.gradient
def __str__(self):
'''
打印连接信息
'''
return '(%u-%u) -> (%u-%u) = %f' % (
self.upstream_node.layer_index,
self.upstream_node.node_index,
self.downstream_node.layer_index,
self.downstream_node.node_index,
self.weight
)
# Connections对象，提供Connection集合操作。
class Connections(object):
def __init__(self):
self.connections = []
def add_connection(self, connection):
self.connections.append(connection)
def dump(self):
for conn in self.connections:
print(conn)
# Network对象，提供API。
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].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):
'''
训练神经网络
:param labels: 数组，训练样本标签。每个元素是一个样本的标签。
:param 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_data(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.calc_gradient()
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):
'''
获得网络在一个样本下，每个连接上的梯度
:param label: 样本标签
:param sample: 样本输入
'''
self.predict(sample)
self.calc_delta(label)
self.calc_gradient()
def predict(self, sample):
'''
根据输入的样本预测输出值
:param 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()
if __name__ == '__main__':
net = Network([8, 3, 8])
net.dump()
