深层神经网络学习检测记录
构建深层神经网络的基本函数
符号说明
本次构建的神经网络中使用了以下符号，特此说明。
所必须的资料
- pycharm编程软件
- numpy库
- matplotlib库
- dnn_utils文件
- testCases文件
资料中的python文件下载链接在这。（点击下载）
相关文件的导入
我们自己新建了一deep_network.py文件，在该文件下进行编程。
导入一些库和相关的资料文件，设置绘图的参数。
import numpy as np
import h5py
import matplotlib.pyplot as plt
from testCases_v2 import *
from dnn_utils_v2 import sigmoid, sigmoid_backward, relu, relu_backward
# 设置默认的绘图尺寸以及其他绘图参数
plt.rcParams['figure.figsize'] = (5.0, 4.0)
plt.rcParams['image.interpolation'] = 'nearest'
plt.rcParams['image.cmap'] = 'gray'
# 指定随机种子，和数据匹配
np.random.seed(1)
初始化参数
对于一个两层的神经网络结构而言，模型结构是线性->ReLU->线性->sigmod函数
def initialize_parameters(n_x,n_h,n_y):
"""
此函数是为了初始化两层网络参数而使用的函数。
参数：
n_x - 输入层节点数量
n_h - 隐藏层节点数量
n_y - 输出层节点数量
返回：
parameters - 包含你的参数的python字典：
W1 - 权重矩阵,维度为（n_h，n_x）
b1 - 偏向量，维度为（n_h，1）
W2 - 权重矩阵，维度为（n_y，n_h）
b2 - 偏向量，维度为（n_y，1）
"""
# 确保准确的维度
W1 = np.random.randn(n_h, n_x) * 0.01
# 偏差b初始化为0.
b1 = np.zeros((n_h, 1))
W2 = np.random.randn(n_y, n_h) * 0.01
b2 = np.zeros((n_y, 1))
#使用assert强制确保我的数据格式是正确的
assert(W1.shape == (n_h, n_x))
assert(b1.shape == (n_h, 1))
assert(W2.shape == (n_y, n_h))
assert(b2.shape == (n_y, 1))
parameters = {"W1": W1,
"b1": b1,
"W2": W2,
"b2": b2}
return parameters
测试initialize_parameters函数
对于一个两层的神经网络，测试一下该函数的效果，追加下列代码，然后运行。
# 测试initialize_parameters函数
print("==============测试initialize_parameters==============")
parameters = initialize_parameters(3,2,1)
print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))
运行结果如下
L层神经网络的初始化
当我们构建更深层，即L层，L大于2或者3时。初始化更加复杂，因为涉及了更多的权重矩阵和偏差。假设输入的数据维度X（12288，209）,209是训练数据的个数。各层的维度如下，n^ [l]是第l层中神经元（神经单元）的数量，shape of activation是Z^ [l]的维度。
线性代数中矩阵的计算乘法规则如下：
定义L层神经网络初始化函数
def initialize_parameters_deep(layers_dims):
"""
此函数是为了初始化多层网络参数而使用的函数。
参数：
layers_dims - 包含我们网络中每层神经网络的节点数量的列表
返回：
parameters - 包含参数“W1”，“b1”，...，“WL”，“bL”的字典：
W1 - 权重矩阵，维度为（layers_dims [1]，layers_dims [1-1]）
bl - 偏向量，维度为（layers_dims [1]，1）
"""
np.random.seed(3)
parameters = {}
L = len(layers_dims)
for l in range(1,L):
parameters["W" + str(l)] = np.random.randn(layers_dims[l], layers_dims[l - 1]) *0.01
parameters["b" + str(l)] = np.zeros((layers_dims[l], 1))
#确保我要的数据的格式是正确的
assert(parameters["W" + str(l)].shape == (layers_dims[l], layers_dims[l-1]))
assert(parameters["b" + str(l)].shape == (layers_dims[l], 1))
return parameters
测试L层网络初始化函数
追加下列代码，这里我们测试的神经网络有2层，输入层节点是5，即有5个输入， 第一层节点4，即隐藏层包含4个隐藏单元，第三层是3，即输出层包含3个输出单元。
# 测试initialize_parameters_deep，这里我们测试的神经网络有2层，输入层节点是5，即有5个输入
# 第一层节点4，即隐藏层包含4个隐藏单元，第三层是3，即输出层包含3个输出单元。
print("==============测试initialize_parameters_deep==============")
layers_dims = [5,4,3]
parameters = initialize_parameters_deep(layers_dims)
print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))
输出结果如下
构建前向传播函数
首先实现一些基本函数，分别是线性传播函数，激活函数
线性正向传播函数计算公式如下:
关键python代码，是numpy库中的np.dot（x,y），x是m×n 矩阵 ，y是n×m矩阵，则np.dot(x，y) 得到m*m矩阵。
#前向传播的线性函数，即求z的函数
def linear_forward(A, W, b):
"""
实现前向传播的线性部分。
参数：
A - 来自上一层（或输入数据）的激活，维度为(上一层的节点数量，示例的数量）
W - 权重矩阵，numpy数组，维度为（当前图层的节点数量，前一图层的节点数量）
b - 偏向量，numpy向量，维度为（当前图层节点数量，1）
返回：
Z - 激活功能的输入，也称为预激活参数
cache - 一个包含“A”，“W”和“b”的字典，存储这些变量以有效地计算后向传递
"""
Z = np.dot(W, A) + b
assert (Z.shape == (W.shape[0], A.shape[1]))
cache = (A, W, b)
return Z, cache
测试线性函数
#测试linear_forward
print("==============测试linear_forward==============")
# 调用testCases_v2中的函数
A,W,b =linear_forward_test_case()
Z,linear_cache = linear_forward(A,W,b)
print("Z = " + str(Z))
最后输出如下：
构建激活函数，有两个，一个是sigmoid函数，一个是ReLU函数。公式如下：
该两个激活函数返回两个值，激活值"a"和包含"Z"的"cache"（这是我们将馈入到相应的反向函数的内容）。
# 构建前向激活函数
def linear_activation_forward(A_prev, W, b, activation):
"""
实现LINEAR-> ACTIVATION 这一层的前向传播
参数：
A_prev - 来自上一层（或输入层）的激活，维度为(上一层的节点数量，示例数）
W - 权重矩阵，numpy数组，维度为（当前层的节点数量，前一层的大小）
b - 偏向量，numpy阵列，维度为（当前层的节点数量，1）
activation - 选择在此层中使用的激活函数名，字符串类型，【"sigmoid" | "relu"】
返回：
A - 激活函数的输出，也称为激活后的值
cache - 一个包含“linear_cache”和“activation_cache”的字典，我们需要存储它以有效地计算后向传递
"""
if activation == "sigmoid":
Z, linear_cache = linear_forward(A_prev, W, b)
A, activation_cache = sigmoid(Z)
elif activation == "relu":
Z, linear_cache = linear_forward(A_prev, W, b)
A, activation_cache = relu(Z)
assert (A.shape == (W.shape[0], A_prev.shape[1]))
cache = (linear_cache, activation_cache)
return A, cache
测试激活函数
#测试linear_activation_forward
print("==============测试linear_activation_forward==============")
A_prev, W,b = linear_activation_forward_test_case()
A, linear_activation_cache = linear_activation_forward(A_prev, W, b, activation = "sigmoid")
print("sigmoid，A = " + str(A))
A, linear_activation_cache = linear_activation_forward(A_prev, W, b, activation = "relu")
print("ReLU，A = " + str(A))
测试激活函数的输出结果如下：
L层模型的激活函数
- 使用你先前编写的函数
- 使用for循环复制[LINEAR-> RELU]（L-1）次
- 不要忘记在“cache”列表中更新缓存。 要将新值 c添加到list中，可以使用
list.append(c)。
def L_model_forward(X,parameters):
"""
实现[LINEAR-> RELU] *（L-1） - > LINEAR-> SIGMOID计算前向传播，也就是多层网络的前向传播，为后面每一层都执行LINEAR和ACTIVATION
参数：
X - 数据，numpy数组，维度为（输入节点数量，样本数）
parameters - initialize_parameters_deep（）的输出
返回：
AL - 最后的激活值
caches - 包含以下内容的缓存列表：
linear_relu_forward（）的每个cache（有L-1个，索引为从0到L-2）
linear_sigmoid_forward（）的cache（只有一个，索引为L-1）
"""
caches = []
A = X
L = len(parameters) // 2
for l in range(1,L):
A_prev = A
A, cache = linear_activation_forward(A_prev, parameters['W' + str(l)], parameters['b' + str(l)], "relu")
caches.append(cache)
AL, cache = linear_activation_forward(A, parameters['W' + str(L)], parameters['b' + str(L)], "sigmoid")
caches.append(cache)
assert(AL.shape == (1,X.shape[1]))
return AL,caches
测试L层模型的前向传播函数
#测试L_model_forward
print("==============测试L_model_forward==============")
X,parameters = L_model_forward_test_case()
AL,caches = L_model_forward(X,parameters)
print("AL = " + str(AL))
print("caches 的长度为 = " + str(len(caches)))
测试结果输出如下：
至此为止，你有了一个完整的正向传播模块，它接受输入X并输出包含预测的行向量A^ [L]。 它还将所有中间值记录在"caches"中以便后续计算预测的损失值。
损失函数
下图公式是成本函数J，是损失函数按照一定规则累加得到的，用来计算误差。
def compute_cost(AL,Y):
"""
实施等式（4）定义的成本函数。
参数：
AL - 与标签预测相对应的概率向量，维度为（1，示例数量）
Y - 标签向量（例如：如果不是猫，则为0，如果是猫则为1），维度为（1，数量）
返回：
cost - 交叉熵成本
"""
m = Y.shape[1]
cost = -np.sum(np.multiply(np.log(AL),Y) + np.multiply(np.log(1 - AL), 1 - Y)) / m
cost = np.squeeze(cost)
assert(cost.shape == ())
return cost
测试成本函数J的运行
#测试compute_cost
print("==============测试compute_cost==============")
Y,AL =compute_cost_test_case()
print("cost = " + str(compute_cost(AL, Y)))
输出如下
构建反向传播函数
反向传播用来计算损失函数L的梯度，即求导，下图是前向传播和反向传播的流程图，第一行是正向，第二行是反向。
构建线性反向传播函数，用到以下公式：
下边是定义函数的代码和测试该函数的代码
#构建反向传播函数的线性部分
def linear_backward(dZ, cache):
"""
为单层实现反向传播的线性部分（第L层）
参数：
dZ - 相对于（当前第l层的）线性输出的成本梯度
cache - 来自当前层前向传播的值的元组（A_prev，W，b）
返回：
dA_prev - 相对于激活（前一层l-1）的成本梯度，与A_prev维度相同
dW - 相对于W（当前层l）的成本梯度，与W的维度相同
db - 相对于b（当前层l）的成本梯度，与b维度相同
"""
A_prev, W, b = cache
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)
assert (dA_prev.shape == A_prev.shape)
assert (dW.shape == W.shape)
assert (db.shape == b.shape)
return dA_prev, dW, db
#测试linear_backward
print("==============测试linear_backward==============")
dZ, linear_cache = linear_backward_test_case()
dA_prev, dW, db = linear_backward(dZ, linear_cache)
print ("dA_prev = "+ str(dA_prev))
print ("dW = " + str(dW))
print ("db = " + str(db))
测试结果输出如下：
构建反向的激活函数
其中sigmoid_backward实现sigmoid函数的反向传播，调用格式如下
dZ = sigmoid_backward(dA, activation_cache)
其中relu_backward实现了relu函数的反向传播，调用格式 如下
dZ = relu_backward(dA, activation_cache)
下边是定义反向激活函数
def linear_activation_backward(dA,cache,activation="relu"):
"""
实现LINEAR-> ACTIVATION层的后向传播。
参数：
dA - 当前层l的激活后的梯度值
cache - 我们存储的用于有效计算反向传播的值的元组（值为linear_cache，activation_cache）
activation - 要在此层中使用的激活函数名，字符串类型，【"sigmoid" | "relu"】
返回：
dA_prev - 相对于激活（前一层l-1）的成本梯度值，与A_prev维度相同
dW - 相对于W（当前层l）的成本梯度值，与W的维度相同
db - 相对于b（当前层l）的成本梯度值，与b的维度相同
"""
linear_cache, activation_cache = cache
if activation == "relu":
dZ = relu_backward(dA, activation_cache)
dA_prev, dW, db = linear_backward(dZ, linear_cache)
elif activation == "sigmoid":
dZ = sigmoid_backward(dA, activation_cache)
dA_prev, dW, db = linear_backward(dZ, linear_cache)
return dA_prev,dW,db
测试该函数
# 测试linear_activation_backward
print("==============测试linear_activation_backward==============")
AL, linear_activation_cache =linear_activation_backward_test_case()
dA_prev, dW, db = linear_activation_backward(AL, linear_activation_cache, activation="sigmoid")
print("sigmoid:")
print("dA_prev = " + str(dA_prev))
print("dW = " + str(dW))
print("db = " + str(db) + "\n")
dA_prev, dW, db = linear_activation_backward(AL, linear_activation_cache, activation="relu")
print("relu:")
print("dA_prev = " + str(dA_prev))
print("dW = " + str(dW))
print("db = " + str(db))
输出如下：
对于L层的神经网络，其中使用dAL = - (np.divide(Y, AL) - np.divide(1 - Y, 1 - AL))是用来计算dAL（A ^ [L]是输出层），计算完了以后，我们可以使用此激活后的梯度dAL继续向后计算，我们这就开始构建多层模型向后传播函数：
def L_model_backward(AL,Y,caches):
"""
对[LINEAR-> RELU] *（L-1） - > LINEAR - > SIGMOID组执行反向传播，就是多层网络的向后传播
参数：
AL - 概率向量，正向传播的输出（L_model_forward（））
Y - 标签向量（例如：如果不是猫，则为0，如果是猫则为1），维度为（1，数量）
caches - 包含以下内容的cache列表：
linear_activation_forward（"relu"）的cache，不包含输出层
linear_activation_forward（"sigmoid"）的cache
返回：
grads - 具有梯度值的字典
grads [“dA”+ str（l）] = ...
grads [“dW”+ str（l）] = ...
grads [“db”+ str（l）] = ...
"""
grads = {}
L = len(caches)
m = AL.shape[1]
Y = Y.reshape(AL.shape)
dAL = - (np.divide(Y, AL) - np.divide(1 - Y, 1 - AL))
current_cache = caches[L-1]
grads["dA" + str(L)], grads["dW" + str(L)], grads["db" + str(L)] = linear_activation_backward(dAL, current_cache, "sigmoid")
for l in reversed(range(L-1)):
current_cache = caches[l]
dA_prev_temp, dW_temp, db_temp = linear_activation_backward(grads["dA" + str(l + 2)], current_cache, "relu")
grads["dA" + str(l + 1)] = dA_prev_temp
grads["dW" + str(l + 1)] = dW_temp
grads["db" + str(l + 1)] = db_temp
return grads
测试函数如下：
#测试L_model_backward
print("==============测试L_model_backward==============")
AL, Y_assess, caches = L_model_backward_test_case()
grads = L_model_backward(AL, Y_assess, caches)
print ("dW1 = "+ str(grads["dW1"]))
print ("db1 = "+ str(grads["db1"]))
print ("dA1 = "+ str(grads["dA1"]))
输出如下
更新参数w和b
我们把向前向后传播都完成了，现在我们就开始更新参数，当然，我们来看看更新参数的公式，其中α是学习率。（常设为0.01）
更新参数的函数和测试该函数的代码如下：
#更新参数w和b
def update_parameters(parameters, grads, learning_rate):
"""
使用梯度下降更新参数
参数：
parameters - 包含你的参数的字典
grads - 包含梯度值的字典，是L_model_backward的输出
返回：
parameters - 包含更新参数的字典
参数[“W”+ str（l）] = ...
参数[“b”+ str（l）] = ...
"""
L = len(parameters) // 2 # 整除
for l in range(L):
parameters["W" + str(l + 1)] = parameters["W" + str(l + 1)] - learning_rate * grads["dW" + str(l + 1)]
parameters["b" + str(l + 1)] = parameters["b" + str(l + 1)] - learning_rate * grads["db" + str(l + 1)]
return parameters
# 测试update_parameters
print("==============测试update_parameters==============")
parameters, grads = update_parameters_test_case()
parameters = update_parameters(parameters, grads, 0.1)
print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))
输出如下：
至此，已经完成实现该神经网络中所需要的函数。
深度神经网络应用，图像分类
使用上文实现的函数来搭建深度神经网络，应用于分类cat图像。理论上来说是比使用logistic回归的准确性有提高。
导入相关文件和库
所使用的资料在前文已经下载，
- numpy是Python科学计算的基本包。
- matplotlib 是在Python中常用的绘制图形的库。
- h5py是一个常用的包，可以处理存储为H5文件格式的数据集
- 这里最后通过PIL和 scipy用你自己的图片去测试模型效果。
- dnn_app_utils_v2提供了上一作业教程“逐步构建你的深度神经网络”中实现的函数。
我们新建一文件命名为cat_watch.py.输入以下代码导入库。
import time
import numpy as np
import h5py
import matplotlib.pyplot as plt
import scipy
from PIL import Image
from scipy import ndimage
from dnn_app_utils_v2 import *
# set default size of plots
plt.rcParams['figure.figsize'] = (5.0, 4.0)
plt.rcParams['image.interpolation'] = 'nearest'
plt.rcParams['image.cmap'] = 'gray'
加载数据集并展示一个图像
# 加载数据集
train_x_orig, train_y, test_x_orig, test_y, classes = load_data()
# 显示示例图像
# 图像的序号
index = 7
plt.imshow(train_x_orig[index])
plt.show()
print ("y = " + str(train_y[0,index]) + ". It's a " + classes[train_y[0,index]].decode("utf-8"))
运行后，将会输出以下图像。
展示数据集的信息
# Explore your dataset
m_train = train_x_orig.shape[0]
num_px = train_x_orig.shape[1]
m_test = test_x_orig.shape[0]
print ("Number of training examples: " + str(m_train))
print ("Number of testing examples: " + str(m_test))
print ("Each image is of size: (" + str(num_px) + ", " + str(num_px) + ", 3)")
print ("train_x_orig shape: " + str(train_x_orig.shape))
print ("train_y shape: " + str(train_y.shape))
print ("test_x_orig shape: " + str(test_x_orig.shape))
print ("test_y shape: " + str(test_y.shape))
重塑图像的类型
我们在图像输入到网络之前，需要对图像进行重塑和标准化。如下图所示，我们就把图像转换成了numpy数组（列向量矩阵）。
代码如下：
#X_flatten = X.reshape(X.shape [0]，-1).T ＃X.T是X的转置
#将训练集的维度降低并转置。
train_set_x_flatten = train_set_x_orig.reshape(train_set_x_orig.shape[0],-1).T
#将测试集的维度降低并转置。
test_set_x_flatten = test_set_x_orig.reshape(test_set_x_orig.shape[0], -1).T
数据预处理
# 预处理步骤是对数据集进行居中和标准化，这意味着可以减去每个示例中整个numpy数组的平均值，然后将每个示例除以整个numpy数组的标准偏差
train_x = train_set_x_flatten/255
test_x = test_set_x_flatten/255
# 查看训练集和测试集的维度
print ("train_x's shape: " + str(train_x.shape))
print ("test_x's shape: " + str(test_x.shape))
输出数据的维度如下，其中12288=64643，这是图像重塑为向量的大小
定义一个两层神经网络模型
def two_layer_model(X,Y,layers_dims,learning_rate=0.0075,num_iterations=3000,print_cost=False,isPlot=True):
"""
实现一个两层的神经网络，【LINEAR->RELU】 -> 【LINEAR->SIGMOID】
参数：
X - 输入的数据，维度为(n_x，例子数)
Y - 标签，向量，0为非猫，1为猫，维度为(1,数量)
layers_dims - 层数的向量，维度为(n_y,n_h,n_y)
learning_rate - 学习率
num_iterations - 迭代的次数
print_cost - 是否打印成本值，每100次打印一次
isPlot - 是否绘制出误差值的图谱
返回:
parameters - 一个包含W1，b1，W2，b2的字典变量
"""
np.random.seed(1)
grads = {}
costs = []
(n_x,n_h,n_y) = layers_dims
"""
初始化参数
"""
parameters = initialize_parameters(n_x, n_h, n_y)
W1 = parameters["W1"]
b1 = parameters["b1"]
W2 = parameters["W2"]
b2 = parameters["b2"]
"""
开始进行迭代
"""
for i in range(0,num_iterations):
#前向传播
A1, cache1 = linear_activation_forward(X, W1, b1, "relu")
A2, cache2 = linear_activation_forward(A1, W2, b2, "sigmoid")
#计算成本
cost = compute_cost(A2,Y)
#后向传播
##初始化后向传播
dA2 = - (np.divide(Y, A2) - np.divide(1 - Y, 1 - A2))
##向后传播，输入：“dA2，cache2，cache1”。 输出：“dA1，dW2，db2;还有dA0（未使用），dW1，db1”。
dA1, dW2, db2 = linear_activation_backward(dA2, cache2, "sigmoid")
dA0, dW1, db1 = linear_activation_backward(dA1, cache1, "relu")
##向后传播完成后的数据保存到grads
grads["dW1"] = dW1
grads["db1"] = db1
grads["dW2"] = dW2
grads["db2"] = db2
#更新参数
parameters = update_parameters(parameters,grads,learning_rate)
W1 = parameters["W1"]
b1 = parameters["b1"]
W2 = parameters["W2"]
b2 = parameters["b2"]
#打印成本值，如果print_cost=False则忽略
if i % 100 == 0:
#记录成本
costs.append(cost)
#是否打印成本值
if print_cost:
print("第", i ,"次迭代，成本值为：" ,np.squeeze(cost))
#迭代完成，根据条件绘制图
if isPlot:
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (per tens)')
plt.title("Learning rate =" + str(learning_rate))
plt.show()
#返回parameters
return parameters
输入参数开始训练
n_x = 12288
n_h = 7
n_y = 1
layers_dims = (n_x,n_h,n_y)
parameters = two_layer_model(train_x, train_y, layers_dims = (n_x, n_h, n_y), num_iterations = 2500, print_cost=True,isPlot=True)
定义一个预测函数
# 预测函数
def predict(X, y, parameters):
"""
该函数用于预测L层神经网络的结果，当然也包含两层
参数：
X - 测试集
y - 标签
parameters - 训练模型的参数
返回：
p - 给定数据集X的预测
"""
m = X.shape[1]
n = len(parameters) // 2 # 神经网络的层数
p = np.zeros((1, m))
# 根据参数前向传播
probas, caches = L_model_forward(X, parameters)
for i in range(0, probas.shape[1]):
if probas[0, i] > 0.5:
p[0, i] = 1
else:
p[0, i] = 0
# 准确度为输出的预测值和实际值相同的个数，占总体样本的百分比。
print("准确度为: " + str(float(np.sum((p == y)) / m)))
return p
查看对于训练集和测试集的准确性
predictions_train = predict(train_x, train_y, parameters) #训练集
predictions_test = predict(test_x, test_y, parameters) #测试集
输出如下：
定义L层神经网络的模型
def L_layer_model(X, Y, layers_dims, learning_rate=0.0075, num_iterations=3000, print_cost=False,isPlot=True):
"""
实现一个L层神经网络：[LINEAR-> RELU] *（L-1） - > LINEAR-> SIGMOID。
参数：
X - 输入的数据，维度为(n_x，例子数)
Y - 标签，向量，0为非猫，1为猫，维度为(1,数量)
layers_dims - 层数的向量，维度为(n_y,n_h,···,n_h,n_y)
learning_rate - 学习率
num_iterations - 迭代的次数
print_cost - 是否打印成本值，每100次打印一次
isPlot - 是否绘制出误差值的图谱
返回：
parameters - 模型学习的参数。 然后他们可以用来预测。
"""
np.random.seed(1)
costs = []
parameters = initialize_parameters_deep(layers_dims)
for i in range(0,num_iterations):
AL , caches = L_model_forward(X,parameters)
cost = compute_cost(AL,Y)
grads = L_model_backward(AL,Y,caches)
parameters = update_parameters(parameters,grads,learning_rate)
#打印成本值，如果print_cost=False则忽略
if i % 100 == 0:
#记录成本
costs.append(cost)
#是否打印成本值
if print_cost:
print("第", i ,"次迭代，成本值为：" ,np.squeeze(cost))
#迭代完成，根据条件绘制图
if isPlot:
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (per tens)')
plt.title("Learning rate =" + str(learning_rate))
plt.show()
return parameters
输入L层神经网络的参数
layers_dims = [12288, 20, 7, 5, 1] # 5-layer model
parameters = L_layer_model(train_x, train_y, layers_dims, num_iterations = 2500, print_cost = True,isPlot=True)
开始训练
至此为止，我们把前边定义的两层神经网络模型和两层神经网络模型输入参数开始训练的代码注释掉，然后运行该python文件，最后得到以下输出
对于训练集和测试集的预测准确度
pred_train = predict(train_x, train_y, parameters) #训练集
pred_test = predict(test_x, test_y, parameters) #测试集
输出如下：
结论分析
在相同的测试集上，5层的神经网络似乎比2层神经网络具有更好的性能（5层有80％准确度）。准确率低的原因与以下几点有关
- 猫身处于异常位置
- 图片背景与猫颜色类似
- 猫的种类和颜色稀有
- 相机角度
- 图片的亮度
- 比例变化（猫的图像很大或很小）
输入自己的图像测试
运行以下代码测试自己的图像，注意修改图像的名字，需要把图像添加进整个工程中。
# 自己找图片来识别
from PIL import Image
my_label_y = [1] # the true class of your image (1 -> cat, 0 -> non-cat)
# 图像的像素定义为64*64的
num_px = 64
image = Image.open('my_image.jpg')
my_image = np.array(image.resize((num_px, num_px), Image.ANTIALIAS))
my_image = my_image.reshape(num_px * num_px * 3, -1)
predict_my_image = predict(my_image, my_label_y, parameters)
plt.imshow(image)
print("y = " + str(np.squeeze(predict_my_image)) + ", your L-layer model predicts a \"" + classes[
int(np.squeeze(predict_my_image))].decode("utf-8") + "\"picture.")
输出结果如下：
很明显没有预测准确，推测有以下几个原因：
因为这个训练出来的参数问题， 用一张黑色的图片可以识别出不是 cat， 感觉是训练时样本都归一化除以255了，然后自己的图片 shape后的值都比较大，所以 返回的probas的值也比较大（大于0.5）， 所以预测都给判别成1了。
完整代码
deep_network.py中
import numpy as np
import h5py
import matplotlib.pyplot as plt
from testCases_v2 import *
from dnn_utils_v2 import sigmoid, sigmoid_backward, relu, relu_backward
# 设置默认的绘图尺寸以及其他绘图参数
plt.rcParams['figure.figsize'] = (5.0, 4.0)
plt.rcParams['image.interpolation'] = 'nearest'
plt.rcParams['image.cmap'] = 'gray'
# 指定随机种子，和数据匹配
np.random.seed(1)
# 初始化两层网络参数
def initialize_parameters(n_x, n_h, n_y):
"""
此函数是为了初始化两层网络参数而使用的函数。
参数：
n_x - 输入层节点数量
n_h - 隐藏层节点数量
n_y - 输出层节点数量
返回：
parameters - 包含你的参数的python字典：
W1 - 权重矩阵,维度为（n_h，n_x）
b1 - 偏向量，维度为（n_h，1）
W2 - 权重矩阵，维度为（n_y，n_h）
b2 - 偏向量，维度为（n_y，1）
"""
# 确保准确的维度
W1 = np.random.randn(n_h, n_x) * 0.01
# 偏差b初始化为0.
b1 = np.zeros((n_h, 1))
W2 = np.random.randn(n_y, n_h) * 0.01
b2 = np.zeros((n_y, 1))
# 使用assert强制确保我的数据格式是正确的
assert (W1.shape == (n_h, n_x))
assert (b1.shape == (n_h, 1))
assert (W2.shape == (n_y, n_h))
assert (b2.shape == (n_y, 1))
parameters = {"W1": W1,
"b1": b1,
"W2": W2,
"b2": b2}
return parameters
# 测试initialize_parameters函数
# print("==============测试initialize_parameters==============")
# parameters = initialize_parameters(3,2,1)
# print("W1 = " + str(parameters["W1"]))
# print("b1 = " + str(parameters["b1"]))
# print("W2 = " + str(parameters["W2"]))
# print("b2 = " + str(parameters["b2"]))
# L层神经网络初始化参数
def initialize_parameters_deep(layers_dims):
"""
此函数是为了初始化多层网络参数而使用的函数。
参数：
layers_dims - 包含我们网络中每个神经网络层的节点数量的列表
返回：
parameters - 包含参数“W1”，“b1”，...，“WL”，“bL”的字典：
W1 - 权重矩阵，维度为（layers_dims [1]，layers_dims [1-1]）
bl - 偏向量，维度为（layers_dims [1]，1）
"""
np.random.seed(3)
parameters = {}
L = len(layers_dims)
for l in range(1, L):
parameters["W" + str(l)] = np.random.randn(layers_dims[l], layers_dims[l - 1]) *0.01
parameters["b" + str(l)] = np.zeros((layers_dims[l], 1))
# 确保我要的数据的格式是正确的
assert (parameters["W" + str(l)].shape == (layers_dims[l], layers_dims[l - 1]))
assert (parameters["b" + str(l)].shape == (layers_dims[l], 1))
return parameters
# 测试initialize_parameters_deep，这里我们测试的神经网络有2层，输入层节点是5，即有5个输入
# 第一层节点4，即隐藏层包含4个隐藏单元，第三层是3，即输出层包含3个输出单元。
print("==============测试initialize_parameters_deep==============")
layers_dims = [5,4,3]
parameters = initialize_parameters_deep(layers_dims)
print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))
#前向传播的线性函数，即求z的函数
def linear_forward(A, W, b):
"""
实现前向传播的线性部分。
参数：
A - 来自上一层（或输入数据）的激活，维度为(上一层的节点数量，示例的数量）
W - 权重矩阵，numpy数组，维度为（当前图层的节点数量，前一图层的节点数量）
b - 偏向量，numpy向量，维度为（当前图层节点数量，1）
返回：
Z - 激活功能的输入，也称为预激活参数
cache - 一个包含“A”，“W”和“b”的字典，存储这些变量以有效地计算后向传递
"""
Z = np.dot(W, A) + b
assert (Z.shape == (W.shape[0], A.shape[1]))
cache = (A, W, b)
return Z, cache
#测试linear_forward
print("==============测试linear_forward==============")
# 调用testCases_v2中的函数
A,W,b =linear_forward_test_case()
Z,linear_cache = linear_forward(A,W,b)
print("Z = " + str(Z))
# 构建前向激活函数
def linear_activation_forward(A_prev, W, b, activation):
"""
实现LINEAR-> ACTIVATION 这一层的前向传播
参数：
A_prev - 来自上一层（或输入层）的激活，维度为(上一层的节点数量，示例数）
W - 权重矩阵，numpy数组，维度为（当前层的节点数量，前一层的大小）
b - 偏向量，numpy阵列，维度为（当前层的节点数量，1）
activation - 选择在此层中使用的激活函数名，字符串类型，【"sigmoid" | "relu"】
返回：
A - 激活函数的输出，也称为激活后的值
cache - 一个包含“linear_cache”和“activation_cache”的字典，我们需要存储它以有效地计算后向传递
"""
if activation == "sigmoid":
Z, linear_cache = linear_forward(A_prev, W, b)
A, activation_cache = sigmoid(Z)
elif activation == "relu":
Z, linear_cache = linear_forward(A_prev, W, b)
A, activation_cache = relu(Z)
assert (A.shape == (W.shape[0], A_prev.shape[1]))
cache = (linear_cache, activation_cache)
return A, cache
#测试linear_activation_forward
print("==============测试linear_activation_forward==============")
A_prev, W,b = linear_activation_forward_test_case()
A, linear_activation_cache = linear_activation_forward(A_prev, W, b, activation = "sigmoid")
print("sigmoid，A = " + str(A))
A, linear_activation_cache = linear_activation_forward(A_prev, W, b, activation = "relu")
print("ReLU，A = " + str(A))
#多层模型的前向传播计算模型
def L_model_forward(X, parameters):
"""
实现[LINEAR-> RELU] *（L-1） - > LINEAR-> SIGMOID计算前向传播，也就是多层网络的前向传播，为后面每一层都执行LINEAR和ACTIVATION
参数：
X - 数据，numpy数组，维度为（输入节点数量，样本数）
parameters - initialize_parameters_deep（）的输出
返回：
AL - 最后的激活值
caches - 包含以下内容的缓存列表：
linear_relu_forward（）的每个cache（有L-1个，索引为从0到L-2）
linear_sigmoid_forward（）的cache（只有一个，索引为L-1）
"""
caches = []
A = X
L = len(parameters) // 2
for l in range(1, L):
A_prev = A
A, cache = linear_activation_forward(A_prev, parameters['W' + str(l)], parameters['b' + str(l)], "relu")
caches.append(cache)
AL, cache = linear_activation_forward(A, parameters['W' + str(L)], parameters['b' + str(L)], "sigmoid")
caches.append(cache)
assert (AL.shape == (1, X.shape[1]))
return AL, caches
#测试L_model_forward
print("==============测试L_model_forward==============")
X,parameters = L_model_forward_test_case()
AL,caches = L_model_forward(X,parameters)
print("AL = " + str(AL))
print("caches 的长度为 = " + str(len(caches)))
def compute_cost(AL, Y):
"""
实施等式（4）定义的成本函数。
参数：
AL - 与标签预测相对应的概率向量，维度为（1，示例数量）
Y - 标签向量（例如：如果不是猫，则为0，如果是猫则为1），维度为（1，数量）
返回：
cost - 交叉熵成本
"""
m = Y.shape[1]
cost = -np.sum(np.multiply(np.log(AL), Y) + np.multiply(np.log(1 - AL), 1 - Y)) / m
cost = np.squeeze(cost)
assert (cost.shape == ())
return cost
#测试compute_cost
print("==============测试compute_cost==============")
Y,AL =compute_cost_test_case()
print("cost = " + str(compute_cost(AL, Y)))
#构建反向传播函数的线性部分
def linear_backward(dZ, cache):
"""
为单层实现反向传播的线性部分（第L层）
参数：
dZ - 相对于（当前第l层的）线性输出的成本梯度
cache - 来自当前层前向传播的值的元组（A_prev，W，b）
返回：
dA_prev - 相对于激活（前一层l-1）的成本梯度，与A_prev维度相同
dW - 相对于W（当前层l）的成本梯度，与W的维度相同
db - 相对于b（当前层l）的成本梯度，与b维度相同
"""
A_prev, W, b = cache
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)
assert (dA_prev.shape == A_prev.shape)
assert (dW.shape == W.shape)
assert (db.shape == b.shape)
return dA_prev, dW, db
#测试linear_backward
print("==============测试linear_backward==============")
dZ, linear_cache = linear_backward_test_case()
dA_prev, dW, db = linear_backward(dZ, linear_cache)
print ("dA_prev = "+ str(dA_prev))
print ("dW = " + str(dW))
print ("db = " + str(db))
# 构建反向激活函数
def linear_activation_backward(dA, cache, activation="relu"):
"""
实现LINEAR-> ACTIVATION层的后向传播。
参数：
dA - 当前层l的激活后的梯度值
cache - 我们存储的用于有效计算反向传播的值的元组（值为linear_cache，activation_cache）
activation - 要在此层中使用的激活函数名，字符串类型，【"sigmoid" | "relu"】
返回：
dA_prev - 相对于激活（前一层l-1）的成本梯度值，与A_prev维度相同
dW - 相对于W（当前层l）的成本梯度值，与W的维度相同
db - 相对于b（当前层l）的成本梯度值，与b的维度相同
"""
linear_cache, activation_cache = cache
if activation == "relu":
dZ = relu_backward(dA, activation_cache)
dA_prev, dW, db = linear_backward(dZ, linear_cache)
elif activation == "sigmoid":
dZ = sigmoid_backward(dA, activation_cache)
dA_prev, dW, db = linear_backward(dZ, linear_cache)
return dA_prev, dW, db
# 测试linear_activation_backward
print("==============测试linear_activation_backward==============")
AL, linear_activation_cache =linear_activation_backward_test_case()
dA_prev, dW, db = linear_activation_backward(AL, linear_activation_cache, activation="sigmoid")
print("sigmoid:")
print("dA_prev = " + str(dA_prev))
print("dW = " + str(dW))
print("db = " + str(db) + "\n")
dA_prev, dW, db = linear_activation_backward(AL, linear_activation_cache, activation="relu")
print("relu:")
print("dA_prev = " + str(dA_prev))
print("dW = " + str(dW))
print("db = " + str(db))
def L_model_backward(AL, Y, caches):
"""
对[LINEAR-> RELU] *（L-1） - > LINEAR - > SIGMOID组执行反向传播，就是多层网络的向后传播
参数：
AL - 概率向量，正向传播的输出（L_model_forward（））
Y - 标签向量（例如：如果不是猫，则为0，如果是猫则为1），维度为（1，数量）
caches - 包含以下内容的cache列表：
linear_activation_forward（"relu"）的cache，不包含输出层
linear_activation_forward（"sigmoid"）的cache
返回：
grads - 具有梯度值的字典
grads [“dA”+ str（l）] = ...
grads [“dW”+ str（l）] = ...
grads [“db”+ str（l）] = ...
"""
grads = {}
L = len(caches)
m = AL.shape[1]
Y = Y.reshape(AL.shape)
dAL = - (np.divide(Y, AL) - np.divide(1 - Y, 1 - AL))
current_cache = caches[L - 1]
grads["dA" + str(L)], grads["dW" + str(L)], grads["db" + str(L)] = linear_activation_backward(dAL, current_cache,
"sigmoid")
for l in reversed(range(L - 1)):
current_cache = caches[l]
dA_prev_temp, dW_temp, db_temp = linear_activation_backward(grads["dA" + str(l + 2)], current_cache, "relu")
grads["dA" + str(l + 1)] = dA_prev_temp
grads["dW" + str(l + 1)] = dW_temp
grads["db" + str(l + 1)] = db_temp
return grads
#测试L_model_backward
print("==============测试L_model_backward==============")
AL, Y_assess, caches = L_model_backward_test_case()
grads = L_model_backward(AL, Y_assess, caches)
print ("dW1 = "+ str(grads["dW1"]))
print ("db1 = "+ str(grads["db1"]))
print ("dA1 = "+ str(grads["dA1"]))
#更新参数w和b
def update_parameters(parameters, grads, learning_rate):
"""
使用梯度下降更新参数
参数：
parameters - 包含你的参数的字典
grads - 包含梯度值的字典，是L_model_backward的输出
返回：
parameters - 包含更新参数的字典
参数[“W”+ str（l）] = ...
参数[“b”+ str（l）] = ...
"""
L = len(parameters) // 2 # 整除
for l in range(L):
parameters["W" + str(l + 1)] = parameters["W" + str(l + 1)] - learning_rate * grads["dW" + str(l + 1)]
parameters["b" + str(l + 1)] = parameters["b" + str(l + 1)] - learning_rate * grads["db" + str(l + 1)]
return parameters
# 测试update_parameters
print("==============测试update_parameters==============")
parameters, grads = update_parameters_test_case()
parameters = update_parameters(parameters, grads, 0.1)
print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))
cat_watch.py中
import time
import numpy as np
import h5py
import matplotlib.pyplot as plt
import scipy
from PIL import Image
from scipy import ndimage
from dnn_app_utils_v2 import *
# set default size of plots
plt.rcParams['figure.figsize'] = (5.0, 4.0)
plt.rcParams['image.interpolation'] = 'nearest'
plt.rcParams['image.cmap'] = 'gray'
# 加载数据集
train_x_orig, train_y, test_x_orig, test_y, classes = load_data()
# 显示示例图像
index = 7
plt.imshow(train_x_orig[index])
plt.show()
print ("y = " + str(train_y[0,index]) + ". It's a " + classes[train_y[0,index]].decode("utf-8"))
# 将图像转换为numpy数组
# X_flatten = X.reshape(X.shape [0]，-1).T
# 将训练集的维度降低并转置。
train_set_x_flatten = train_x_orig.reshape(train_x_orig.shape[0],-1).T
# 将测试集的维度降低并转置。
test_set_x_flatten = test_x_orig.reshape(test_x_orig.shape[0], -1).T
# 预处理步骤是对数据集进行居中和标准化，这意味着可以减去每个示例中整个numpy数组的平均值，然后将每个示例除以整个numpy数组的标准偏差
train_x = train_set_x_flatten/255
test_x = test_set_x_flatten/255
# 查看训练集和测试集的维度
print ("train_x's shape: " + str(train_x.shape))
print ("test_x's shape: " + str(test_x.shape))
# # 定义一个两层神经网络模型
# def two_layer_model(X, Y, layers_dims, learning_rate=0.0075, num_iterations=3000, print_cost=False, isPlot=True):
# """
# 实现一个两层的神经网络，【LINEAR->RELU】 -> 【LINEAR->SIGMOID】
# 参数：
# X - 输入的数据，维度为(n_x，例子数)
# Y - 标签，向量，0为非猫，1为猫，维度为(1,数量)
# layers_dims - 层数的向量，维度为(n_y,n_h,n_y)
# learning_rate - 学习率
# num_iterations - 迭代的次数
# print_cost - 是否打印成本值，每100次打印一次
# isPlot - 是否绘制出误差值的图谱
# 返回:
# parameters - 一个包含W1，b1，W2，b2的字典变量
# """
# np.random.seed(1)
# grads = {}
# costs = []
# (n_x, n_h, n_y) = layers_dims
#
# """
# 初始化参数
# """
# parameters = initialize_parameters(n_x, n_h, n_y)
#
# W1 = parameters["W1"]
# b1 = parameters["b1"]
# W2 = parameters["W2"]
# b2 = parameters["b2"]
#
# """
# 开始进行迭代
# """
# for i in range(0, num_iterations):
# # 前向传播
# A1, cache1 = linear_activation_forward(X, W1, b1, "relu")
# A2, cache2 = linear_activation_forward(A1, W2, b2, "sigmoid")
#
# # 计算成本
# cost = compute_cost(A2, Y)
#
# # 后向传播
# ##初始化后向传播
# dA2 = - (np.divide(Y, A2) - np.divide(1 - Y, 1 - A2))
#
# ##向后传播，输入：“dA2，cache2，cache1”。 输出：“dA1，dW2，db2;还有dA0（未使用），dW1，db1”。
# dA1, dW2, db2 = linear_activation_backward(dA2, cache2, "sigmoid")
# dA0, dW1, db1 = linear_activation_backward(dA1, cache1, "relu")
#
# ##向后传播完成后的数据保存到grads
# grads["dW1"] = dW1
# grads["db1"] = db1
# grads["dW2"] = dW2
# grads["db2"] = db2
#
# # 更新参数
# parameters = update_parameters(parameters, grads, learning_rate)
# W1 = parameters["W1"]
# b1 = parameters["b1"]
# W2 = parameters["W2"]
# b2 = parameters["b2"]
#
# # 打印成本值，如果print_cost=False则忽略
# if i % 100 == 0:
# # 记录成本
# costs.append(cost)
# # 是否打印成本值
# if print_cost:
# print("第", i, "次迭代，成本值为：", np.squeeze(cost))
# # 迭代完成，根据条件绘制图
# if isPlot:
# plt.plot(np.squeeze(costs))
# plt.ylabel('cost')
# plt.xlabel('iterations (per tens)')
# plt.title("Learning rate =" + str(learning_rate))
# plt.show()
#
# # 返回parameters
# return parameters
#
# # 输入参数开始训练
# n_x = 12288
# n_h = 7
# n_y = 1
# layers_dims = (n_x,n_h,n_y)
#
# parameters = two_layer_model(train_x, train_y, layers_dims = (n_x, n_h, n_y), num_iterations = 2500, print_cost=True,isPlot=True)
# 预测函数
def predict(X, y, parameters):
"""
该函数用于预测L层神经网络的结果，当然也包含两层
参数：
X - 测试集
y - 标签
parameters - 训练模型的参数
返回：
p - 给定数据集X的预测
"""
m = X.shape[1]
n = len(parameters) // 2 # 神经网络的层数
p = np.zeros((1, m))
# 根据参数前向传播
probas, caches = L_model_forward(X, parameters)
for i in range(0, probas.shape[1]):
if probas[0, i] > 0.5:
p[0, i] = 1
else:
p[0, i] = 0
# 准确度为输出的预测值和实际值相同的个数，占总体样本的百分比。
print("准确度为: " + str(float(np.sum((p == y)) / m)))
return p
# # 查看对于测试集和训练集的准确性
# predictions_train = predict(train_x, train_y, parameters) #训练集
# predictions_test = predict(test_x, test_y, parameters) #测试集
# 搭建L层神经网络模型
def L_layer_model(X, Y, layers_dims, learning_rate=0.0075, num_iterations=3000, print_cost=False, isPlot=True):
"""
实现一个L层神经网络：[LINEAR-> RELU] *（L-1） - > LINEAR-> SIGMOID。
参数：
X - 输入的数据，维度为(n_x，例子数)
Y - 标签，向量，0为非猫，1为猫，维度为(1,数量)
layers_dims - 层数的向量，维度为(n_y,n_h,···,n_h,n_y)
learning_rate - 学习率
num_iterations - 迭代的次数
print_cost - 是否打印成本值，每100次打印一次
isPlot - 是否绘制出误差值的图谱
返回：
parameters - 模型学习的参数。 然后他们可以用来预测。
"""
np.random.seed(1)
costs = []
parameters = initialize_parameters_deep(layers_dims)
for i in range(0, num_iterations):
AL, caches = L_model_forward(X, parameters)
cost = compute_cost(AL, Y)
grads = L_model_backward(AL, Y, caches)
parameters = update_parameters(parameters, grads, learning_rate)
# 打印成本值，如果print_cost=False则忽略
if i % 100 == 0:
# 记录成本
costs.append(cost)
# 是否打印成本值
if print_cost:
print("第", i, "次迭代，成本值为：", np.squeeze(cost))
# 迭代完成，根据条件绘制图
if isPlot:
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (per tens)')
plt.title("Learning rate =" + str(learning_rate))
plt.show()
return parameters
# 输入L层神经网络的参数
layers_dims = [12288, 20, 7, 5, 1] # 5-layer model
parameters = L_layer_model(train_x, train_y, layers_dims, num_iterations = 2500, print_cost = True,isPlot=True)
# 预测训练集和测试集的准确度
pred_train = predict(train_x, train_y, parameters) #训练集
pred_test = predict(test_x, test_y, parameters) #测试集
# 使用自己的图像查看识别效果
# 自己找图片来识别
from PIL import Image
my_label_y = [1] # the true class of your image (1 -> cat, 0 -> non-cat)
# 图像的像素定义为64*64的
num_px = 64
image = Image.open('my_image.jpg')
my_image = np.array(image.resize((num_px, num_px), Image.ANTIALIAS))
my_image = my_image.reshape(num_px * num_px * 3, -1)
predict_my_image = predict(my_image, my_label_y, parameters)
plt.imshow(image)
print("y = " + str(np.squeeze(predict_my_image)) + ", your L-layer model predicts a \"" + classes[
int(np.squeeze(predict_my_image))].decode("utf-8") + "\"picture.")
351
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
