二、神经网络基础（逻辑回归和向量化）
1、二分类
logistic回归是一个用于二分类（Binary Classification）的算法。二分类就是输出结果y只有0和1两个标签（也有-1和1的情况）。以一个图像识别为例，例如识别猫，1代表猫，0代表不是猫。用y表示输出的结果标签。
在二分类问题中，目标是训练一个分类器，它以图片的特征向量x为输入，预测输出的结果标签y是0还是1。
2、logisitic回归
接下来介绍如何使用逻辑回归来解决二分类问题。逻辑回归中，
表示y为1的概率，取值范围是(0,1)之间。
逻辑回归的线性预测输出可以写成如上形式，已知的特征输入向量x可能是n_x维度，logistic回归的参数w也是n_x维的向量，而b就是一个实数。所以已知输入x和参数w和b，
值得注意的是，在很多其他机器学习资料中，可能把常数b当做w0处理，并引入x0=1。这样从维度来看，x和w都会增加一维。但是在本课程中，为了简化计算和便于理解，多使用上式的形式，将w和b分开比较好。
注意到上式的线性输出区间为整个实数范围，而逻辑回归要求输出范围在[0,1]之间，所以需要进行转换。引入Sigmiod函数（神经网络激活函数），让输出限定在[0,1]之间。
3、logistic回归损失函数
逻辑回归中，w和b都是未知参数，需要反复训练优化得的。为了训练logistic回归模型的参数w以及b，需要定义一个成本函数（cost function）。它是关于未知参数w和b的函数，我们的目标是在训练模型时，要找到合适的w和b，让成本函数J尽可能的小。
Loss(error) function：损失函数（误差函数），可以用来衡量算法的运行情况。这个的直观理解就是我们通过定义这个损失函数L来衡量你的预测输出值y帽和y的实际值有多接近。
- 可以定义损失函数为y帽和y的差的平方，或者它们差的平方的1/2，但是这样做的话，会发现之后讨论的优化问题，会变成非凸的，最后会得到很多个局部最优解，梯度下降法可能找不到全局最优解。
在logistic回归中，我们会定义一个不同的损失函数它有和误差平方相似的作用，这些会给我们一个凸的优化问题。一般而言，我们偏向研究凸函数问题。
- 对于这个损失函数，我们也想让它尽可能的小。
- 损失函数是在单个训练样本中定义的，它衡量了在单个训练样本上的表现。
下面定义一个成本函数，它衡量的是在全体训练样本上的表现。成本函数J是根据之前得到的两个参数w和b，J(w,b)=损失函数求和/m.，即所有m个训练样本的损失函数和的平均。
4、梯度下降法（Gradient Descent）
损失函数是衡量单一训练样例的效果，成本函数用来衡量在全部训练集上参数w和b的效果。下面我们讨论如何使用梯度下降法来训练或学习训练集上的参数w和b。
我们希望找到使成本函数J(w,b)尽可能小的w和b。
- 通过上式不断的更新迭代w。
由于J(w,b)是凸函数，梯度下降算法（Gradient Descent）是先随机选组一组参数w和b值，然后每次迭代的过程中分别沿着w和b的梯度（偏导数）的反方向前进一小步，不断修正w和b。每次迭代更新w和b后，都能让J(w,b)更接近全局最小值。
梯度下降算法每次迭代更新，w和b的修正表达式为：
- alpha是学习因子（learning rate），表示梯度下降的步进长度，其值越大，w和b每次更新的“步伐”更大一些；越小，更新“步伐”更小一些。在程序代码中，我们通常使用dw来表示。
一个神经网络的计算过程是通过正向传播（Forward Propagation）和反向传播（Back Propagation）过程来实现的，首先计算出神经网络的输出，紧接着进行一个反向传输操作，后者我们用来计算出对应的梯度或者函数。
5、课后习题
搭建一个能够**【识别猫】** 的简单的神经网络
import numpy as np
import matplotlib.pyplot as plt
import h5py
from lr_utils import load_dataset
train_set_x_orig, train_set_y, test_set_x_orig, test_set_y, classes = load_dataset()
# index = 25
# plt.imshow(train_set_x_orig[index])
# plt.show()
# print("train_set_y=" + str(train_set_y))
m_train = train_set_y.shape[1] # 训练集里图片的数量。
m_test = test_set_y.shape[1] # 测试集里图片的数量。
num_px = train_set_x_orig.shape[1] # 训练、测试集里面的图片的宽度和高度（均为64x64）。
# 现在看一看我们加载的东西的具体情况
print("训练集的数量: m_train = " + str(m_train))
print("测试集的数量 : m_test = " + str(m_test))
print("每张图片的宽/高 : num_px = " + str(num_px))
print("每张图片的大小 : (" + str(num_px) + ", " + str(num_px) + ", 3)")
print("训练集_图片的维数 : " + str(train_set_x_orig.shape))
print("训练集_标签的维数 : " + str(train_set_y.shape))
print("测试集_图片的维数: " + str(test_set_x_orig.shape))
print("测试集_标签的维数: " + str(test_set_y.shape))
# 为了方便，我们要把维度为（64，64，3）的numpy数组重新构造为（64 x 64 x3，1）的数组，要乘以3的原因是每张图片是由64x64像素构成的，
# 而每个像素点由（R，G，B）三原色构成的，所以要乘以3。在此之后，我们的训练和测试数据集是一个numpy数组，
# 【每列代表一个平坦的图像】 ，应该有m_train和m_test列。
# 当你想将形状（a，b，c，d）的矩阵X平铺成形状（b * c * d，a）的矩阵X_flatten时，可以使用以下代码：
# 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
print("训练集降维最后的维度： " + str(train_set_x_flatten.shape))
print("训练集_标签的维数 : " + str(train_set_y.shape))
print("测试集降维之后的维度: " + str(test_set_x_flatten.shape))
print("测试集_标签的维数 : " + str(test_set_y.shape))
# 为了表示彩色图像，必须为每个像素指定红色，绿色和蓝色通道（RGB），因此像素值实际上是从0到255范围内的三个数字的向量。
# 机器学习中一个常见的预处理步骤是对数据集进行居中和标准化，这意味着可以减去每个示例中整个numpy数组的平均值，
# 然后将每个示例除以整个numpy数组的标准偏差。但对于图片数据集，它更简单，更方便，几乎可以将数据集的每一行除以255（像素通道的最大值），
# 因为在RGB中不存在比255大的数据，所以我们可以放心的除以255，让标准化的数据位于[0,1]之间，现在标准化我们的数据集：
train_set_x = train_set_x_flatten / 255
test_set_x = test_set_x_flatten / 255
# 完成了对数据的处理，我们现在开始构建神经网络。
# 构建sigmoid()
def sigmoid(z):
s = 1 / (1 + np.exp(-z))
return s
# 初始化我们需要的参数w和b
def initialize_with_zeros(dim):
"""
此函数为w创建一个维度为（dim，1）的0向量，并将b初始化为0。
参数：
dim - 我们想要的w矢量的大小（或者这种情况下的参数数量）
返回：
w - 维度为（dim，1）的初始化向量。
b - 初始化的标量（对应于偏差）
"""
w = np.zeros(shape=(dim, 1))
b = 0
# 使用断言来确保我要的数据是正确的
assert (w.shape == (dim, 1)) # w的维度是(dim,1)
assert (isinstance(b, float) or isinstance(b, int)) # b的类型是float或者是int
return (w, b)
# 初始化参数的函数已经构建好了，现在就可以执行“前向”和“后向”传播步骤来学习参数。
# 我们现在要实现一个计算成本函数及其渐变的函数propagate（）。
def propagate(w, b, X, Y):
"""
实现前向和后向传播的成本函数及其梯度。
参数：
w - 权重，大小不等的数组（num_px * num_px * 3，1）
b - 偏差，一个标量
X - 矩阵类型为（num_px * num_px * 3，训练数量）
Y - 真正的“标签”矢量（如果非猫则为0，如果是猫则为1），矩阵维度为(1,训练数据数量)
返回：
cost- 逻辑回归的负对数似然成本
dw - 相对于w的损失梯度，因此与w相同的形状
db - 相对于b的损失梯度，因此与b的形状相同
"""
m = X.shape[1]
# 正向传播
A = sigmoid(np.dot(w.T,X) + b) # 计算激活值
cost = (- 1 / m) * np.sum(Y * np.log(A) + (1 - Y) * (np.log(1 - A))) # 计算成本
# 反向传播
dw = (1 / m) * np.dot(X, (A - Y).T)
db = (1 / m) * np.sum(A - Y)
# 使用断言确保数据正确
assert(dw.shape == w.shape)
assert(db.dtype == float)
cost = np.squeeze(cost) # 去除所有维度为1的轴，将cost转化为一个标量值
assert(cost.shape == ()) # () 表示空的形状元组，表示这是一个零维数组，即标量。
# 创建一个字典，把dw和db保存起来
grads = {"dw": dw, "db": db}
return (grads, cost)
# 构建梯度下降函数
def optimize(w, b, X, Y, num_iterations, learning_rate, print_cost = False):
"""
此函数通过运行梯度下降算法来优化w和b
参数：
w - 权重，大小不等的数组（num_px * num_px * 3，1）
b - 偏差，一个标量
X - 维度为（num_px * num_px * 3，训练数据的数量）的数组。
Y - 真正的“标签”矢量（如果非猫则为0，如果是猫则为1），矩阵维度为(1,训练数据的数量)
num_iterations - 优化循环的迭代次数
learning_rate - 梯度下降更新规则的学习率
print_cost - 每100步打印一次损失值
返回：
params - 包含权重w和偏差b的字典
grads - 包含权重和偏差相对于成本函数的梯度的字典
成本 - 优化期间计算的所有成本列表，将用于绘制学习曲线。
提示：
我们需要写下两个步骤并遍历它们：
1）计算当前参数的成本和梯度，使用propagate（）。
2）使用w和b的梯度下降法则更新参数。
"""
costs = []
for i in range(num_iterations):
grads, cost = propagate(w, b, X, Y)
dw = grads["dw"]
db = grads["db"]
w = w - learning_rate * dw
b = b - learning_rate * db
# 记录成本
if i % 100 == 0:
costs.append(cost)
# 打印成本数据
if (print_cost) and (i % 100 == 0):
print('迭代的次数：%i, 误差值： %f' % (i, cost))
params = {
"w": w,
"b": b}
grads = {
"dw": dw,
"db": db}
return (params, grads, costs)
# optimize函数会输出已学习的w和b的值，我们可以使用w和b来预测数据集X的标签。
# 构建函数predict()
def predict(w, b, X):
"""
使用学习逻辑回归参数logistic （w，b）预测标签是0还是1，
参数：
w - 权重，大小不等的数组（num_px * num_px * 3，1）
b - 偏差，一个标量
X - 维度为（num_px * num_px * 3，训练数据的数量）的数据
返回：
Y_prediction - 包含X中所有图片的所有预测【0 | 1】的一个numpy数组（向量）
"""
m = X.shape[1] # 图片的数量
Y_prediction = np.zeros((1, m))
w = w.reshape(X.shape[0], 1)
# 预测猫在图片中出现的概率
A = sigmoid(np.dot(w.T, X) + b)
for i in range(A.shape[1]):
# 将概率a [0，i]转换为实际预测p [0，i]
Y_prediction[0, i] = 1 if A[0, i] > 0.5 else 0
# 断言
assert (Y_prediction.shape == (1, m))
return Y_prediction
# 测试predict
# print("====================测试predict====================")
# w, b, X, Y = np.array([[1], [2]]), 2, np.array([[1, 2], [3, 4]]), np.array([[1, 0]])
# print("predictions = " + str(predict(w, b, X)))
# 这些函数统统整合到一个model()函数
def model(X_train, Y_train, X_test, Y_test, num_iterations = 2000 , learning_rate = 0.5 , print_cost = False):
"""
通过调用之前实现的函数来构建逻辑回归模型
参数：
X_train - numpy的数组,维度为（num_px * num_px * 3，m_train）的训练集
Y_train - numpy的数组,维度为（1，m_train）（矢量）的训练标签集
X_test - numpy的数组,维度为（num_px * num_px * 3，m_test）的测试集
Y_test - numpy的数组,维度为（1，m_test）的（向量）的测试标签集
num_iterations - 表示用于优化参数的迭代次数的超参数
learning_rate - 表示optimize（）更新规则中使用的学习速率的超参数
print_cost - 设置为true以每100次迭代打印成本
返回：
d - 包含有关模型信息的字典。
"""
w, b = initialize_with_zeros(X_train.shape[0])
parameters, grads, costs = optimize(w, b, X_train, Y_train, num_iterations, learning_rate, print_cost)
# 从字典“参数”中检索参数w和b
w, b = parameters["w"], parameters["b"]
# 预测测试/训练集的例子
Y_prediction_test = predict(w, b, X_test)
Y_prediction_train = predict(w, b, X_train)
# 打印训练后的准确性
print("训练集准确性：", format(100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100), "%")
print("测试集准确性：", format(100 - np.mean(np.abs(Y_prediction_test - Y_test)) * 100), "%")
d = {
"costs": costs,
"Y_prediction_test": Y_prediction_test,
"Y_prediciton_train": Y_prediction_train,
"w": w,
"b": b,
"learning_rate": learning_rate,
"num_iterations": num_iterations}
return d
d = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 2000, learning_rate = 0.005, print_cost = True)
# #绘制图
# costs = np.squeeze(d['costs'])
# plt.plot(costs)
# plt.ylabel('cost')
# plt.xlabel('iterations (per hundreds)')
# plt.title("Learning rate =" + str(d["learning_rate"]))
# plt.show()
# 尝试使用不同初始化的learning_rates变量值，并对比结果
learning_rates = [0.01, 0.001, 0.0001]
models = {}
for i in learning_rates:
print("learning rate is: " + str(i))
models[str(i)] = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 1500, learning_rate = i, print_cost = False)
print('\n' + "-------------------------------------------------------" + '\n')
for i in learning_rates:
plt.plot(np.squeeze(models[str(i)]["costs"]), label= str(models[str(i)]["learning_rate"]))
plt.ylabel('cost')
plt.xlabel('iterations')
legend = plt.legend(loc='upper center', shadow=True)
frame = legend.get_frame()
frame.set_facecolor('0.90')
plt.show()
浙公网安备 33010602011771号