【吴恩达课后编程作业——week3】

最新推荐文章于 2024-03-12 19:00:31 发布

无眠

最新推荐文章于 2024-03-12 19:00:31 发布

阅读量230

点赞数 1

分类专栏：吴恩达深度学习 python函数笔记文章标签：机器学习深度学习人工智能

本文链接：https://blog.csdn.net/sjzszyh/article/details/127445607

版权

python函数同时被 3 个专栏收录

17 篇文章 0 订阅

订阅专栏

笔记

15 篇文章 0 订阅

订阅专栏

吴恩达深度学习

9 篇文章 1 订阅

订阅专栏

简介

本文主要参考该博主的文章来理解创作的：这是原博主的链接地址：https://blog.csdn.net/u013733326/article/details/79702148

一、知识点

1.1 符号及其含义

（1）
在这里插入图片描述
[1] ： layer，这里指第一层
i ： node in layer

（2）
在这里插入图片描述
[m] : 代表第m层
( i )：代表第 i 个训练实例

注：在计算网络层数的时候，输入层不算入总层数内，所以隐藏层是第一层，输出层是第二层，第二个惯例是我们将输入层称为第 0 层

（3）
在这里插入图片描述
W本身是（1，Nx）列向量，Nx 是输入变量 x 的个数，有三个 x 就 1*3

（4）
在这里插入图片描述
在之后的作业中我们可以看到 W 是一个4 x 5 的矩阵，4 是源于我们隐藏层中有四个节点，5 是源于我们有五个输入特征；b 是一个4 x 1 的向量；

（5）

在这里插入图片描述
α ：表示激活的意思
输入层的激活值称为 α[0],下一层的激活值称为 α[1] (规模为 4 x 1 的矩阵或者一个大小为4 x 1 的列向量)

1.2 构建神经网络的办法

定义神经网络的结构（输入单元的数量，隐藏单元的数量）
初始化模型的参数
循环：
实施前向传播
计算损失
实现后向传播
更新参数（梯度下降）

注：
前向传播：通过输入层输入，一路向前，通过输出层输出的一个结果。如图指的是1 、 x1、x2、xn、与权重（weights）相乘，并且加上偏置值b0，然后进行总的求和，同时通过激活函数激活之后算出结果。这个过程就是前向传播。
反向传播是通过输出反向更新权重的过程，具体的说输出位置会产生一个模型的输出，通过这个输出以及原始数据计算一个差值，将前向计算过程反过来计算，通过差值和学习率更新权重。
在神经网络使用反向传播的时候，你真的需要计算激活函数的斜率或者导数

1.3 传播函数

在这里插入图片描述

二、程序

2.1准备软件包

numpy ： python 进行科学计算的基本软件包
sklearn ：为数据挖掘和数据分析提供的简单高效的工具
matplotlib ：在python中绘制图表的库
testCases ：提供一些测试示例来评估函数的正确性
planar_utils : 提供一些测试函数等其他功能

2.2 逻辑回归分类

首先我们导入应有的库到项目当中

import numpy as np
import matplotlib.pyplot as plt
from testCases import *
import sklearn
import sklearn.datasets
import sklearn.linear_model
from planar_utils import plot_decision_boundary, sigmoid, load_planar_dataset, load_extra_datasets



np.random.seed(1) #设置一个固定的随机种子，以保证接下来的步骤中我们的结果是一致的。

我们来加载并且查看一下数据集

X, Y = load_planar_dataset()#加载数据集

plt.scatter(X[0, :], X[1, :], c=Y, s=40, cmap=plt.cm.Spectral) #绘制散点图，参数c代表颜色，s代表尺寸

# 上一语句如出现问题，请使用下面的语句：
# plt.scatter(X[0, :], X[1, :], c=np.squeeze(Y), s=40, cmap=plt.cm.Spectral) #绘制散点图

plt.show()

输出结果是这样的：
在这里插入图片描述
我们的目标是建立一个模型来适应这些数据，现在我们已知有：
X：一个numpy的矩阵，包含了这些数据点的数值
Y：一个numpy的向量，对应着的是X的标签【0 | 1】（红色:0 ，蓝色 :1）

使用简单的逻辑回归来查看效果：（使用sklearn的内置函数来实现）
运行代码：

clf = sklearn.linear_model.LogisticRegressionCV()
clf.fit(X.T,Y.T)


plot_decision_boundary(lambda x: clf.predict(x), X, Y) #绘制决策边界
plt.title("Logistic Regression") #图标题
plt.show()
LR_predictions  = clf.predict(X.T) #预测结果
print ("逻辑回归的准确性： %d " % float((np.dot(Y, LR_predictions) +
		np.dot(1 - Y,1 - LR_predictions)) / float(Y.size) * 100) +
       "% " + "(正确标记的数据点所占的百分比)")

输出结果：

E:\python\pycharm\week3\venv\lib\site-packages\sklearn\utils\validation.py:993: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().
  y = column_or_1d(y, warn=True)
逻辑回归的准确性： 47 % (正确标记的数据点所占的百分比)

Process finished with exit code 0

这里出现提示信息正常
在这里插入图片描述
我们看到准确率只有47%，骑原因是数据集不是线性可分的，所及用逻辑回归的表现不佳。现在我们开始构建神经网络

2.3神经网络

定义神经网络结构（这里直接复制博主的代码，测试代码并没有体现，我会在代码中注释一些自己的理解）

def layer_sizes(X , Y):
    """
    参数：
     X - 输入数据集,维度为（输入的数量，训练/测试的数量）
     Y - 标签，维度为（输出的数量，训练/测试数量）
    
    返回：
     n_x - 输入层的数量
     n_h - 隐藏层的数量
     n_y - 输出层的数量
    """
    n_x = X.shape[0] #输入层
    n_h = 4 #，隐藏层，硬编码为4
    n_y = Y.shape[0] #输出层
    
    return (n_x,n_h,n_y)

初始化参数

def initialize_parameters( n_x , n_h ,n_y):
    """
    参数：
        n_x - 输入层节点的数量
        n_h - 隐藏层节点的数量
        n_y - 输出层节点的数量
    
    返回：
        parameters - 包含参数的字典：
            W1 - 权重矩阵,维度为（n_h，n_x）
            b1 - 偏向量，维度为（n_h，1）
            W2 - 权重矩阵，维度为（n_y，n_h）
            b2 - 偏向量，维度为（n_y，1）

    """
    np.random.seed(2) #指定一个随机种子，以便你的输出与我们的一样。
    W1 = np.random.randn(n_h,n_x) * 0.01#初始化一个维度为（n_h,n_x）的矩阵
    b1 = np.zeros(shape=(n_h, 1))#用 0 初始化（a,b）
    W2 = np.random.randn(n_y,n_h) * 0.01
    b2 = np.zeros(shape=(n_y, 1))
    
    #使用断言确保我的数据格式是正确的
    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

循环
前向传播

def forward_propagation( X , parameters ):
    """
    参数：
         X - 维度为（n_x，m）的输入数据。
         parameters - 初始化函数（initialize_parameters）的输出
    
    返回：
         A2 - 使用sigmoid()函数计算的第二次激活后的数值
         cache - 包含“Z1”，“A1”，“Z2”和“A2”的字典类型变量
     """
    W1 = parameters["W1"]
    b1 = parameters["b1"]
    W2 = parameters["W2"]
    b2 = parameters["b2"]
    #前向传播计算A2
    Z1 = np.dot(W1 , X) + b1
    A1 = np.tanh(Z1)#使用tanh函数计算第一次激活后的数值
    Z2 = np.dot(W2 , A1) + b2
    A2 = sigmoid(Z2)#使用sigmoid函数计算第二次激活后的数值
    #使用断言确保我的数据格式是正确的
    assert(A2.shape == (1,X.shape[1]))
    cache = {"Z1": Z1,
             "A1": A1,
             "Z2": Z2,
             "A2": A2}
    #反向传播所需要的值存储在"cache"中，cache将作为反向传播的输入
    return (A2, cache)

计算损失
在这里插入图片描述

def compute_cost(A2,Y,parameters):
    """
    计算方程（6）中给出的交叉熵成本，
    
    参数：
         A2 - 使用sigmoid()函数计算的第二次激活后的数值
         Y - "True"标签向量,维度为（1，数量）
         parameters - 一个包含W1，B1，W2和B2的字典类型的变量
    
    返回：
         成本 - 交叉熵成本给出方程（13）
    """
    
    m = Y.shape[1]
    W1 = parameters["W1"]
    W2 = parameters["W2"]
    
    #计算成本
    logprobs = np.multiply(np.log(A2), Y) + np.multiply((1 - Y), np.log(1 - A2))
    """np.multiply(a,b)
	 由于multiply是ufunc函数，ufunc函数会对这两个数组的对应元素进行计算，因此它要求这两个数组有相同的大小(shape相同)，相同则是计算内积。如果shape不同的话，会将小规格的矩阵延展成与另一矩阵一样大小，再求两者内积。
	"""
    cost = - np.sum(logprobs) / m
    cost = float(np.squeeze(cost))
    """isinstance()
	函数用来判断一个对象是否是一个已知类型，类似type。
	语法：isinstance（object,classinfo）
	Object:实例对象
	Classinfo：可以是直接或间接类名，基本类型或者由他们组成的元组。
	如果二者相同返回true，不同返回false
	"""
    assert(isinstance(cost,float))
    
    return cost

反向传播

def backward_propagation(parameters,cache,X,Y):
    """
    使用上述说明搭建反向传播函数。
    
    参数：
     parameters - 包含我们的参数的一个字典类型的变量。
     cache - 包含“Z1”，“A1”，“Z2”和“A2”的字典类型的变量。
     X - 输入数据，维度为（2，数量）
     Y - “True”标签，维度为（1，数量）
    
    返回：
     grads - 包含W和b的导数一个字典类型的变量。
    """
    m = X.shape[1]
    
    W1 = parameters["W1"]
    W2 = parameters["W2"]
    
    A1 = cache["A1"]
    A2 = cache["A2"]
    
    dZ2= A2 - Y
    dW2 = (1 / m) * np.dot(dZ2, A1.T)
    db2 = (1 / m) * np.sum(dZ2, axis=1, keepdims=True)
    dZ1 = np.multiply(np.dot(W2.T, dZ2), 1 - np.power(A1, 2))
    dW1 = (1 / m) * np.dot(dZ1, X.T)
    db1 = (1 / m) * np.sum(dZ1, axis=1, keepdims=True)
    grads = {"dW1": dW1,
             "db1": db1,
             "dW2": dW2,
             "db2": db2 }
    
    return grads

更新参数

def update_parameters(parameters,grads,learning_rate=1.2):
    """
    使用上面给出的梯度下降更新规则更新参数
    
    参数：
     parameters - 包含参数的字典类型的变量。
     grads - 包含导数值的字典类型的变量。
     learning_rate - 学习速率
    
    返回：
     parameters - 包含更新参数的字典类型的变量。
    """
    W1,W2 = parameters["W1"],parameters["W2"]
    b1,b2 = parameters["b1"],parameters["b2"]
    
    dW1,dW2 = grads["dW1"],grads["dW2"]
    db1,db2 = grads["db1"],grads["db2"]
    
    W1 = W1 - learning_rate * dW1
    b1 = b1 - learning_rate * db1
    W2 = W2 - learning_rate * dW2
    b2 = b2 - learning_rate * db2
    
    parameters = {"W1": W1,
                  "b1": b1,
                  "W2": W2,
                  "b2": b2}
    
    return parameters

整合

def nn_model(X,Y,n_h,num_iterations,print_cost=False):
    """
    参数：
        X - 数据集,维度为（2，示例数）
        Y - 标签，维度为（1，示例数）
        n_h - 隐藏层的数量
        num_iterations - 梯度下降循环中的迭代次数
        print_cost - 如果为True，则每1000次迭代打印一次成本数值
    
    返回：
        parameters - 模型学习的参数，它们可以用来进行预测。
     """
     
    np.random.seed(3) #指定随机种子
    n_x = layer_sizes(X, Y)[0]#layer_sizes 返回的是一个数组，[0]是指返回第一个值，就是指输入层节点数
    n_y = layer_sizes(X, Y)[2]
    
    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(num_iterations):
        A2 , cache = forward_propagation(X,parameters)
        cost = compute_cost(A2,Y,parameters)
        grads = backward_propagation(parameters,cache,X,Y)
        parameters = update_parameters(parameters,grads,learning_rate = 0.5)
        
        if print_cost:
            if i%1000 == 0:
                print("第 ",i," 次循环，成本为："+str(cost))
    return parameters

预测

def predict(parameters,X):
    """
    使用学习的参数，为X中的每个示例预测一个类
    
    参数：
		parameters - 包含参数的字典类型的变量。
	    X - 输入数据（n_x，m）
    
    返回
		predictions - 我们模型预测的向量（红色：0 /蓝色：1）
     
     """
    A2 , cache = forward_propagation(X,parameters)
    predictions = np.round(A2)
    
    return predictions

运行

parameters = nn_model(X, Y, n_h = 4, num_iterations=10000, print_cost=True)

#绘制边界
plot_decision_boundary(lambda x: predict(parameters, x.T), X, Y)
plt.title("Decision Boundary for hidden layer size " + str(4))

predictions = predict(parameters, X)
print ('准确率: %d' % float((np.dot(Y, predictions.T) + np.dot(1 - Y, 1 - predictions.T)) / float(Y.size) * 100) + '%')

运行结果为：
在这里插入图片描述
我们来看一下隐藏层不同节点数对应的准确率，代码如下：

plt.figure(figsize=(16, 32))
hidden_layer_sizes = [1, 2, 3, 4, 5, 20, 50] #隐藏层数量
for i, n_h in enumerate(hidden_layer_sizes):
    plt.subplot(5, 2, i + 1)
    plt.title('Hidden Layer of size %d' % n_h)
    parameters = nn_model(X, Y, n_h, num_iterations=5000)
    plot_decision_boundary(lambda x: predict(parameters, x.T), X, Y)

    predictions = predict(parameters, X)
    accuracy = float((np.dot(Y, predictions.T) + np.dot(1 - Y, 1 - predictions.T)) / float(Y.size) * 100)
    print ("隐藏层的节点数量： {}  ，准确率: {} %".format(n_h, accuracy))
plt.show()