[关闭]
@Pigmon 2017-09-17T20:24:48.000000Z 字数 10310 阅读 941

机器学习的数学基础 Day 5 P1 《人工神经网络初步》

Python

Neuron 类

  1. # -*- coding: utf-8 -*-
  2. """
  3. Created on Sun Apr 09 17:25:53 2017
  5. @author: Yuan Sheng
  6. """
  8. #import random
  9. import numpy as np
  10. import random as rnd
  12. def sigmoid(x):
  13.     return 1. / (1. + np.e ** (-x))
  15. class Neuron:
  16.     "神经元基类"
  18.     # layer: 所在层，第一个输入层为0
  19.     # index: 在当前层的位置，最上面为0
  20.     # gid: 全局位置，从 0 开始
  21.     #   整个网络输入在左，输出在右
  22.     #   从输入神经元算起，按左上到右下依次排列
  23.     #         2
  24.     #   ->0       5   7->
  25.     #         3
  26.     #   ->1       6    8->
  27.     #         4
  28.     layer, index, gid = 0, 0, 0
  29.     # output: 输出值
  30.     # error: 误差项
  31.     output, error = 0.0, 0.0
  33.     def __init__ (self, _layer, _index, _global_index):
  34.         self.layer, self.index, self.gid = _layer, _index, _global_index
  35.         self.bias = rnd.uniform(-1.0, 1.0)
  37.     def sigmoid_derive(self):
  38.         return self.output * (1.0 - self.output)
  40.     def count_out(self, _in_w, _in_vec):
  41.         "计算输出值"       
  42.         if len(_in_w) != len(_in_vec):
  43.             return 0.0
  45.         self.output = sigmoid(self.bias + np.dot(_in_w, _in_vec))        
  46.         return self.output
  48.     def count_error(self, _out_w, _next_layer_error):
  49.         "计算误差项"
  50.         if len(_out_w) != len(_next_layer_error):
  51.             return 0.0
  53.         self.error = self.sigmoid_derive() * np.dot(_out_w, _next_layer_error)
  54.         return self.error
  56.     def update_bais(self, _eta):
  57.         "调整 bias 值"
  58.         self.bias -= _eta * self.error
  60.     def debug(self):
  61.         print ('%d: <%d, %d> b=%f' % (self.gid, self.layer, self.index, self.bias))
  63. class OutputNeuron(Neuron):
  64.     "输出层神经元"
  65.     def __init__ (self, _layer, _index, _global_index):
  66.         Neuron.__init__(self, _layer, _index, _global_index)
  68.     def count_error(self, _label):
  69.         self.error = self.sigmoid_derive() * (self.output - _label)
  70.         return self.error

BPNN 类

  1. # -*- coding: utf-8 -*-
  2. """
  3. Created on Sun Apr 09 20:50:49 2017
  5. @author: Yuan Sheng
  7. 为了降低阅读代码的难度，并没有采用矩阵乘法，而是直接套用ppt中的公式
  8. """
  10. import numpy as np
  11. import random as rnd
  12. from neuron import Neuron, OutputNeuron
  14. class BPNN:
  15.     "BP前馈神经网络"
  17.     # @input_vec_len: 输入层维数
  18.     # @output_vec_len: 输出层维数
  19.     # @hidden_layer_count: 隐藏层数
  20.     # @eta: 学习率，步长
  21.     # @threshold: 全局均方差的阈值
  22.     input_vec_len, output_vec_len, hidden_layer_count, eta, threshold = 2, 1, 0, 0.2, 0.1
  24.     # @hidden_layers_len： 每个隐藏层维数
  25.     # @hidden_neurons：隐藏神经元二维数组
  26.     # @output_neurons：输出神经元一维数组
  27.     # @weights：权重三维数组
  28.     hidden_layers_len, hidden_neurons, output_neurons, weights = [], [], [], []
  30.     # 全局位置到(layer, index)的映射字典; 当前的输出值
  31.     gid_dict = {}
  33.     # -----------------输出变量-----------------
  34.     _correct_rate, _output_vec = 0.0, []
  36.     # -------------------------------------------------------------------------
  37.     def __init__ (self, _in_len, _out_len, _hiddens_len, _learning_rate):
  38.         self.input_vec_len, self.output_vec_len, self.hidden_layer_count, self.hidden_layers_len, self.eta = \
  39.             _in_len, _out_len, len(_hiddens_len), _hiddens_len, _learning_rate
  41.         # 生成隐藏层 Nerons
  42.         cnter = _in_len
  43.         for i in range(0, len(_hiddens_len)):
  44.             cnt, layer_list = _hiddens_len[i], []
  45.             for j in range(0, cnt):
  46.                 layer_list.append(Neuron(i, j, cnter))
  47.                 self.gid_dict[cnter] = (i, j)
  48.                 cnter += 1
  49.             self.hidden_neurons.append(layer_list)
  51.         # 生成输出层 Neurons
  52.         for i in range(0, _out_len):
  53.             self.output_neurons.append(OutputNeuron(self.hidden_layer_count, i, cnter))
  54.             self.gid_dict[cnter] = (self.hidden_layer_count, i)
  55.             cnter += 1
  57.         # 生成权重，例如：
  58.         # 形如下面这样的输入层2，隐藏层为(3, 2)，输出层为2:
  59.         #
  60.         #         2
  61.         #   ->0       5   7->
  62.         #         3
  63.         #   ->1       6    8->
  64.         #         4
  65.         #
  66.         # 权重数组如下所示：
  67.         # [
  68.         #     [ [w_0_2, w_1_2], [w_0_3, w_1_3], [w_0_4, w_1_4] ],
  69.         #     [ [w_2_5, w_3_5, w_4_5], [w_2_6, w_3_6, w_4_6] ],
  70.         #     [ [w_5_7, w_6_7], [w_5_8, w_6_8] ]
  71.         # ]
  72.         #
  73.         # 可以在循环最内部，用pair.append(self.debug_weight_index(cnt_list, i, j, k))调试
  74.         #
  75.         cnt_list = np.append(np.array([_in_len]), np.append(_hiddens_len, _out_len))
  76.         #print cnt_list
  77.         for i in range(0, len(cnt_list)-1):
  78.             layer1_cnt, layer2_cnt, layer_weight = cnt_list[i], cnt_list[i + 1], []
  80.             for j in range(0, layer2_cnt):
  81.                 pair = []
  82.                 for k in range(0, layer1_cnt):
  83.                     pair.append(rnd.uniform(-1.0, 1.0))
  84.                     #pair.append(self.debug_weight_index(cnt_list, i, j, k))
  85.                 layer_weight.append(pair)
  87.             self.weights.append(layer_weight)            
  89.     # -------------------------------------------------------------------------        
  90.     def input_weights_of(self, layer, index):
  91.         """
  92.         得到在第layer层的第index个神经元的输入权重（左侧）列表。
  93.         layer 0 代表第一个隐藏层，index 0代表最上面的神经元
  94.         """
  95.         return self.weights[layer][index]
  97.     # -------------------------------------------------------------------------
  98.     def input_weights_of_gid(self, _gid):
  99.         "通过gid得到输入权重列表"
  100.         return self.input_weights_of(self.gid_dict[_gid][0], self.gid_dict[_gid][1])
  102.     # -------------------------------------------------------------------------    
  103.     def output_weights_of(self, layer, index):
  104.         """
  105.         得到在第layer层的第index个神经元的输出权重（右侧）列表。
  106.         layer 0 代表第一个隐藏层，index 0代表最上面的神经元
  107.         """        
  108.         # 如果是输出层的神经元，返回空数组
  109.         if layer == self.hidden_layer_count:
  110.             return []
  112.         next_layer_weights, ret = self.weights[layer + 1], []
  113.         for group in next_layer_weights:
  114.             ret.append(group[index])
  116.         return ret
  118.     # -------------------------------------------------------------------------        
  119.     def output_weights_of_gid(self, _gid):
  120.         "通过gid得到输出权重列表"
  121.         return self.output_weights_of(self.gid_dict[_gid][0], self.gid_dict[_gid][1])
  123.     # -------------------------------------------------------------------------        
  124.     def pre_layer_outs(self, layer, input_vec):
  125.         """
  126.         得到在第layer层的第index个神经元的<前一层>神经元的值的列表。
  127.         layer 0 代表第一个隐藏层，index 0代表最上面的神经元
  128.         """
  129.         if layer == 0:
  130.             return input_vec
  131.         else:
  132.             pre_layer_neurons, ret = self.hidden_neurons[layer - 1], []
  133.             for neuron in pre_layer_neurons:
  134.                 ret.append(neuron.output)
  135.             return ret
  137.     # -------------------------------------------------------------------------            
  138.     def next_layer_errors(self, layer):
  139.         "得到第layer+1层的神经元的误差项列表"
  141.         # 如果是输出层的神经元，返回空数组
  142.         if layer >= self.hidden_layer_count:
  143.             return []
  145.         next_layer_neurons, ret = [], []
  147.         if layer == self.hidden_layer_count - 1:
  148.             next_layer_neurons = self.output_neurons
  149.         else:
  150.             next_layer_neurons = self.hidden_neurons[layer + 1]
  152.         for neuron in next_layer_neurons:
  153.             ret.append(neuron.error)
  155.         return ret
  157.     # -------------------------------------------------------------------------        
  158.     def forward(self, input_vec):
  159.         "前向传播计算值的过程"
  160.         assert len(input_vec) == self.input_vec_len
  161.         self._output_vec = []
  163.         for i in range(0, len(self.hidden_neurons)):
  164.             hidden_layer = self.hidden_neurons[i]
  165.             for j in range(0, len(hidden_layer)):
  166.                 neuron, input_values, input_weights = \
  167.                     hidden_layer[j], self.pre_layer_outs(i, input_vec), self.input_weights_of(i, j)
  168.                 neuron.count_out(input_weights, input_values)
  170.         for j in range(0, len(self.output_neurons)):
  171.             neuron, input_values, input_weights = self.output_neurons[j], \
  172.                 self.pre_layer_outs(self.hidden_layer_count, input_vec), self.input_weights_of(self.hidden_layer_count, j)
  173.             neuron.count_out(input_weights, input_values)
  174.             self._output_vec.append(neuron.output)
  176.         return self._output_vec;
  178.     # -------------------------------------------------------------------------            
  179.     def backward(self, _result_vec, _label_vec):
  180.         "后向传播误差项"
  181.         assert len(_result_vec) == len(_label_vec)
  183.         # 计算输出层误差项
  184.         for j in range(0, len(self.output_neurons)):
  185.             self.output_neurons[j].count_error(_label_vec[j])
  187.         # 从后向前计算隐藏层误差项
  188.         arr, length = self.hidden_neurons[::-1], len(self.hidden_neurons)
  189.         for i in range(0, length):
  190.             hidden_layer, layer_idx = arr[i], length - i - 1
  191.             for j in range(0, len(hidden_layer)):
  192.                 neuron, output_weights, next_layer_errors = \
  193.                     hidden_layer[j], self.output_weights_of(layer_idx, j), self.next_layer_errors(layer_idx)
  194.                 neuron.count_error(output_weights, next_layer_errors)
  196.     # -------------------------------------------------------------------------                
  197.     def update_param(self, _inpput_vec):
  198.         "调整误差和 bias 的值，可以放到 backward 函数里，单独写出来是为了看起来清晰"
  200.         # 调整输出层的输入权重和 bias
  201.         for j in range(0, len(self.output_neurons)):
  202.             neuron, input_values, input_weights = self.output_neurons[j], \
  203.                 self.pre_layer_outs(self.hidden_layer_count, []), self.input_weights_of(self.hidden_layer_count, j)
  205.             neuron.update_bais(self.eta)
  206.             for i in range(0, len(input_weights)):
  207.                 input_weights[i] -= self.eta * neuron.error * input_values[i]
  208.             # 更新 self.weights
  209.             self.weights[self.hidden_layer_count][j] = input_weights
  211.         # 调整隐藏层的输入权重和 bias
  212.         for i in range(0, len(self.hidden_neurons)):
  213.             hidden_layer = self.hidden_neurons[i]
  214.             for j in range(0, len(hidden_layer)):
  215.                 neuron, input_values, input_weights =\
  216.                     hidden_layer[j], self.pre_layer_outs(i, _inpput_vec), self.input_weights_of(i, j)
  218.                 neuron.update_bais(self.eta)
  219.                 for k in range(0, len(input_weights)):
  220.                     input_weights[k] -= self.eta * neuron.error * input_values[k]
  221.                 # 更新 self.weights
  222.                 self.weights[i][j] = input_weights
  225.     # -------------------------------------------------------------------------
  226.     @staticmethod
  227.     def correct_rate(_vec1, _vec2):
  228.         "正确率"
  229.         assert len(_vec1) == len(_vec2)
  231.         counter = 0        
  232.         for i in range(0, len(_vec1)):
  233.             if abs(_vec1[i] - _vec2[i]) < 0.5:
  234.                 counter += 1
  236.         return float(counter) / float(len(_vec1))
  238.     # -------------------------------------------------------------------------
  239.     def total_error_var(self, _train_set):
  240.         total = 0
  242.         for smpl in _train_set:
  243.             total += (self.predict_labeled([smpl])[0] - smpl[1]) ** 2
  245.         return total / len(_train_set)
  247.     # -------------------------------------------------------------------------
  248.     def predict_labeled(self, _test_set):
  249.         "_test_set 每个元素，传入之前需要格式化成 [[x1, x2, ...], label]"
  251.         assert len(_test_set) > 0 and len(_test_set[0]) == 2
  253.         ret_vec, label_vec = [], []
  254.         for sample in _test_set:
  255.             ret_vec.append(self.forward(sample[0])[0])
  256.             label_vec.append(sample[1])
  258.         self._correct_rate = BPNN.correct_rate(ret_vec, label_vec)
  260.         return ret_vec
  262.     # -------------------------------------------------------------------------
  263.     @staticmethod
  264.     def sigsign(x):
  265.         if x >= 0.5:
  266.             return 1
  267.         else:
  268.             return 0
  270.     # -------------------------------------------------------------------------
  271.     def predict(self, _attr_set):
  272.         "只包含特征的测试集，[[x1, x2, ...], [x1, x2,...], ...]"
  274.         ret_vec = []        
  275.         for point in _attr_set:
  276.             #ret_vec.append(self.forward(point))
  277.             ret_vec.append(BPNN.sigsign(self.forward(point)[0]))
  279.         return ret_vec
  281.     # -------------------------------------------------------------------------    
  282.     def fit(self, _train_set, max_epochs = 10000):
  283.         "_train_set 每个元素，传入之前需要格式化成 [[x1, x2, ...], label]"
  285.         assert len(_train_set) > 0 and len(_train_set[0]) == 2        
  286.         counter, go_through = 0, False
  288.         while (counter <= max_epochs):
  289.             if self.total_error_var(_train_set) <= self.threshold:
  290.                 go_through = True
  291.                 break
  293.             # 1. 随机选取一个测试样本
  294.             sample = rnd.choice(_train_set)
  295.             input_vec, label = sample[0], sample[1] 
  296.             # 2. 前向计算值
  297.             y_hat = self.forward(input_vec)
  298.             # 3. 反向传播误差
  299.             self.backward([y_hat], [label])
  300.             # 4. 更新参数
  301.             self.update_param(input_vec)
  303.             counter += 1                
  305.         return go_through
  307.     # -------------------------------------------------------------------------
  308.     # Debug Functions
  309.     # -------------------------------------------------------------------------
  310.     def debug(self):
  311.         "输出 debug 信息"
  313.         print ('Hidden Layers Length: ' + str(nn.hidden_layers_len))
  314.         print ('Hidden Neurons: ')
  316.         for layer_neurons in self.hidden_neurons:
  317.             for neuron in layer_neurons:
  318.                 print (neuron.debug())
  320.         for neuron in self.output_neurons:
  321.             print (neuron.debug())
  323.         print (self.weights)
  325.     # -------------------------------------------------------------------------       
  326.     def debug_weight_index(self, cnt_list, layer, next_layer_index, current_layer_index):
  327.         """
  328.         测试用，生成权重下标。如连接3和8号神经元的权重返回 'w_3_8'
  329.         layer 是从输入层开始为0， 依次+1
  330.         调用方式：
  331.         在构造函数生成weights的循环最内部 pair.append(self.debug_weight_index(cnt_list, i, j, k))
  332.         """
  334.         # 当前层起始位置
  335.         current_layer_start_index = 0 
  336.         for i in range(0, layer):        
  337.             current_layer_start_index += cnt_list[i]
  338.         # 下一层的起始位置
  339.         next_layer_start_index = current_layer_start_index + cnt_list[layer]
  341.         idx1, idx2 = current_layer_start_index + current_layer_index, \
  342.             next_layer_start_index + next_layer_index
  344.         #return 'w_%d_%d' % (idx1, idx2)
  345.         return float(idx1) + idx2 / 10.0 # temp test
  347. if __name__ == '__main__':
  348.     X = [ [[0, 0], 0], [[0, 1], 1], [[1, 0], 1], [[1, 1], 0] ]
  349.     T = [[0.1, 0.085], [-0.12, 0.88], [1.13, 0.1], [0.8, 1.2]] # 期望输出：[0, 1, 1, 0]
  351.     nn = BPNN(2, 1, [2], 0.2)
  353.     # -----test-----
  354.     print (nn.fit(X))
  355.     print (nn._correct_rate)
  357.     print (nn.predict(T))
  358.     #nn.debug()
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注