欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

学习笔记之构建一个具有Logistic回归的神经网络模型

程序员文章站 2024-02-11 12:41:22
...

一、准备工作

1. 首先导入所需的包

import numpy as np
import matplotlib.pyplot as plt 
import h5py
from lr_utils import load_dataset

2. 加载所有数据
数据集可以到本文结尾的参考文章中下载,是一个关于识别猫猫的数据集,以及一个加载数据的库。

train_set_x_orig , train_set_y , test_set_x_orig , test_set_y , classes = load_dataset()
  • train_set_x_orig :保存的是训练集里面的图像数据(本训练集有209张64x64的图像)。
  • train_set_y_orig :保存的是训练集的图像对应的分类值(【0|1】,0表示不是猫,1表示是猫)。
  • test_set_x_orig :保存的是测试集里面的图像数据(本训练集有50张64x64的图像)。
  • test_set_y_orig :保存的是测试集的图像对应的分类值(【0 | 1】,0表示不是猫,1表示是猫)。
  • classes : 保存的是以bytes类型保存的两个字符串数据,数据为:[b’non-cat’ b’cat’]。

3.对数据进行预处理

# 将(a,b,c,d)的矩阵平铺成形状(b*c*d,a)的矩阵,以便计算
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

# 对维度进行标准化,使其位于[0,1]之间
train_set_x = train_set_x_flatten / 255
test_set_x = test_set_x_flatten / 255

至此完成对数据预处理工作,下面开始构建神经网络

二、构建神经网络

1.建立sigmoid函数

def sigmoid(z):
    return 1/(1+np.exp(-z))

2.初始化模型参数,权重和偏置b

def init_params(dim):
    # dim为我们想要的w矢量的大小
    w = np.zeros(shape=(dim,1)).reshape(dim,1)
    # 此处reshape为吴恩达带佬的经验,确保我们需要的w维度是正确的
    # 当然也可以用断言
    b = 0
    return w,b

3.正向传播和反向传播

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,db -相对于w和b的损失梯度
    m = X.shape[1]

    # 正向传播
    # 1)计算**值
    a = sigmoid(np.dot(w.T,X)+b)
    # 2)计算成本
    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)

    cost = np.squeeze(cost)

    grads = {
        "dw":dw,
        "db":db
    }
    return grads,cost
print("====================测试====================")
w, b, X, Y = np.array([[1], [2]]), 2, np.array([[1,2], [3,4]]), np.array([[1, 0]])
grads, cost = propagate(w, b, X, Y)
print ("dw = " + str(grads["dw"]))
print ("db = " + str(grads["db"]))
print ("cost = " + str(cost))
====================测试====================
dw = [[0.99993216]
 [1.99980262]]
db = 0.49993523062470574
cost = 6.000064773192205

4.使用梯度下降更新w和b

def optimize(w,b,X,Y,num_iterations,alpha,print_cost):
    # num_iterations -优化循环的迭代次数
    # alpha -学习率
    # print_cost -每100步打印一次损失值

    costs = []

    for i in range(num_iterations):
        grads,cost = propagate(w,b,X,Y)

        dw = grads["dw"]
        db = grads["db"]

        w = w - alpha * dw
        b = b - alpha * db
        
        #  每迭代100次输出一次误差值       
        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
print("====================测试====================")
w, b, X, Y = np.array([[1], [2]]), 2, np.array([[1,2], [3,4]]), np.array([[1, 0]])
params , grads , costs = optimize(w , b , X , Y , num_iterations=100 , alpha = 0.009 , print_cost = False)
print ("w = " + str(params["w"]))
print ("b = " + str(params["b"]))
print ("dw = " + str(grads["dw"]))
print ("db = " + str(grads["db"]))
====================测试====================
w = [[0.1124579 ]
 [0.23106775]]
b = 1.5593049248448891
dw = [[0.90158428]
 [1.76250842]]
db = 0.4304620716786828

5.实现预测函数

def predict(w,b,X):
    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]):
        Y_prediction[0,i] = 1 if a[0,i] > 0.5 else 0

    return Y_prediction

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)))
====================测试predict====================
predictions = [[1. 1.]]

6.整合以上函数

def model(X_train,Y_train,X_test,Y_test,num_iterations,alpha,print_cost):    
    w,b = init_params(X_train.shape[0])
    parameters,grads,costs = optimize(w,b,X_train,Y_train,num_iterations,alpha,print_cost)

    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_prediction_train": Y_prediction_train,
        "w": w,
        "b": b,
        "alpha": alpha,
        "num_iterations": num_iterations}
    return d

print("====================测试,迭代次数1000====================")
d = model(train_set_x, train_set_y, test_set_x, test_set_y, 1000, 0.005, True)
====================测试,迭代次数1000====================
迭代的次数: 0 , 误差值: 0.693147
迭代的次数: 100 , 误差值: 0.584508
迭代的次数: 200 , 误差值: 0.466949
迭代的次数: 300 , 误差值: 0.376007
迭代的次数: 400 , 误差值: 0.331463
迭代的次数: 500 , 误差值: 0.303273
迭代的次数: 600 , 误差值: 0.279880
迭代的次数: 700 , 误差值: 0.260042
迭代的次数: 800 , 误差值: 0.242941
迭代的次数: 900 , 误差值: 0.228004
训练集准确性: 96.65071770334929 %
测试集准确性: 72.0 %
print("====================测试,迭代次数2000====================")
d = model(train_set_x, train_set_y, test_set_x, test_set_y, 2000, 0.005, True)
====================测试,迭代次数2000====================
迭代的次数: 0 , 误差值: 0.693147
迭代的次数: 100 , 误差值: 0.584508
迭代的次数: 200 , 误差值: 0.466949
迭代的次数: 300 , 误差值: 0.376007
迭代的次数: 400 , 误差值: 0.331463
迭代的次数: 500 , 误差值: 0.303273
迭代的次数: 600 , 误差值: 0.279880
迭代的次数: 700 , 误差值: 0.260042
迭代的次数: 800 , 误差值: 0.242941
迭代的次数: 900 , 误差值: 0.228004
迭代的次数: 1000 , 误差值: 0.214820
迭代的次数: 1100 , 误差值: 0.203078
迭代的次数: 1200 , 误差值: 0.192544
迭代的次数: 1300 , 误差值: 0.183033
迭代的次数: 1400 , 误差值: 0.174399
迭代的次数: 1500 , 误差值: 0.166521
迭代的次数: 1600 , 误差值: 0.159305
迭代的次数: 1700 , 误差值: 0.152667
迭代的次数: 1800 , 误差值: 0.146542
迭代的次数: 1900 , 误差值: 0.140872
训练集准确性: 99.04306220095694 %
测试集准确性: 70.0 %

可以看到,误差值逐渐减少,证明反向传播更新w和b的效果达到了,若提高迭代次数,则准确性会更符合实际情况,若提高alpha学习率,则可能出现过拟合的情况。

7.最后画图看看

costs = np.squeeze(d['costs'])
plt.plot(costs)
plt.ylabel('cost')
plt.xlabel('iterations (per hundreds)')
plt.title("Learning rate =" + str(d["alpha"]))
plt.show()

学习笔记之构建一个具有Logistic回归的神经网络模型

三、小结

按照这位大佬写的吴恩达的课后编程作业来动手实现了一遍,总算理解了逻辑回归、反向传播相关的知识,但还是有一些内容比较模糊,这算是一篇学习笔记把,我会继续根据自己的理解去完善这边博客的。

参考链接:具有神经网络思维的Logistic回归