目录
一、神经网络介绍:
神经网络算法参考人的神经元原理(轴突、树突、神经核)，在很多神经元基础上构建神经网络模型，每个神经元可看作一个个学习单元。这些神经元采纳一定的特征作为输入，根据自身的模型得到输出。
图1 神经网络构造的例子（符号说明：上标[l]表示与第l层；上标（i）表示第i个例子；下标i表示矢量第i项)
图2 单层神经网络示例
神经元模型是先计算一个线性函数（z=wx+b），接着再计算一个激活函数。一般来说，神经元模型的输出值是a=g(wx+b)，其中g是激活函数（sigmoid,tanh, relu, …）。
二、数据集
假设有一个很大的数据库，里面记录了很多天气数据，例如，气温、湿度、气压和降雨率。
问题陈述：
一组训练数据m_train，下雨标记为（1），不下雨标记为（0）。
一个测试数据组m_test，标记是否下雨。
每一个天气数据包含x1=气温，x2=湿度，x3=气压。
机器学习中一个常见的预处理步骤是将数据集居中并标准化，这意味着从每个示例中减去整个numpy数组的平均值，然后将每个示例除以整个numpy数组的标准偏差。
通用方法（建立部分算法）
使用深度学习来建造模型
1. 定义模型构造（例如，数据的输入特征）
2. 初始化参数并定义超参数(迭代次数、在神经网络中的l层的层数、隐藏层大小、学习率α）
3. 迭代循环（正向传播（计算电流损耗）、计算成本函数、反向传播（计算电流损耗）、升级参数（使用背景参数和梯度））
4. 使用训练参数来预测标签（初始化）
更深层次的l-层神经网络的初始化更为复杂，因为有更多的权重矩阵和偏置向量。下表展示了不同结构的各种层级。
表1 l层的权重矩阵w、偏置向量b和激活函数z
表2 示例架构中的神经网络权重矩阵w、偏置向量b和激活函数z
表2帮助我们为图1中的示例神经网络架构的矩阵准备了正确的维度。
import numpy as np
import matplotlib.pyplot as plt
nn_architecture = [
{"layer_size": 4,"activation": "none"}, # input layer
{"layer_size": 5,"activation": "relu"},
{"layer_size": 4,"activation": "relu"},
{"layer_size": 3,"activation": "relu"},
{"layer_size": 1,"activation": "sigmoid"}
]
def initialize_parameters(nn_architecture, seed = 3):
np.random.seed(seed)
# python dictionary containingour parameters "w1", "b1", ..., "wl","bl"
parameters = {}
number_of_layers = len(nn_architecture)
for l in range(1,number_of_layers):
parameters['w' + str(l)] =np.random.randn(
nn_architecture[l]["layer_size"],
nn_architecture[l-1]["layer_size"]
) * 0.01
parameters['b' + str(l)] =np.zeros((nn_architecture[l]["layer_size"], 1))
return parameters
代码段1 参数初始化
使用小随机数初始化参数是一种简单的方法，但同时也保证算法的起始值足够好。
记住：
- 不同的初始化工具，例如zero,random, he or xavier，都会导致不同的结果。
- 随机初始化能够确保不同的隐藏单元可以学习不同的东西（初始化所有权重为零会导致，所有层次的所有感知机都将学习相同的东西）。
- 不要初始化为太大的值
三、激活函数
激活函数的作用是为了增加神经网络的非线性。下例将使用sigmoid and relu。
sigmoid输出一个介于0和1之间的值，这使得它成为二进制分类的一个很好的选择。如果输出小于0.5，可以将其分类为0；如果输出大于0.5，可以将其分类为1。
def sigmoid(z):
s = 1 / (1 + np.exp(-z))
return s
def relu(z):
r = np.maximum(0, z)
return r
def sigmoid_backward(da, z):
s = sigmoid(z)
ds = s * (1 - s)
return da * ds
def relu_backward(da, z):
dz = np.array(da, copy=true)
dz[z <= 0] = 0
return dz
代码段2 sigmoid和relu激活函数，及其衍生物
在代码段2中，可以看到激活函数及其派生的矢量化编程实现。该代码将用于进一步的计算。
四、正向传播
在正向传播中，在层l的正向函数中，需要知道该层中的激活函数是哪一种（sigmoid、tanh、relu等）。前一层的输出值为这一层的输入值，先计算z，再用选定的激活函数计算。
图3 神经网络的正向传播
线性正向模块（对所有示例进行矢量化）计算以下方程式：
方程式1 线性正向函数
def l_model_forward(x, parameters, nn_architecture):
forward_cache = {}
a = x
number_of_layers = len(nn_architecture)
for l in range(1, number_of_layers):
a_prev = a
w = parameters['w' + str(l)]
b = parameters['b' + str(l)]
activation = nn_architecture[l]["activation"]
z, a = linear_activation_forward(a_prev, w, b, activation)
forward_cache['z' + str(l)] = z
forward_cache['a' + str(l)] = a
al = a
return al, forward_cache
def linear_activation_forward(a_prev, w, b, activation):
if activation == "sigmoid":
z = linear_forward(a_prev, w, b)
a = sigmoid(z)
elif activation == "relu":
z = linear_forward(a_prev, w, b)
a = relu(z)
return z, a
def linear_forward(a, w, b):
z = np.dot(w, a) + b
return z
代码段3 正向传播模型
使用“cache”（python字典包含为特定层所计算的a和z值）以在正向传播至相应的反向传播期间传递变量。它包含用于反向传播计算导数的有用值。
五、损失函数
为了管程学习过程，需要计算代价函数的值。下面的公式用于计算成本。
方程式2 交叉熵成本
def compute_cost(al, y):
m = y.shape[1]
# compute loss from al and y
logprobs = np.multiply(np.log(al), y) + np.multiply(1 - y, np.log(1 - al))
# cross-entropy cost
cost = - np.sum(logprobs) / m
cost = np.squeeze(cost)
return cost
代码段4 代价函数的计算
六、反向传播
反向传播用于计算参数的损失函数梯度。该算法是由微分学中已知的“链规则”递归使用的。
反向传播计算中使用的公式：
方程式3 反向传播计算公式
链式法则是计算复合函数导数的公式。复合函数就是函数套函数。
方程式4 链规则示例
“链规则”在计算损失时十分重要（以方程式5为例）。
方程式5 损失函数（含替换数据）及其相对于第一权重的导数
神经网络模型反向传播的第一步是计算最后一层损失函数相对于z的导数。方程式6由两部分组成：方程式2损失函数的导数（关于激活函数）和激活函数“sigmoid”关于最后一层z的导数。
方程式6 从4层对z的损失函数导数
方程式6的结果可用于计算方程式3的导数。
方程式7 损失函数相对于3层的导数
在进一步计算中，使用了与第三层激活函数有关的损失函数的导数（方程式7）。
方程式8 第三层的导数
方程式7的结果和第三层活化函数“relu”的导数用于计算方程式8的导数（损失函数相对于z的导数）。然后，我们对方程式3进行了计算。
我们对方程9和10做了类似的计算。
方程式9 第二层的导数
方程式10 第一层的导数
七、总体思路
从第一层层对z的损失函数导数有助于计算（l-1）层（上一层）对损失函数的导数。结果将用于计算激活函数的导数。
图4 神经网络的反向传播
def l_model_backward(al, y, parameters, forward_cache, nn_architecture):
grads = {}
number_of_layers =len(nn_architecture)
m = al.shape[1]
y = y.reshape(al.shape) # afterthis line, y is the same shape as al
# initializing thebackpropagation
dal = - (np.divide(y, al) -np.divide(1 - y, 1 - al))
da_prev = dal
for l in reversed(range(1,number_of_layers)):
da_curr = da_prev
activation =nn_architecture[l]["activation"]
w_curr = parameters['w' +str(l)]
z_curr = forward_cache['z' +str(l)]
a_prev = forward_cache['a' +str(l-1)]
da_prev, dw_curr, db_curr =linear_activation_backward(da_curr, z_curr, a_prev, w_curr, activation)
grads["dw" +str(l)] = dw_curr
grads["db" +str(l)] = db_curr
return grads
def linear_activation_backward(da, z, a_prev, w, activation):
if activation =="relu":
dz = relu_backward(da, z)
da_prev, dw, db =linear_backward(dz, a_prev, w)
elif activation =="sigmoid":
dz = sigmoid_backward(da, z)
da_prev, dw, db =linear_backward(dz, a_prev, w)
return da_prev, dw, db
def linear_backward(dz, a_prev, w):
m = a_prev.shape[1]
dw = np.dot(dz, a_prev.t) / m
db = np.sum(dz, axis=1,keepdims=true) / m
da_prev = np.dot(w.t, dz)
return da_prev, dw, db
代码段5 反向传播模块
更新参数
该函数的目标是通过梯度优化来更新模型的参数。
def update_parameters(parameters, grads, learning_rate):
l = len(parameters)
for l in range(1, l):
parameters["w" +str(l)] = parameters["w" + str(l)] - learning_rate *grads["dw" + str(l)]
parameters["b" +str(l)] = parameters["b" + str(l)] - learning_rate *grads["db" + str(l)]
return parameters
全模型
神经网络模型的完整实现包括在片段中提供的方法。
def l_layer_model(x, y, nn_architecture, learning_rate = 0.0075,num_iterations = 3000, print_cost=false):
np.random.seed(1)
# keep track of cost
costs = []
# parameters initialization.
parameters =initialize_parameters(nn_architecture)
# loop (gradient descent)
for i in range(0,num_iterations):
# forward propagation:[linear -> relu]*(l-1) -> linear -> sigmoid.
al, forward_cache =l_model_forward(x, parameters, nn_architecture)
# compute cost.
cost = compute_cost(al, y)
# backward propagation.
grads = l_model_backward(al,y, parameters, forward_cache, nn_architecture)
# update parameters.
parameters =update_parameters(parameters, grads, learning_rate)
# print the cost every 100training example
if print_cost and i % 100 ==0:
print("cost afteriteration %i: %f" %(i, cost))
costs.append(cost)
# plot the cost
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (pertens)')
plt.title("learning rate=" + str(learning_rate))
plt.show()
return parameters
代码段7 整个神经网络模型
只需要将已知的权重和系列测试数据，应用于正向传播模型，就能预测结果。
可以修改snippet1中的nn_架构，以构建具有不同层数和隐藏层大小的神经网络。此外，准备正确实现激活函数及其派生函数（代码段2）。所实现的函数可用于修改代码段3中的线性正向激活方法和代码段5中的线性反向激活方法。
进一步改进
如果训练数据集不够大，则可能面临“过度拟合”问题。这意味着所学的网络不会概括为它从未见过的新例子。可以使用正则化方法，如l2规范化（它包括适当地修改成本函数）或退出（它在每次迭代中随机关闭一些感知机）。
我们使用梯度下降来更新参数和最小化成本。你可以学习更多高级优化方法，这些方法可以加快学习速度，甚至可以为成本函数提供更好的最终价值，例如：
- 小批量梯度下降
- 动力
- adam优化器
参考：http://www.uml.org.cn/ai/201911251.asp
到此这篇关于python建立任意层数的深度神经网络的文章就介绍到这了,更多相关python神经网络内容请搜索www.887551.com以前的文章或继续浏览下面的相关文章希望大家以后多多支持www.887551.com！
