DL构建具有单隐藏层的2类分类神经网络-带有一个隐藏层的平面数据分类

Posted Tialyg

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了DL构建具有单隐藏层的2类分类神经网络-带有一个隐藏层的平面数据分类相关的知识,希望对你有一定的参考价值。

第三周作业 - 带有一个隐藏层的平面数据分类

我们简单说一下我们要做什么。我们要建立一个神经网络,它有一个隐藏层。你会发现这个模型和上一个逻辑回归实现的模型有很大的区别。

实现:
构建具有单隐藏层的2类分类神经网络。
使用具有非线性激活功能激活函数,例如tanh。
计算交叉熵损失(损失函数)。
实现向前和向后传播。

numpy:是用Python进行科学计算的基本软件包。
sklearn:为数据挖掘和数据分析提供的简单高效的工具。
matplotlib :是一个用于在Python中绘制图表的库。
testCases:提供了一些测试示例来评估函数的正确性,参见下载的资料或者在底部查看它的代码。
planar_utils :提供了在这个任务中使用的各种有用的功能,参见下载的资料或者在底部查看它的代码。

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


%matplotlib inline   #如果你使用用的是Jupyter Notebook的话请取消注释。
np.random.seed(1)    #设置一个固定的随机种子,以保证接下来的步骤中我们的结果是一致的。

一、加载和查看数据集

首先,我们来看看我们将要使用的数据集, 下面的代码会将一个花的图案的2类数据集加载到变量X和Y中。

X,Y = load_planar_dataset()

#把数据集加载完成了,然后使用matplotlib可视化数据集,代码如下:
plt.scatter(X[0,:],X[1,:],c=Y,s=40,cmap=plt.cm.Spectral)   ##绘制散点图

#X包含了这些数据的数值
#Y标签  红色 y=0,蓝色 y=1 

#s=40,表示散点的大小为40,可以输入与样本数量相同的列表,表示不同点的不同大小;

# c=y,c表示颜色,可以使用c='b’这样的命令将所有散点表示为同一颜色,
# 也可以是一个与样本数量相同的序列,因为y中的取值有两个(0或1),
# 散点根据y的索引表示为两种不同的颜色用以区分不用类别;

# cmap表示Colormap实体或者是一个colormap的名字,cmap =
# plt.cm.Spectral实现的功能是给label为1的点一种颜色,给label为0的点另一种颜色。


shape_X = X.shape
shape_Y = Y.shape
m = Y.shape[1]  # 训练集里面的数量

print ("X的维度为: " + str(shape_X))
print ("Y的维度为: " + str(shape_Y))
print ("数据集里面的数据有:" + str(m) + " 个")


#X - 维度为(n_x,m)的输入数据。  所以这里输入为2


在构建完整的神经网络之前,先让我们看看逻辑回归在这个问题上的表现如何,我们可以使用sklearn的内置函数来做到这一点, 运行下面的代码来训练数据集上的逻辑回归分类器。

clf = sklearn.linear_model.LogisticRegressionCV()  #逻辑回归
clf.fit(X.T,Y.T)

#lambda x: clf.predict(x), 输入为x,输出为clf.predict(x)
plot_decision_boundary(lambda x: clf.predict(x), X, Y) #绘制决策边界  # 预测X, Y对应坐标
plt.title("Logistic Regression") #图标题
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) +
       "% " + "(正确标记的数据点所占的百分比)")

#准确性只有47%的原因是数据集不是线性可分的,所以逻辑回归表现不佳,现在我们正式开始构建神经网络。

二、构建神经网络的一般方法是:

1.定义神经网络结构(输入单元的数量,隐藏单元的数量等)。
2.初始化模型的参数
3.循环:
3.1实施前向传播
3.2计算损失
3.3实现向后传播
3.4更新参数(梯度下降)

我们要它们合并到一个nn_model() 函数中,当我们构建好了nn_model()并学习了正确的参数,我们就可以预测新的数据。

2.1定义神经网络结构

在构建之前,我们要先把神经网络的结构给定义好:
n_x: 输入层的数量
n_h: 隐藏层的数量(这里设置为4)
n_y: 输出层的数量

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

    return (n_x,n_h,n_y)
#测试一下
#测试layer_sizes
print("=========================测试layer_sizes=========================")
X_asses , Y_asses = layer_sizes_test_case()
(n_x,n_h,n_y) =  layer_sizes(X_asses,Y_asses)
print("输入层的节点数量为: n_x = " + str(n_x))
print("隐藏层的节点数量为: n_h = " + str(n_h))
print("输出层的节点数量为: n_y = " + str(n_y))

2.2 初始化模型的参数

我们要实现函数initialize_parameters()。我们要确保我们的参数大小合适,如果需要的话,请参考上面的神经网络图。

我们将会用随机值初始化权重矩阵
p.random.randn(a,b)* 0.01来随机初始化一个维度为(a,b)的矩阵。
将偏向量初始化为零。
np.zeros((a,b))用零初始化矩阵(a,b)。

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)  #指定一个随机种子,以便你的输出与我们的一样。   
#  seed( ) 用于指定随机数生成时所用算法开始的整数值。
# 1.如果使用相同的seed( )值,则每次生成的随即数都相同;
# 2.如果不设置这个值,则系统根据时间来自己选择这个值,此时每次生成的随机数因时间差异而不同。
# 3.设置的seed()值仅一次有效
    W1 = np.random.randn(n_h,n_x)*0.01
    b1 = np.zeros(shape = (n_h,1))
    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


#测试initialize_parameters
print("=========================测试initialize_parameters=========================")    
n_x , n_h , n_y = initialize_parameters_test_case()
parameters = initialize_parameters(n_x , n_h , n_y)
print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))

2.3 循环

2.3.1 前向传播

我们现在要实现前向传播函数forward_propagation()。
我们可以使用sigmoid()函数,也可以使用np.tanh()函数。

步骤:
使用字典类型的parameters(它是initialize_parameters() 的输出)检索每个参数。
实现向前传播, ( 训练集里面所有例子的预测向量)。
反向传播所需的值存储在“cache”中,cache将作为反向传播函数的输入。

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)  #第一层的激活函数
    #A1=np.where(Z1>0,Z1,0)  #relu激活函数
    Z2 = np.dot(W2 , A1) + b2
    A2 = sigmoid(Z2)  #输出层用的sigmioid的激活函数

    #使用断言确保我的数据格式是正确的
    assert(A2.shape == (1,X.shape[1]))
    cache = "Z1": Z1,
             "A1": A1,
             "Z2": Z2,
             "A2": A2
    
    return (A2, cache)

#测试forward_propagation
print("=========================测试forward_propagation=========================") 
X_assess, parameters = forward_propagation_test_case()
A2, cache = forward_propagation(X_assess, parameters)
#print(cache["Z1"])
print(np.mean(cache["Z1"]), np.mean(cache["A1"]), np.mean(cache["Z2"]), np.mean(cache["A2"]))

# mean()函数功能:求取均值
# 经常操作的参数为axis,以m * n矩阵举例:
# axis 不设置值,对 m*n 个数求均值,返回一个实数
# axis = 0:压缩行,对各列求均值,返回 1* n 矩阵
# axis =1 :压缩列,对各行求均值,返回 m *1 矩阵

2.3.2计算损失

正式开始构建计算成本的函数:

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))
    cost = - np.sum(logprobs) / m
    cost = float(np.squeeze(cost))   #numpy.squeeze()函数 作用:从数组的形状中删除单维度条目,即把shape中为1的维度去掉
    
    assert(isinstance(cost,float))
    
    return cost
#测试一下我们的成本函数:
#测试compute_cost
print("=========================测试compute_cost=========================") 
A2 , Y_assess , parameters = compute_cost_test_case()
print("cost = " + str(compute_cost(A2,Y_assess,parameters)))

2.3.3 向后传播

使用正向传播期间计算的cache,现在可以利用它实现反向传播。
向量化表示
需要使用六个方程

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)   #axis为1是压缩列,即将每一行的元素相加,将矩阵压缩为一列
    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

#测试backward_propagation
print("=========================测试backward_propagation=========================")
parameters, cache, X_assess, Y_assess = backward_propagation_test_case()

grads = backward_propagation(parameters, cache, X_assess, Y_assess)
print ("dW1 = "+ str(grads["dW1"]))
print ("db1 = "+ str(grads["db1"]))
print ("dW2 = "+ str(grads["dW2"]))
print ("db2 = "+ str(grads["db2"]))

2.3.4更新参数

我们需要使用(dW1, db1, dW2, db2)来更新(W1, b1, W2, b2)。

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

#测试update_parameters
print("=========================测试update_parameters=========================")
parameters, grads = update_parameters_test_case()
parameters = update_parameters(parameters, grads)

print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))

整合

把前面的函数都调用过来。

模型中传入的参数是,X,Y,和迭代次数

首先需要得到你要设计的神经网络结构,调用layer_sizes()得到了n_x,n_y,也就是输入层和输出层。
初始化参数initialize_parameters(n_x, n_h, n_y),得到初始化的 W1, b1, W2, b2
然后开始循环
使用forward_propagation(X, parameters),先得到各个神经元的计算值。
然后compute_cost(A2, Y, parameters),得到cost
backward_propagation(parameters, cache, X, Y)计算出每一步的梯度
update_parameters(parameters, grads)更新一下参数
返回训练完的parameters

def nn_model(X,Y,n_h,num_iterations,learning_rate,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]
    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)
        
        if print_cost:
            if i%1000 == 0:
                print("第 ",i," 次循环,成本为:"+str(cost))
    return parameters

#测试nn_model
print("=========================测试nn_model=========================")
X_assess, Y_assess = nn_model_test_case()

parameters = nn_model(X_assess, Y_assess, 4, num_iterations=10000, learning_rate = 0.5,print_cost=False)
print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))

三、预测

构建predict()来使用模型进行预测, 使用向前传播来预测结果。

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
#测试predict
print("=========================测试predict===============

以上是关于DL构建具有单隐藏层的2类分类神经网络-带有一个隐藏层的平面数据分类的主要内容,如果未能解决你的问题,请参考以下文章

神经网络中 2 个隐藏层的反向传播和前向传播

基本的 deeplearning4j 分类示例

Keras 序列模型输入层

一:输入层隐藏层输出层;二隐藏层的层数

用于不平衡多类多标签分类的神经网络

受限玻尔兹曼机