make your own neural network笔记整理

第一部分 神经网络如何工作

---

1. 神经网络信号前向传播，误差后向传播，选取合适的误差表达式，通过梯度下降法调节权重使误差最小，神经网络可以用于回归和分类
   
2. 学习率的引入是为了防止某个训练样本完全决定学习的模型
3. 阈值的设定，模拟生物大脑接受信号的过程，达到阈值后才激活
4. 激活函数，将输出转换为0-1之间的数，
5. 输入数据的处理，对于以下sigmoid的激活函数，若输入数据过大则输出的差别很小且接近1，若输入太小则限制了学习的能力，就成了饱和的神经网络了，不会更好的更新权重，需要避免，所以将输入取0-1之间的数，但要注意避免输入0，1，若是0则失去更新权重的能力，这样使用0.01-0.99，
   
6. 权重，初始时随机产生，可使用0-1随机数，或（0，开根号输入节点数）正态分布产生随机数等等，避免使用相同的常数尤其避免使用0，0就失去了更新权重的能力。权重要随机且要小。
   
7. 误差反向传播
   
8. 梯度下降法寻找误差最小值，有时会进入局部极小值，在训练时同一组数据增加训练次数，由于每次训练初始权重随机产生，这样可以使得梯度下降时从不同的位置开始，防止进入局部极小值，训练次数太大，耗时且容易出现过拟合，训练次数太小跳不出局部极小值，根据不同的数据集和不同的模型利用画图试验的方式寻找最优值；调整学习率，即下降时的步长，太大了容易在极小值点反复，太小了使得下降速度太小。
   
9. 误差的求解方式：采用差的平方的形式1）易求梯度2）误差函数光滑连续使得梯度易计算，没有间断和跳跃3）接近极小值时梯度变小，意味着越过极小值的风险变小；将误差对权重求偏导，并利用梯度下降法求的使误差最小的权重值。
   
10. 梯度下降法求出权重的变化量来更新权重值
    

第二部分 python 创建神经网络及神经网络优化方法

---

一，python创建神经网络

# coding: utf-8

# python notebook for Make Your Own Neural Network

import numpy
# scipy.special for the sigmoid function expit()
import scipy.special

# neural network class definition
class neuralNetwork:

    # initialise the neural network
    def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate):
        # set number of nodes in each input, hidden, output layer
        self.inodes = inputnodes
        self.hnodes = hiddennodes
        self.onodes = outputnodes

        # link weight matrices, wih and who
        # weights inside the arrays are w_i_j, where link is from node i to node j in the next layer
        # w11 w21
        # w12 w22 etc
        self.wih = numpy.random.normal(0.0, pow(self.inodes, -0.5), (self.hnodes, self.inodes))
        self.who = numpy.random.normal(0.0, pow(self.hnodes, -0.5), (self.onodes, self.hnodes))

        # learning rate
        self.lr = learningrate

        # activation function is the sigmoid function
        self.activation_function = lambda x: scipy.special.expit(x)

        pass


    # train the neural network
    def train(self, inputs_list, targets_list):
        # convert inputs list to 2d array
        inputs = numpy.array(inputs_list, ndmin=2).T
        targets = numpy.array(targets_list, ndmin=2).T

        # calculate signals into hidden layer
        hidden_inputs = numpy.dot(self.wih, inputs)
        # calculate the signals emerging from hidden layer
        hidden_outputs = self.activation_function(hidden_inputs)

        # calculate signals into final output layer
        final_inputs = numpy.dot(self.who, hidden_outputs)
        # calculate the signals emerging from final output layer
        final_outputs = self.activation_function(final_inputs)

        # output layer error is the (target - actual)
        output_errors = targets - final_outputs
        # hidden layer error is the output_errors, split by weights, recombined at hidden nodes
        hidden_errors = numpy.dot(self.who.T, output_errors)

        # update the weights for the links between the hidden and output layers
        self.who += self.lr * numpy.dot((output_errors * final_outputs * (1.0 - final_outputs)), numpy.transpose(hidden_outputs))

        # update the weights for the links between the input and hidden layers
        self.wih += self.lr * numpy.dot((hidden_errors * hidden_outputs * (1.0 - hidden_outputs)), numpy.transpose(inputs))

        pass


    # query the neural network
    def query(self, inputs_list):
        # convert inputs list to 2d array
        inputs = numpy.array(inputs_list, ndmin=2).T

        # calculate signals into hidden layer
        hidden_inputs = numpy.dot(self.wih, inputs)
        # calculate the signals emerging from hidden layer
        hidden_outputs = self.activation_function(hidden_inputs)

        # calculate signals into final output layer
        final_inputs = numpy.dot(self.who, hidden_outputs)
        # calculate the signals emerging from final output layer
        final_outputs = self.activation_function(final_inputs)

        return final_outputs

# number of input, hidden and output nodes
input_nodes = 784
hidden_nodes = 100
output_nodes = 10

# learning rate is 0.3
learning_rate = 0.3

# create instance of neural network
n = neuralNetwork(input_nodes,hidden_nodes,output_nodes, learning_rate)

train_data_file=open("/Users/apple/demo/mnist_dataset/mnist_train_100.csv",'r')
train_data_list=train_data_file.readlines()
train_data_file.close()

epochs =5
for e in range(epochs):
    for record in train_data_list:
        all_values=record.split(',')
        inputs=(numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01
        targets=numpy.zeros(output_nodes)+0.01
        targets[int(all_values[0])] = 0.99
        n.train(inputs,targets)
        pass
pass

test_data_file=open("/Users/apple/demo/mnist_dataset/mnist_test_10.csv",'r')
test_data_list=test_data_file.readlines()
test_data_file.close()

scorecard=[]

for record in test_data_list:
    all_values = record.split(',')
    inputs=(numpy.asfarray(all_values[1:])/255.0*0.99)+0.01
    outputs=n.query(inputs)
    correct_label=int(all_values[0])

    label = numpy.argmax(outputs)

    if (label==correct_label):
        scorecard.append(1)
    else:
        scorecard.append(0)
        pass
    pass

score_array=numpy.asarray(scorecard)
print ("performence = ",score_array.sum()/score_array.size)

二，神经网络优化方法
1. 隐藏节点数，隐藏层数：没有很好的办法确定隐藏节点的数目以及隐藏层的数目，目前最好的办法就是调节参数来试验，以找到最合适的输出，一般隐藏节点数不小于输出节点数

2. 学习率：太大会导致在极小值附近反复，以及在梯度下降过程跳过极小值；太小则会限制梯度下降的速度，对于特定的数据集和神经网络模型可以通过试验并作图来选取合适的学习率

3. 局部极小值：对同一数据集增加训练次数，太大易过拟合；神经网络的学习过程是个随机的过程，有时结果会表现的很好，有时则很坏；当增加训练次数时，可适当调小学习率

第三部分 神经网络进一步探索

---

1. 神经网络具有一定的抗干扰的能力，当输入的数据存在噪音时，依然可以表现很好
2. 探究神经网络通过训练数据学到了什么，可以使用逆向神经网络，即将输出输入到神经网络，观察此时的输出，可以看到神经网络的大脑里学到了什么，通过什么标准来对测试数据进行测试的
   
3. 通过对训练数据进行处理，来提高学习效果，比如手写数字识别通过旋转图片来增加训练数据