本文目录一览：
一文搞懂梯度下降&反向传播
如果把神经网络模型比作一个黑箱，把模型参数比作黑箱上面一个个小旋钮，那么根据通用近似理论（universal approximation theorem），只要黑箱上的旋钮数量足够多，而且每个旋钮都被调节到合适的位置，那这个模型就可以实现近乎任意功能（可以逼近任意的数学模型）。
显然，这些旋钮（参数）不是由人工调节的，所谓的机器学习，就是通过程序来自动调节这些参数。神经网络不仅参数众多（少则十几万，多则上亿），而且网络是由线性层和非线性层交替叠加而成，上层参数的变化会对下层的输出产生非线性的影响，因此，早期的神经网络流派一度无法往多层方向发展，因为他们找不到能用于任意多层网络的、简洁的自动调节参数的方法。
直到上世纪80年代，祖师爷辛顿发明了反向传播算法，用输出误差的均方差（就是loss值）一层一层递进地反馈到各层神经网络，用梯度下降法来调节每层网络的参数。至此，神经网络才得以开始它的深度之旅。
本文用python自己动手实现梯度下降和反向传播算法。 请点击这里 到Github上查看源码。
梯度下降法是一种将输出误差反馈到神经网络并自动调节参数的方法，它通过计算输出误差的loss值（ J ）对参数 W 的导数，并沿着导数的反方向来调节 W ，经过多次这样的操作，就能将输出误差减小到最小值，即曲线的最低点。
虽然Tensorflow、Pytorch这些框架都实现了自动求导的功能，但为了彻底理解参数调节的过程，还是有必要自己动手实现梯度下降和反向传播算法。我相信你和我一样，已经忘了之前学的微积分知识，因此，到可汗学院复习下 Calculus
和 Multivariable Calculus 是个不错的方法，或是拜读 这篇关于神经网络矩阵微积分的文章 。
Figure2是求导的基本公式，其中最重要的是 Chain Rule ，它通过引入中间变量，将“ y 对 x 求导”的过程转换为“ y 对中间变量 u 求导，再乘以 u 对 x 求导”，这样就将一个复杂的函数链求导简化为多个简单函数求导。
如果你不想涉及这些求导的细节，可以跳过具体的计算，领会其思想就好。
对于神经网络模型： Linear - ReLu - Linear - MSE(Loss function) 来说，反向传播就是根据链式法则对 求导，用输出误差的均方差（MSE）对模型的输出求导，并将导数传回上一层神经网络，用于它们来对 w 、 b 和 x （上上层的输出）求导，再将 x 的导数传回到它的上一层神经网络，由此将输出误差的均方差通过递进的方式反馈到各神经网络层。
对于 求导的第一步是为这个函数链引入中间变量：
接着第二步是对各中间变量求导，最后才是将这些导数乘起来。
首先，反向传播的起点是对loss function求导，即 。 ：
mse_grad()之所以用unsqueeze(-1)给导数增加一个维度，是为了让导数的shape和tensor shape保持一致。
linear层的反向传播是对 求导，它也是一个函数链，也要先对中间变量求导再将所有导数相乘：
这些中间变量的导数分别是：
对向量 求导，指的是对向量所有的标量求偏导（ ），即： ，这个横向量也称为y的梯度。
这里 ，是一个向量，因此， 求导，指的是y的所有标量（y_1, y_2, ..., y_n）对向量x求偏导，即：
。
这个矩阵称为雅克比矩阵，它是个对角矩阵，因为 ，因此 。
同理， 。
因此，所有中间导数相乘的结果：
lin_grad() 中的inp.g、w.g和b.g分别是求 的导数，以inp.g为例，它等于 ，且需要乘以前面各层的导数，即 outp.g @ w.t() ，之所以要用点积运算符（@）而不是标量相乘，是为了让它的导数shape和tensor shape保持一致。同理，w.g和b.g也是根据相同逻辑来计算的。
ReLu层的求导相对来说就简单多了，当输入 = 0时，导数为0，当输入 0时，导数为1。
求导运算终于结束了，接下来就是验证我们的反向传播是否正确。验证方法是将forward_backward()计算的导数和Pytorch自动微分得到的导数相比较，如果它们相近，就认为我们的反向传播算法是正确的。
首先，将计算好的参数导数保存到w1g、b1g、w2g和b2g中，再用Pytorch的自动微分来求w11、b11、w22和b22的导数。
最后，用np.allclose()来比较导数间的差异，如果有任何一个导数不相近，assert就会报错。结果证明，我们自己动手实现的算法是正确的。
反向传播是遵循链式法则的，它将前向传播的输出作为输入，输入作为输出，通过递进的方式将求导这个动作从后向前传递回各层。神经网络参数的求导需要进行矩阵微积分计算，根据这些导数的反方向来调节参数，就可以让模型的输出误差的优化到最小值。
欢迎关注和点赞，你的鼓励将是我创作的动力
从零开始用Python构建神经网络
从零开始用Python构建神经网络
动机：为了更加深入的理解深度学习，我们将使用 python 语言从头搭建一个神经网络，而不是使用像 Tensorflow 那样的封装好的框架。我认为理解神经网络的内部工作原理，对数据科学家来说至关重要。
这篇文章的内容是我的所学，希望也能对你有所帮助。
神经网络是什么?
介绍神经网络的文章大多数都会将它和大脑进行类比。如果你没有深入研究过大脑与神经网络的类比，那么将神经网络解释为一种将给定输入映射为期望输出的数学关系会更容易理解。
神经网络包括以下组成部分
? 一个输入层，x
? 任意数量的隐藏层
? 一个输出层，?
? 每层之间有一组权值和偏置，W and b
? 为隐藏层选择一种激活函数，σ。在教程中我们使用 Sigmoid 激活函数
下图展示了 2 层神经网络的结构(注意：我们在计算网络层数时通常排除输入层)
2 层神经网络的结构
用 Python 可以很容易的构建神经网络类
训练神经网络
这个网络的输出 ? 为：
你可能会注意到，在上面的等式中，输出 ? 是 W 和 b 函数。
因此 W 和 b 的值影响预测的准确率. 所以根据输入数据对 W 和 b 调优的过程就被成为训练神经网络。
每步训练迭代包含以下两个部分:
? 计算预测结果 ?，这一步称为前向传播
? 更新 W 和 b,，这一步成为反向传播
下面的顺序图展示了这个过程：
前向传播
正如我们在上图中看到的，前向传播只是简单的计算。对于一个基本的 2 层网络来说，它的输出是这样的：
我们在 NeuralNetwork 类中增加一个计算前向传播的函数。为了简单起见我们假设偏置 b 为0：
但是我们还需要一个方法来评估预测结果的好坏(即预测值和真实值的误差)。这就要用到损失函数。
损失函数
常用的损失函数有很多种，根据模型的需求来选择。在本教程中，我们使用误差平方和作为损失函数。
误差平方和是求每个预测值和真实值之间的误差再求和，这个误差是他们的差值求平方以便我们观察误差的绝对值。
训练的目标是找到一组 W 和 b，使得损失函数最好小，也即预测值和真实值之间的距离最小。
反向传播
我们已经度量出了预测的误差(损失)，现在需要找到一种方法来传播误差，并以此更新权值和偏置。
为了知道如何适当的调整权值和偏置，我们需要知道损失函数对权值 W 和偏置 b 的导数。
回想微积分中的概念，函数的导数就是函数的斜率。
梯度下降法
如果我们已经求出了导数，我们就可以通过增加或减少导数值来更新权值 W 和偏置 b(参考上图)。这种方式被称为梯度下降法。
但是我们不能直接计算损失函数对权值和偏置的导数，因为在损失函数的等式中并没有显式的包含他们。因此，我们需要运用链式求导发在来帮助计算导数。
链式法则用于计算损失函数对 W 和 b 的导数。注意，为了简单起见。我们只展示了假设网络只有 1 层的偏导数。
这虽然很简陋，但是我们依然能得到想要的结果—损失函数对权值 W 的导数(斜率)，因此我们可以相应的调整权值。
现在我们将反向传播算法的函数添加到 Python 代码中
为了更深入的理解微积分原理和反向传播中的链式求导法则，我强烈推荐 3Blue1Brown 的如下教程：
Youtube：
整合并完成一个实例
既然我们已经有了包括前向传播和反向传播的完整 Python 代码，那么就将其应用到一个例子上看看它是如何工作的吧。
神经网络可以通过学习得到函数的权重。而我们仅靠观察是不太可能得到函数的权重的。
让我们训练神经网络进行 1500 次迭代，看看会发生什么。 注意观察下面每次迭代的损失函数，我们可以清楚地看到损失函数单调递减到最小值。这与我们之前介绍的梯度下降法一致。
让我们看看经过 1500 次迭代后的神经网络的最终预测结果：
经过 1500 次迭代训练后的预测结果
我们成功了!我们应用前向和方向传播算法成功的训练了神经网络并且预测结果收敛于真实值。
注意预测值和真实值之间存在细微的误差是允许的。这样可以防止模型过拟合并且使得神经网络对于未知数据有着更强的泛化能力。
下一步是什么?
幸运的是我们的学习之旅还没有结束，仍然有很多关于神经网络和深度学习的内容需要学习。例如：
? 除了 Sigmoid 以外，还可以用哪些激活函数
? 在训练网络的时候应用学习率
? 在面对图像分类任务的时候使用卷积神经网络
我很快会写更多关于这个主题的内容，敬请期待!
最后的想法
我自己也从零开始写了很多神经网络的代码
虽然可以使用诸如 Tensorflow 和 Keras 这样的深度学习框架方便的搭建深层网络而不需要完全理解其内部工作原理。但是我觉得对于有追求的数据科学家来说，理解内部原理是非常有益的。
这种练习对我自己来说已成成为重要的时间投入，希望也能对你有所帮助
怎样用python构建一个卷积神经网络
用keras框架较为方便
首先安装anaconda，然后通过pip安装keras
以下转自wphh的博客。
#coding:utf-8
'''
GPU run command:
THEANO_FLAGS=mode=FAST_RUN,device=gpu,floatX=float32 python cnn.py
CPU run command:
python cnn.py
2016.06.06更新：
这份代码是keras开发初期写的，当时keras还没有现在这么流行，文档也还没那么丰富，所以我当时写了一些简单的教程。
现在keras的API也发生了一些的变化，建议及推荐直接上keras.io看更加详细的教程。
'''
#导入各种用到的模块组件
from __future__ import absolute_import
from __future__ import print_function
from keras.preprocessing.image import ImageDataGenerator
from keras.models import Sequential
from keras.layers.core import Dense, Dropout, Activation, Flatten
from keras.layers.advanced_activations import PReLU
from keras.layers.convolutional import Convolution2D, MaxPooling2D
from keras.optimizers import SGD, Adadelta, Adagrad
from keras.utils import np_utils, generic_utils
from six.moves import range
from data import load_data
import random
import numpy as np
np.random.seed(1024) # for reproducibility
#加载数据
data, label = load_data()
#打乱数据
index = [i for i in range(len(data))]
random.shuffle(index)
data = data[index]
label = label[index]
print(data.shape[0], ' samples')
#label为0~9共10个类别，keras要求格式为binary class matrices,转化一下，直接调用keras提供的这个函数
label = np_utils.to_categorical(label, 10)
###############
#开始建立CNN模型
###############
#生成一个model
model = Sequential()
#第一个卷积层，4个卷积核，每个卷积核大小5*5。1表示输入的图片的通道,灰度图为1通道。
#border_mode可以是valid或者full，具体看这里说明：
#激活函数用tanh
#你还可以在model.add(Activation('tanh'))后加上dropout的技巧: model.add(Dropout(0.5))
model.add(Convolution2D(4, 5, 5, border_mode='valid',input_shape=(1,28,28)))
model.add(Activation('tanh'))
#第二个卷积层，8个卷积核，每个卷积核大小3*3。4表示输入的特征图个数，等于上一层的卷积核个数
#激活函数用tanh
#采用maxpooling，poolsize为(2,2)
model.add(Convolution2D(8, 3, 3, border_mode='valid'))
model.add(Activation('tanh'))
model.add(MaxPooling2D(pool_size=(2, 2)))
#第三个卷积层，16个卷积核，每个卷积核大小3*3
#激活函数用tanh
#采用maxpooling，poolsize为(2,2)
model.add(Convolution2D(16, 3, 3, border_mode='valid'))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
#全连接层，先将前一层输出的二维特征图flatten为一维的。
#Dense就是隐藏层。16就是上一层输出的特征图个数。4是根据每个卷积层计算出来的：(28-5+1)得到24,(24-3+1)/2得到11，(11-3+1)/2得到4
#全连接有128个神经元节点,初始化方式为normal
model.add(Flatten())
model.add(Dense(128, init='normal'))
model.add(Activation('tanh'))
#Softmax分类，输出是10类别
model.add(Dense(10, init='normal'))
model.add(Activation('softmax'))
#############
#开始训练模型
##############
#使用SGD + momentum
#model.compile里的参数loss就是损失函数(目标函数)
sgd = SGD(lr=0.05, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy', optimizer=sgd,metrics=["accuracy"])
#调用fit方法，就是一个训练过程. 训练的epoch数设为10，batch_size为100．
#数据经过随机打乱shuffle=True。verbose=1，训练过程中输出的信息，0、1、2三种方式都可以，无关紧要。show_accuracy=True，训练时每一个epoch都输出accuracy。
#validation_split=0.2，将20%的数据作为验证集。
model.fit(data, label, batch_size=100, nb_epoch=10,shuffle=True,verbose=1,validation_split=0.2)
"""
#使用data augmentation的方法
#一些参数和调用的方法，请看文档
datagen = ImageDataGenerator(
featurewise_center=True, # set input mean to 0 over the dataset
samplewise_center=False, # set each sample mean to 0
featurewise_std_normalization=True, # divide inputs by std of the dataset
samplewise_std_normalization=False, # divide each input by its std
zca_whitening=False, # apply ZCA whitening
rotation_range=20, # randomly rotate images in the range (degrees, 0 to 180)
width_shift_range=0.2, # randomly shift images horizontally (fraction of total width)
height_shift_range=0.2, # randomly shift images vertically (fraction of total height)
horizontal_flip=True, # randomly flip images
vertical_flip=False) # randomly flip images
# compute quantities required for featurewise normalization
# (std, mean, and principal components if ZCA whitening is applied)
datagen.fit(data)
for e in range(nb_epoch):
print('-'*40)
print('Epoch', e)
print('-'*40)
print("Training...")
# batch train with realtime data augmentation
progbar = generic_utils.Progbar(data.shape[0])
for X_batch, Y_batch in datagen.flow(data, label):
loss,accuracy = model.train(X_batch, Y_batch,accuracy=True)
progbar.add(X_batch.shape[0], values=[("train loss", loss),("accuracy:", accuracy)] )
"""
如何用 Python 构建神经网络择时模型
import math
import random
random.seed(0)
def rand(a,b): #随机函数
return (b-a)*random.random()+a
def make_matrix(m,n,fill=0.0):#创建一个指定大小的矩阵
mat = []
for i in range(m):
mat.append([fill]*n)
return mat
#定义sigmoid函数和它的导数
def sigmoid(x):
return 1.0/(1.0+math.exp(-x))
def sigmoid_derivate(x):
return x*(1-x) #sigmoid函数的导数
class BPNeuralNetwork:
def __init__(self):#初始化变量
self.input_n = 0
self.hidden_n = 0
self.output_n = 0
self.input_cells = []
self.hidden_cells = []
self.output_cells = []
self.input_weights = []
self.output_weights = []
self.input_correction = []
self.output_correction = []
#三个列表维护：输入层，隐含层，输出层神经元
def setup(self,ni,nh,no):
self.input_n = ni+1 #输入层+偏置项
self.hidden_n = nh #隐含层
self.output_n = no #输出层
#初始化神经元
self.input_cells = [1.0]*self.input_n
self.hidden_cells= [1.0]*self.hidden_n
self.output_cells= [1.0]*self.output_n
#初始化连接边的边权
self.input_weights = make_matrix(self.input_n,self.hidden_n) #邻接矩阵存边权：输入层-隐藏层
self.output_weights = make_matrix(self.hidden_n,self.output_n) #邻接矩阵存边权：隐藏层-输出层
#随机初始化边权：为了反向传导做准备---随机初始化的目的是使对称失效
for i in range(self.input_n):
for h in range(self.hidden_n):
self.input_weights[i][h] = rand(-0.2 , 0.2) #由输入层第i个元素到隐藏层第j个元素的边权为随机值
for h in range(self.hidden_n):
for o in range(self.output_n):
self.output_weights[h][o] = rand(-2.0, 2.0) #由隐藏层第i个元素到输出层第j个元素的边权为随机值
#保存校正矩阵，为了以后误差做调整
self.input_correction = make_matrix(self.input_n , self.hidden_n)
self.output_correction = make_matrix(self.hidden_n,self.output_n)
#输出预测值
def predict(self,inputs):
#对输入层进行操作转化样本
for i in range(self.input_n-1):
self.input_cells[i] = inputs[i] #n个样本从0~n-1
#计算隐藏层的输出，每个节点最终的输出值就是权值*节点值的加权和
for j in range(self.hidden_n):
total = 0.0
for i in range(self.input_n):
total+=self.input_cells[i]*self.input_weights[i][j]
# 此处为何是先i再j，以隐含层节点做大循环，输入样本为小循环，是为了每一个隐藏节点计算一个输出值，传输到下一层
self.hidden_cells[j] = sigmoid(total) #此节点的输出是前一层所有输入点和到该点之间的权值加权和
for k in range(self.output_n):
total = 0.0
for j in range(self.hidden_n):
total+=self.hidden_cells[j]*self.output_weights[j][k]
self.output_cells[k] = sigmoid(total) #获取输出层每个元素的值
return self.output_cells[:] #最后输出层的结果返回
#反向传播算法：调用预测函数，根据反向传播获取权重后前向预测，将结果与实际结果返回比较误差
def back_propagate(self,case,label,learn,correct):
#对输入样本做预测
self.predict(case) #对实例进行预测
output_deltas = [0.0]*self.output_n #初始化矩阵
for o in range(self.output_n):
error = label[o] - self.output_cells[o] #正确结果和预测结果的误差：0,1，-1
output_deltas[o]= sigmoid_derivate(self.output_cells[o])*error#误差稳定在0~1内
#隐含层误差
hidden_deltas = [0.0]*self.hidden_n
for h in range(self.hidden_n):
error = 0.0
for o in range(self.output_n):
error+=output_deltas[o]*self.output_weights[h][o]
hidden_deltas[h] = sigmoid_derivate(self.hidden_cells[h])*error
#反向传播算法求W
#更新隐藏层-输出权重
for h in range(self.hidden_n):
for o in range(self.output_n):
change = output_deltas[o]*self.hidden_cells[h]
#调整权重：上一层每个节点的权重学习*变化+矫正率
self.output_weights[h][o] += learn*change + correct*self.output_correction[h][o]
#更新输入-隐藏层的权重
for i in range(self.input_n):
for h in range(self.hidden_n):
change = hidden_deltas[h]*self.input_cells[i]
self.input_weights[i][h] += learn*change + correct*self.input_correction[i][h]
self.input_correction[i][h] = change
#获取全局误差
error = 0.0
for o in range(len(label)):
error = 0.5*(label[o]-self.output_cells[o])**2 #平方误差函数
return error
def train(self,cases,labels,limit=10000,learn=0.05,correct=0.1):
for i in range(limit): #设置迭代次数
error = 0.0
for j in range(len(cases)):#对输入层进行访问
label = labels[j]
case = cases[j]
error+=self.back_propagate(case,label,learn,correct) #样例，标签，学习率，正确阈值
def test(self): #学习异或
cases = [
[0, 0],
[0, 1],
[1, 0],
[1, 1],
] #测试样例
labels = [[0], [1], [1], [0]] #标签
self.setup(2,5,1) #初始化神经网络：输入层，隐藏层，输出层元素个数
self.train(cases,labels,10000,0.05,0.1) #可以更改
for case in cases:
print(self.predict(case))
if __name__ == '__main__':
nn = BPNeuralNetwork()
nn.test()
