吴恩达编程作业L2W2

最新推荐文章于 2024-11-05 15:28:12 发布
最新推荐文章于 2024-11-05 15:28:12 发布
阅读量80 收藏
点赞数
分类专栏： 神经网络 python 文章标签： python numpy 开发语言 神经网络 机器学习 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45900622/article/details/134137457
版权
本文介绍了一个基于Python的深度学习神经网络类，包括初始化权重、前向传播、反向传播和不同优化器（GD、Momentum、Adam）的训练过程。作者还展示了使用不同优化器训练时遇到的问题，如损失函数波动大和准确性分析。
摘要由CSDN通过智能技术生成

code:

from dnn_utils_v2 import *
import numpy as np
import h5py
import matplotlib.pyplot as plt
from dnn_utils_v2 import relu_backward
class dnn:
    def __init__(self,layer_dims,optimezer="gd") -> None:
        '''layer_dimes:各层的神经元数量
            init_mod:初始化方法:zeros,random,he三种初始化'''
        self.WL={}
        self.bL={}
        self.L=len(layer_dims)-1
        # 初始化参数
        np.random.seed(3)
        for i in range(1,self.L+1):
            self.WL['W'+str(i)]=np.random.randn(layer_dims[i], layer_dims[i-1])  / np.sqrt(layer_dims[i-1])
            self.bL['b'+str(i)]=np.zeros((layer_dims[i],1))
        self.XL={}
        self.AL={}
        self.ZL={}
        self.dZ={}
        self.dW={}
        self.db={}
        self.dA={}
        
        self.minibatchs=[]
    def input_data(self,X,Y,learning_rate,optimizer,minibatchsize=64,b1=0.9,b2=0.8):
        self.learning_rate=learning_rate
        # minibatch的大小
        self.minbatch_size=minibatchsize
        self.optimizer=optimizer
        self.AL["A0"]=X
        self.Y=Y
        self.m=X.shape[1]
        if optimizer=='':
            # 无任何优化
            self.m=X.shape[1]
            
        elif optimizer=='gd':
            # minibatch
            # 初始化minibatch
            self.ini_gd()
        elif optimizer=='moment':
            self.ini_mom(b1)
        elif optimizer=='adam':
            self.ini_ada(b1,b2)
    
    def ini_gd(self):
        # state=np.random.get_state()
        # np.random.shuffle(self.AL["A0"])
        # np.random.set_state(state)
        # np.random.shuffle(self.Y)
        self.minibatch_num=np.floor(self.Y.shape[1]/self.minbatch_size)
        print("分成"+str(self.minibatch_num)+str("个minibatch"))
        print(self.minibatch_num)
        # 划分minibatch
        for k in range(int(self.minibatch_num)):
            temp_minibatch_x=self.AL["A0"][:,k*self.minbatch_size:(k+1)*self.minbatch_size]
            temp_minibatch_y=self.Y[:,k*self.minbatch_size:(k+1)*self.minbatch_size]
            temp_minibatch=(temp_minibatch_x,temp_minibatch_y)
            print("第"+str(k)+"个minibatch大小:x.shape="+str(temp_minibatch_x.shape)+"y.shape="+str(temp_minibatch_y.shape))
            self.minibatchs.append(temp_minibatch)
        if self.Y.shape[1]%self.minbatch_size!=0:
            temp_minibatch_x=self.AL["A0"][:,int(self.minibatch_num)*self.minbatch_size:]
            temp_minibatch_y=self.Y[:,int(self.minibatch_num)*self.minbatch_size:]
            temp_minibatch=(temp_minibatch_x,temp_minibatch_y)
            print("第"+str(self.minibatch_num+1)+"个minibatch大小:x.shape="+str(temp_minibatch_x.shape)+"y.shape="+str(temp_minibatch_y.shape))
            self.minibatchs.append(temp_minibatch)
    def ini_mom(self,b1):
        # 超参数
        self.b1=b1
        self.ini_gd()
        self.ini_v()
    def ini_ada(self,b1,b2):
        # 超参数
        self.b1=b1
        self.b2=b2
        self.ini_gd()
        self.ini_v()
        self.ini_s()
    def set_data(self,X):
        # 预测时设置输入
        self.m=X.shape[1]
        self.AL["A0"]=X
    def ini_v(self):
        # momentum优化方法的初始化动量
        self.vdW={}
        self.vdb={}
        for i in range(1,self.L+1):
            self.vdW['dW'+str(i)]=np.zeros(self.WL["W"+str(i)].shape)
            self.vdb['db'+str(i)]=np.zeros(self.bL['b'+str(i)].shape)
    def ini_s(self):
        self.SdW={}
        self.Sdb={}
        self.vWc={}
        self.vbc={}
        self.sWc={}
        self.sbc={}
        for i in range(1,self.L+1):
            self.SdW['dW'+str(i)]=np.zeros(self.WL["W"+str(i)].shape)
            self.Sdb['db'+str(i)]=np.zeros(self.bL['b'+str(i)].shape)
    #下面是前向传播模块,前向传播过程中需要记录Z,A 
    def linear_activation_forward(self,i,activation):
        
        '''实现一层的正向传播'''
        # self.ZL[Zi]和self.AL[Ai]记录第i层的数据
        # 存储了计算的Z ,A,W,b,对象自带的有
        self.ZL['Z'+str(i)]=np.dot(self.WL['W'+str(i)],self.AL['A'+str(i-1)])+self.bL['b'+str(i)]
        if activation=="sigmoid":
            self.AL['A'+str(i)]=1/(1+np.exp(-self.ZL['Z'+str(i)]))
        elif activation=="relu":
            self.AL['A'+str(i)]=np.maximum(0,self.ZL['Z'+str(i)])    
        
    def L_model_forward(self):
        # 前L-1层使用relu函数激活,最后一层使用sigmoid函数激活
        for i in range(1,self.L):
            self.linear_activation_forward(i,"relu")
        self.linear_activation_forward(self.L,"sigmoid")
        # 确定最后的输出是否是二分类所需要的输出
        # print("AL.shape="+str(self.AL['A'+str(self.L)].shape)+" Y.shape=s"+str(self.Y.shape[1]))
        assert(self.AL['A'+str(self.L)].shape==(1,self.m))

    # 下面是计算损失函数
    def computer_cost(self):
        return np.squeeze(-1/self.m*np.sum(self.Y*np.log(self.AL['A'+str(self.L)]+1e-5)+(1-self.Y)*np.log(1-self.AL['A'+str(self.L)]+1e-5)))

    # 下面是反向传播模块
    def linear_backward(self,i):
        '''根据dz[L]计算dw[L],db[L],dA[L-1]'''
        self.dW['dW'+str(i)]=1/self.Y.shape[1]*np.dot(self.dZ['dZ'+str(i)],self.AL["A"+str(i-1)].T)
        self.db['db'+str(i)]=1/self.Y.shape[1]*np.sum(self.dZ['dZ'+str(i)],axis=1,keepdims=True)
        self.dA['dA'+str(i-1)]=np.dot(self.WL['W'+str(i)].T,self.dZ['dZ'+str(i)])
    def L_model_backforward(self):
        #  先计算最后一层
        # 计算dA
        self.dA['dA'+str(self.L)]=-(np.divide(self.Y,self.AL['A'+str(self.L)]+1e-10)-np.divide(1-self.Y,1-self.AL['A'+str(self.L)]+1e-10))
        # 计算dz
        s=1/(1+np.exp(-self.ZL['Z'+str(self.L)]))
        self.dZ['dZ'+str(self.L)]=self.dA['dA'+str(self.L)]*s*(1-s)
        # 计算dw,db,dA[L-1]
        self.linear_backward(self.L)
        for i in reversed(range(self.L)):
            if i==0:
                break
            else:
                self.dZ['dZ'+str(i)]=relu_backward(self.dA['dA'+str(i)],self.ZL['Z'+str(i)])
                # 计算当前i层的dw,db,和dA[L-1]
                self.linear_backward(i)   

    # 更新参数
    # minibatch的更新参数
    def update_wb(self):
        for i in range(1,self.L+1):
            self.WL['W'+str(i)]=self.WL['W'+str(i)]-self.learning_rate*self.dW['dW'+str(i)]
            self.bL['b'+str(i)]=self.bL['b'+str(i)]-self.learning_rate*self.db['db'+str(i)]
    
    # 使用momentum优化的更新参数
    def update_wb_withmomentum(self):
        for i in range(1,self.L+1):
            self.WL['W'+str(i)]=self.WL['W'+str(i)]-self.learning_rate*self.vdW['dW'+str(i)]
            self.bL['b'+str(i)]=self.bL['b'+str(i)]-self.learning_rate*self.vdb['db'+str(i)]
    # 使用adam优化的更新参数
    def update_wb_withadam(self):
        for i in range(1,self.L+1):
            self.WL['W'+str(i)]=self.WL['W'+str(i)]-self.learning_rate*(self.vWc['dW'+str(i)]/(np.sqrt(self.sWc['dW'+str(i)])+1e-7))
            self.bL['b'+str(i)]=self.bL['b'+str(i)]-self.learning_rate*(self.vbc['db'+str(i)]/(np.sqrt(self.sbc['db'+str(i)])+1e-7))

    # 更新动力vdw， vdb
    def update_vdwb(self):
        for i in range(1,self.L+1):
            self.vdW['dW'+str(i)]=self.b1*self.vdW['dW'+str(i)]+(1-self.b1)*self.dW['dW'+str(i)]
            self.vdb['db'+str(i)]=self.b1*self.vdb['db'+str(i)]+(1-self.b1)*self.db['db'+str(i)]

    # 更新vdwvdb和s
    def update_svdwb(self):
        for i in range(1,self.L+1):
            self.vdW['dW'+str(i)]=self.b1*self.vdW['dW'+str(i)]+(1-self.b1)*self.dW['dW'+str(i)]
            self.vdb['db'+str(i)]=self.b1*self.vdb['db'+str(i)]+(1-self.b1)*self.db['db'+str(i)]
            self.vWc['dW'+str(i)]=self.vdW['dW'+str(i)]/(1-self.b1**2)
            self.vbc['db'+str(i)]=self.vdb['db'+str(i)]/(1-self.b1**2)
            self.SdW['dW'+str(i)]=self.b2*self.SdW['dW'+str(i)]+(1-self.b2)*(self.dW['dW'+str(i)]**2)
            self.Sdb['db'+str(i)]=self.b2*self.Sdb['db'+str(i)]+(1-self.b2)*(self.db['db'+str(i)]**2)
            self.sWc['dW'+str(i)]=self.SdW['dW'+str(i)]/(1-self.b2**2)
            self.sbc['db'+str(i)]=self.Sdb['db'+str(i)]/(1-self.b2**2)
    def train(self,iterations):
        costs=[]
        for i in range(iterations):
            if self.optimizer=='':
                # 前向传播
                self.L_model_forward()
                # 计算损失
                cost=self.computer_cost()
                # 后向传播
                self.L_model_backforward()
                # 更新参数
                self.update_wb()
                if i%100==0:
                    costs.append(cost)
                    print("第"+str(i)+"次迭代cost:"+str(cost))
            elif self.optimizer=='gd':
                for minibatch in self.minibatchs:
                    (minibatch_x,minibatch_y)=minibatch
                    self.AL['A0']=minibatch_x
                    self.Y=minibatch_y
                    # 更新每个minibatch在正向传播时的m
                    self.m=minibatch_x.shape[1]
                    self.L_model_forward()
                    cost=self.computer_cost()
                    self.L_model_backforward()
                    self.update_wb()
                    if i%100==0:
                        costs.append(cost)
                    #     print("第"+str(i)+"次迭代的minibatch_cost:"+str(cost))
            elif self.optimizer=='moment':
                for minibatch in self.minibatchs:
                    (minibatch_x,minibatch_y)=minibatch
                    self.AL['A0']=minibatch_x
                    self.Y=minibatch_y
                    self.m=minibatch_x.shape[1]
                    self.L_model_forward()
                    cost=self.computer_cost()
                    self.L_model_backforward()
                    self.update_vdwb()
                    self.update_wb_withmomentum()
                    if i%100==0:
                        costs.append(cost)
                        print("第"+str(i)+"次迭代的minibatch_cost:"+str(cost))   
            elif self.optimizer=='adam':
                for minibatch in self.minibatchs:
                    (minibatch_x,minibatch_y)=minibatch
                    self.AL['A0']=minibatch_x
                    self.Y=minibatch_y
                    self.m=minibatch_x.shape[1]
                    self.L_model_forward()
                    cost=self.computer_cost()
                    self.L_model_backforward()
                    self.update_svdwb()
                    self.update_wb_withadam()
                    if i%100==0:
                        costs.append(cost)
                        print("第"+str(i)+"次迭代的minibatch_cost:"+str(cost))
        return costs
    def predict(self,X):
        self.set_data(X)
        self.L_model_forward()
        return self.AL['A'+str(self.L)]>=0.5


#加载数据
train_x, train_y, test_x, test_y = load_2D_dataset()


# 4层的神经网络
my_dnn=dnn([2, 3,  2, 1])

# 设置数据
my_dnn.input_data(train_x,train_y,0.01,"adam",32,0.9)

# 训练
cost=my_dnn.train(3000)


# 预测

y_predict_train=my_dnn.predict(train_x)
y_predict_train_int = [int(x) for x in y_predict_train[0]]
y_predict_test=my_dnn.predict(test_x)
y_predict_test_int = [int(x) for x in y_predict_test[0]]

plt.subplot(1,2,1)
plot_decision_boundary(lambda x: my_dnn.predict(x.T), train_x, train_y)
plt.subplot(1,2,2)
plt.plot(cost)
print("训练集准确度:"+str((1-np.sum(np.abs(y_predict_train_int-train_y))/train_y.shape[1])*100)+"%")
print("测试集准确度"+str((1-np.sum(np.abs(y_predict_test_int-test_y))/test_y.shape[1])*100)+"%")
plt.show()

使用的数据集还是上一个作业的数据集
1.无任何优化的实验结果：
在这里插入图片描述
2.使用minibatch的优化结果：
每个minibatch的大小时32;
在这里插入图片描述
损失的变化幅度太大了，应该是数据问题，也有可能时代码问题，大佬路过的如果有空可以检查检查
3.使用moment的优化
在这里插入图片描述
结果和上面的一样，就很奇怪。。。。。
4.使用Adam优化
在这里插入图片描述
依旧损失反复跳动的问题。哎

小王要当超人
关注
专栏目录
吴恩达深度学习L2W3作业
m0_67611983的博客
12-07 1151
欢迎来到本周的编程作业。到目前为止，你一直使用numpy来构建神经网络。现在，我们将引导你使用深度学习框架，该框架将使你可以更轻松地构建神经网络。TensorFlow，PaddlePaddle，Torch，Caffe，Keras等机器学习框架可以极大地加快你的机器学习开发速度。所有这些框架也都有很多文档，你应该随时阅读学习。编程框架不仅可以缩短编码时间，而且有时还可以进行优化以加快代码速度。
吴恩达深度学习作业之deepleraning_L1W2_h1
Learningisgood的博客
02-26 1080
#吴恩达《深度学习》L1W2作业1 知识点：numpy入门，函数向量化实现 ''' 做完这个作业，你能学会： 用ipython notebook 用numpy，包括函数调用及向量矩阵运算 理解“广播”的概念 向量化代码 ''' #我们很少在深度学习中使用“math”库。 因为math函数的输入是实数. #而深度学习中主要使用的是矩阵和向量，因此numpy更为实用。 a=5 b=[1,2,3,4] import math math.exp(a) math.exp(b) import...
吴恩达深度学习课程第二章第一周编程作业
only my railgun
11-08 2014
文章目录声明一、任务描述二、编程实现1.数据2.参数初始化2.1 初始化参数为02.2 参数随机初始化2.3 抑梯度异常初始化2.4 主控函数2.5 测试结果对比2.5.1 初始化为02.5.2 随机初始化参数2.5.3抑梯度异常初始化3.模型正则化3.1 L2正则化二、使用步骤1.引入库2.读入数据总结 声明   本博客只是记录一下本人在深度学习过程中的学习笔记和编程经验，大部分代码是参考了【中文】【吴恩达课后编程作业】Course 2 - 改善深层神经网络 - 第一周作业(1&2&3)这
吴恩达深度学习l2week1编程作业—Regularization（中文跑通版）
na__D的博客
12-26 951
请注意，正则化会影响训练集的性能！这是因为它限制了网络过拟合到训练集的能力。但是，由于它最终提供了更好的测试准确性，它正在帮助您的系统。我们希望您从此笔记本中记住的内容：正则化将帮助您减少过度拟合。规则化会使权重降低。L2正则化和Dropout是两种非常有效的正则化技术。
吴恩达DeepLearning 2023学习目录
女王の专属领地
01-05 989
这个算法将帮助你的模型理解，在给出一系列的输入时，它应该把注意力放在什么地方。这种类型的模型已经被证明在时间数据上表现非常好，它有几个变体，包括 LSTM、GRU 和双向神经网络，本周的课程中也都包括这些内容。使用词向量表示和嵌入层，可以训练在各种行业中表现出色的循环神经网络。理解深度学习中的关键计算，使用它们搭建并训练深层神经网络，并应用在计算机视觉中。学习驱动神经网络兴起的主要技术趋势，了解现今深度学习在哪里应用、如何应用。学习如何用神经网络的思维模式提出机器学习问题、如何使用向量化加速你的模型。
【中文】【吴恩达课后编程作业】Course 4 - 卷积神经网络 - 第一周作业
热门推荐
何宽的博客
10-25 9万+
【中文】【吴恩达课后编程作业】Course 4 - 卷积神经网络 - 第一周作业 - 搭建卷积神经网络模型以及应用（1&2） 上一篇：【课程4 - 第一周测验】※※※※※ 【回到目录】※※※※※下一篇：【课程4 - 第二周测验】 声明   本文参考Kulbear 的【Convolution model - Step by Step 】和【Convolution model ...
吴恩达深度学习l2week2编程作业—Optimization Methods（最新中文跑通版）
na__D的博客
01-06 1679
具有动量的梯度下降通常可以有很好的效果，但由于小的学习速率和简单的数据集所以它的影响几乎是轻微的。另一方面，Adam明显优于小批量梯度下降和具有动量的梯度下降，如果在这个简单的模型上运行更多时间的数据集，这三种方法都会产生非常好的结果，然而，我们已经看到Adam收敛得更快。Adam的一些优点包括相对较低的内存要求（虽然比梯度下降和动量下降更高）和通常运作良好，即使对参数进行微调（除了学习率α）
吴恩达深度学习课程1编程作业
weixin_56368033的博客
08-31 288
吴恩达深度学习课程1编程作业
吴恩达深度学习l2week1编程作业—Initialization
na__D的博客
12-25 1028
您已经尝试了三种不同类型的初始化。
吴恩达 深度学习 编程作业（2-1）- Initialization & Regularization & Gradient Checking
大树先生的博客
09-29 1万+
Part 1：Initialization、Part 2：Regularization、Part 3：Gradient Checking
吴恩达 深度学习 编程作业（5-2）Part 1 - Operations on word vectors
大树先生的博客
03-06 4401
词向量运算——Operations on word vectors：词向量相似度、词向量除偏
吴恩达深度学习课后作业第五周-权重初始化以及正则化
weixin_43606419的博客
02-02 860
init_utils.py 初始化部分的数据集和模型加载都在这个文件内 reg_utils.py 正则化部分的数据集和模型加载都在这个文件内 第一部分：初始化参数 1.1：使用0来初始化参数。 1.2：使用随机数来初始化参数。 1.3：使用抑梯度异常初始化参数（参见视频中的梯度消失和梯度爆炸）。 import numpy as np import matplotlib.pyplot as pl...
吴恩达深度学习课后习题第五课第二周编程作业1:Operations on Word Vectors - Debiasing
weixin_71479720的博客
07-18 395
吴恩达深度学习课后习题第五课第二周编程作业1:Operations on Word Vectors - Debiasing
自助餐剩余食品识别图像分割系统：教学内容全覆盖
sgcsdn99的博客
11-04 1435
数据集信息展示在本研究中，我们使用的数据集名为“9_5_Merged”，该数据集专门用于训练改进YOLOv8-seg的自助餐剩余食品识别图像分割系统。该数据集包含71个类别，涵盖了丰富多样的食品种类，旨在提高模型对不同类型剩余食品的识别和分割能力。通过对这些类别的细致划分，我们希望能够实现更高精度的图像分割，进而优化自助餐剩余食品的管理和利用。
【anaconda】使用记录
最新发布
zhuyan108的博客
11-05 320
window11 下安装anaconda。
Python 类和对象
疯一样的码农
11-04 735
在 Python 中，类是一个对象创建的蓝图。它指定了对象（实例）将具有的属性和方法的集合。类通过封装数据和行为，促进了代码的组织、复用和模块化。使用类可以建模现实世界中的对象，定义其属性，并更有效地控制应用程序的复杂性。在 Python 中，一切都是对象，所有的数据类型和结构都是特定类的实例。对象是类的实例，具有用于修改数据的方法和存储数据的属性。理解对象对于掌握 Python 中的面向对象编程（OOP）范式至关重要。
探索 Python 的新天地：Helium 库揭秘
AIGC搞起
11-04 807
在自动化测试和网页交互的领域，Selenium 是一个强大的工具，但它的复杂性和陡峭的学习曲线让许多开发者望而却步。Helium库的出现，以其简洁的 API 和易用性，为 Python 开发者提供了一个新的选择。它不仅简化了 Selenium 的使用，还自带 WebDriver，减少了配置的复杂性。Helium 以其简洁的 API 和易用性，为 Python 开发者提供了一个强大的 Selenium 替代方案。它不仅减少了代码量，还简化了 WebDriver 的管理，使得自动化测试和网页交互变得更加容易。
01_IAR新建CC2530工程
nanxl1的博客
11-02 1048
由于很多Zigbee商家提供的教程未有从零建立CC2530工程的讲解，可能会导致后面的开发中出现一些琐碎的问题。本文将以**LED流水灯**为例，从0到1用**IAR**建立CC2530工程。
Python小游戏21——拼图小游戏
cxh666888_的博客
11-05 1018
如果图像大小不同，你需要调整tile_size和图像缩放代码。初始化Pygame：使用pygame.init()来初始化Pygame库，这是使用Pygame进行任何游戏开发的第一步。更新屏幕：使用pygame.display.flip()或pygame.display.update()来更新屏幕显示。调整图像大小：使用pygame.transform.scale()来调整图像的大小，以适应拼图游戏的需求。设置屏幕尺寸：使用pygame.display.set_mode()来设置游戏的屏幕尺寸和模式。
吴恩达编程作业线性回归
03-25
可以使用Octave或Matlab编写吴恩达编程作业中的线性回归代码。其中输入数据应该放在矩阵X中，每个样本的特征应该是一行，对应的标签放在向量y中。然后，使用梯度下降算法来最小化代价函数，并更新Theta参数。最后，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值