人工神经网络

「爱情、让人受尽委屈。」 2021-10-29 15:32 550阅读 0赞

# 1.基本组成 #

输入层（特征向量）  
隐藏层  
输出层

每层由神经元或单元组成；  
输入层由训练集的样本特征向量传入；  
经过连接点的权重传入下一层，上一层的加权求和，然后根据非线性方程转化为下一层的输入；  
对于多层神经网络，理论上如果有足够多的隐藏层和足够多的的训练样本，可以拟合出任意方程

# 2.设计神经网络结构 #

包括确定网络层数，每层的节点个数；  
特征向量在被传入输入层之前要进行标准化到0-1之间，为了加速训练过程；  
神经网络既可以用来解决分类问题，也可以解决回归问题；  
输出层的单元数十类别的个数；  
一般通过交叉验证的方法确定隐藏层的个数和节点的个数

# 3.反向传播 #

通过迭代处理训练集中的样本；  
对比经过神经网络后输出层的预测值和真实值；  
从输出层经过隐藏层反向传播到输入层，以最小化误差更新连接权重

# 4.算法过程 #

初始化权重和偏置：随机初始化在-1到1之间的值，每个节点有一个偏向；  
每个训练样本执行以下步骤：  
有输入层前向传播，根据初始化的参数及激活函数，计算出节点的输出，直到输出层；  
反向传播计算误差，更新权重和偏置；  
终止条件：权重的更新低于某个阈值、预测的错误率低于某个阈值、达到预设的循环次数

# 5.代码及注释 #

[mian.py][]

# -*- coding: utf-8 -*-
    
    
    from neural_network import NeuralNetwork
    
    
    def run_main():
        """
            主函数
        """
    
        # 输入层：2个节点
        # 隐含层：2个节点
        # 输出层：2个节点
        # 初始化各层的权重和偏置
        nn = NeuralNetwork(2, 2, 2,
                           hidden_layer_weights=[0.15, 0.2, 0.25, 0.3],
                           hidden_layer_bias=0.35,
                           output_layer_weights=[0.4, 0.45, 0.5, 0.55],
                           output_layer_bias=0.6)
    
        # 训练网络（这里只用一个样本作为训练作为示例）
        sample_input = [0.05, 0.1]
        sample_output = [0.01, 0.99]
        # 迭代10000次训练网络
        print('训练神经网络')
        for i in range(10000):
            # 提供输入和输出
            nn.fit(sample_input, sample_output)
            # 输出误差
            # 会看到随着迭代的增多，误差是变小的
            print('{}次迭代，误差：{}'.format(i + 1, nn.calculate_total_error([[sample_input, sample_output]])))
    
        # 测试网络（这里选取一个和训练样本接近的样本）
        print('测试神经网络:')
        test_sample = [0.049, 0.11]
    
        print('训练样本:', sample_input, sample_output)
        print()
        print('输入样本:', test_sample)
        print('预测结果:', nn.feed_forward(test_sample))
    
    
    if __name__ == '__main__':
        run_main()

neural\_network.py

# -*- coding: utf-8 -*-
    
    
    
    import random
    import math
    
    #
    # "pd_"     : 偏导数
    # "d_"      : 导数
    # "_wrt_"   : "with respect to" 对于变量
    # "w_ho"    : 由隐含层(h)到输出层(o)的weights的索引
    # "w_ih"    : 由输入层(i)到隐含层(h)的weights的索引
    
    
    class NeuralNetwork(object):
        """
            神经网络类
        """
        LEARNING_RATE = 0.5  # 学习率
    
        def __init__(self,
                     num_inputs,                    # 输入层神经元个数
                     num_hidden,                    # 隐含层神经元个数
                     num_outputs,                   # 输出层神经元个数
                     hidden_layer_weights=None,     # 隐含层神经元权重
                     hidden_layer_bias=None,        # 隐含层神经元偏置
                     output_layer_weights=None,     # 输出层神经元权重
                     output_layer_bias=None         # 输出层神经元偏置
                     ):
            # 输入层
            self.num_inputs = num_inputs
    
            # 隐含层
            self.hidden_layer = Layer(num_hidden, hidden_layer_bias)
    
            # 输出层
            self.output_layer = Layer(num_outputs, output_layer_bias)
    
            # 初始化各层权重
            self.init_weights_from_inputs_to_hidden_layer_neurons(hidden_layer_weights)
            self.init_weights_from_hidden_layer_neurons_to_output_layer_neurons(output_layer_weights)
    
        def init_weights_from_inputs_to_hidden_layer_neurons(self, hidden_layer_weights):
            """
                初始化从输入层到隐含层的权重
            """
            weight_num = 0
            for h in range(len(self.hidden_layer.neurons)):
                for i in range(self.num_inputs):
                    if not hidden_layer_weights:
                        self.hidden_layer.neurons[h].weights.append(random.random())
                    else:
                        self.hidden_layer.neurons[h].weights.append(hidden_layer_weights[weight_num])
                    weight_num += 1
    
        def init_weights_from_hidden_layer_neurons_to_output_layer_neurons(self, output_layer_weights):
            """
                初始化从隐含层到输出层的权重
            """
            weight_num = 0
            for o in range(len(self.output_layer.neurons)):
                for h in range(len(self.hidden_layer.neurons)):
                    if not output_layer_weights:
                        self.output_layer.neurons[o].weights.append(random.random())
                    else:
                        self.output_layer.neurons[o].weights.append(output_layer_weights[weight_num])
                    weight_num += 1
    
        def inspect(self):
            """
                信息输出
            """
            print('------')
            print('* 输入层: {}'.format(self.num_inputs))
            print('------')
            print('隐含层')
            self.hidden_layer.inspect()
            print('------')
            print('* 输出层')
            self.output_layer.inspect()
            print('------')
    
        def feed_forward(self, inputs):
            """
                前向传播
            """
            hidden_layer_outputs = self.hidden_layer.feed_forward(inputs)
            return self.output_layer.feed_forward(hidden_layer_outputs)
    
        def fit(self, training_inputs, training_outputs):
            """
                根据输入输出训练网络
            """
            # 前向传播
            self.feed_forward(training_inputs)
    
            # 1. 输出层神经元error计算
            pd_errors_wrt_output_neuron_total_net_input = [0] * len(self.output_layer.neurons)
            for o in range(len(self.output_layer.neurons)):
                # 求偏导
                pd_errors_wrt_output_neuron_total_net_input[o] = \
                    self.output_layer.neurons[o].calculate_pd_error_wrt_total_net_input(training_outputs[o])
    
            # 2. 隐含层神经元erro计算
            pd_errors_wrt_hidden_neuron_total_net_input = [0] * len(self.hidden_layer.neurons)
            for h in range(len(self.hidden_layer.neurons)):
                d_error_wrt_hidden_neuron_output = 0
                for o in range(len(self.output_layer.neurons)):
                    d_error_wrt_hidden_neuron_output += \
                        pd_errors_wrt_output_neuron_total_net_input[o] * self.output_layer.neurons[o].weights[h]
    
                pd_errors_wrt_hidden_neuron_total_net_input[h] = \
                    d_error_wrt_hidden_neuron_output * self.hidden_layer.neurons[h].calculate_pd_total_net_input_wrt_input()
    
            # 3. 更新输出层权重
            for o in range(len(self.output_layer.neurons)):
                for w_ho in range(len(self.output_layer.neurons[o].weights)):
                    pd_error_wrt_weight = \
                        pd_errors_wrt_output_neuron_total_net_input[o] * self.output_layer.neurons[o].calculate_pd_total_net_input_wrt_weight(w_ho)
    
                    self.output_layer.neurons[o].weights[w_ho] -= self.LEARNING_RATE * pd_error_wrt_weight
    
            # 4. 更新隐含层权重
            for h in range(len(self.hidden_layer.neurons)):
                for w_ih in range(len(self.hidden_layer.neurons[h].weights)):
                    pd_error_wrt_weight = pd_errors_wrt_hidden_neuron_total_net_input[h] * self.hidden_layer.neurons[h].calculate_pd_total_net_input_wrt_weight(w_ih)
                    self.hidden_layer.neurons[h].weights[w_ih] -= self.LEARNING_RATE * pd_error_wrt_weight
    
        def calculate_total_error(self, training_sets):
            """
                计算整体误差
            """
            total_error = 0
            for t in range(len(training_sets)):
                training_inputs, training_outputs = training_sets[t]
                self.feed_forward(training_inputs)
                for o in range(len(training_outputs)):
                    total_error += self.output_layer.neurons[o].calculate_error(training_outputs[o])
            return total_error
    
    
    class Layer:
        """
            网络层类
        """
        def __init__(self, num_neurons, bias):
    
            # 同一层神经元的偏置都一致
            self.bias = bias if bias else random.random()
    
            self.neurons = []
            for i in range(num_neurons):
                self.neurons.append(Neuron(self.bias))
    
        def inspect(self):
            """
                信息输出
            """
            print('神经元:', len(self.neurons))
            for n in range(len(self.neurons)):
                print(' 神经元', n)
                for w in range(len(self.neurons[n].weights)):
                    print('  权重:', self.neurons[n].weights[w])
                print('  偏置:', self.bias)
    
        def feed_forward(self, inputs):
            """
                前向传播
            """
            outputs = []
            for neuron in self.neurons:
                outputs.append(neuron.calculate_output(inputs))
            return outputs
    
        def get_outputs(self):
            """
                获取输出结果
            """
            outputs = []
            for neuron in self.neurons:
                outputs.append(neuron.output)
            return outputs
    
    
    class Neuron(object):
        """
            神经元节点
        """
        def __init__(self, bias):
            self.bias = bias
            self.weights = []
    
        def calculate_output(self, inputs):
            """
                计算输出
            """
            self.inputs = inputs
            # 激活函数
            self.output = self.activate(self.calculate_total_net_input())
            return self.output
    
        def calculate_total_net_input(self):
            """
                计算整体输入
            """
            total = 0
            for i in range(len(self.inputs)):
                total += self.inputs[i] * self.weights[i]
            return total + self.bias
    
        def activate(self, total_net_input):
            """
                逻辑回归激活函数
            """
            return 1 / (1 + math.exp(-total_net_input))
    
        def calculate_pd_error_wrt_total_net_input(self, target_output):
            """
                计算相对于整体网络输入的误差偏导数
            """
            return self.calculate_pd_error_wrt_output(target_output) * self.calculate_pd_total_net_input_wrt_input();
    
        # The error for each neuron is calculated by the Mean Square Error method:
        def calculate_error(self, target_output):
            """
                计算每个神经元节点的误差（均方误差)
            """
            return 0.5 * (target_output - self.output) ** 2
    
        def calculate_pd_error_wrt_output(self, target_output):
            """
                计算相对于输出的误差偏导数
            """
            return -(target_output - self.output)
    
        def calculate_pd_total_net_input_wrt_input(self):
            """
                计算相对于输入的总体偏导数
            """
            return self.output * (1 - self.output)
    
        def calculate_pd_total_net_input_wrt_weight(self, index):
            """
                计算相对于权重的整体输入的偏导数
            """
            return self.inputs[index]

[mian.py]: http://mian.py