DeepLearning AI (1-4-1)

最新推荐文章于 2024-07-05 13:45:41 发布
最新推荐文章于 2024-07-05 13:45:41 发布
阅读量174 收藏
点赞数
文章标签： python 深度学习 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36028321/article/details/118931687
版权

Building your Deep Neural Network Step by Step
在这里插入图片描述
在这里插入图片描述

#packages
import numpy as np
import h5py
import matplotlib.pyplot as plt
from testCases import *
from dnn_utils import sigmoid, sigmoid_backward, relu, relu_backward
from public_tests import *

%matplotlib inline
plt.rcParams['figure.figsize'] = (5.0, 4.0) # set default size of plots
plt.rcParams['image.interpolation'] = 'nearest'
plt.rcParams['image.cmap'] = 'gray'

%load_ext autoreload
%autoreload 2

np.random.seed(1)



def initialize_parameters(n_x, n_h, n_y):
    """
    Argument:
    n_x -- size of the input layer
    n_h -- size of the hidden layer
    n_y -- size of the output layer
    
    Returns:
    parameters -- python dictionary containing your parameters:
                    W1 -- weight matrix of shape (n_h, n_x)
                    b1 -- bias vector of shape (n_h, 1)
                    W2 -- weight matrix of shape (n_y, n_h)
                    b2 -- bias vector of shape (n_y, 1)
    """
    
    np.random.seed(1)
    
    #(≈ 4 lines of code)
    # W1 = ...
    # b1 = ...
    # W2 = ...
    # b2 = ...
    # YOUR CODE STARTS HERE
    W1=np.random.randn(n_h,n_x)*0.01
    b1=np.zeros((n_h,1))
    W2=np.random.randn(n_y,n_h)*0.01
    b2=np.zeros((n_y,1))
    # YOUR CODE ENDS HERE
    
    parameters = {"W1": W1,
                  "b1": b1,
                  "W2": W2,
                  "b2": b2}
    
    return parameters    

def initialize_parameters_deep(layer_dims):
    """
    Arguments:
    layer_dims -- python array (list) containing the dimensions of each layer in our network
    
    Returns:
    parameters -- python dictionary containing your parameters "W1", "b1", ..., "WL", "bL":
                    Wl -- weight matrix of shape (layer_dims[l], layer_dims[l-1])
                    bl -- bias vector of shape (layer_dims[l], 1)
    """
    
    np.random.seed(3)
    parameters = {}
    L = len(layer_dims) # number of layers in the network

    for l in range(1, L):
        #(≈ 2 lines of code)
        # parameters['W' + str(l)] = ...
        # parameters['b' + str(l)] = ...
        # YOUR CODE STARTS HERE
        parameters['W' + str(l)]=np.random.randn(layer_dims[l], layer_dims[l-1])*0.01
        parameters['b' + str(l)]=np.zeros((layer_dims[l],1))
        
        # YOUR CODE ENDS HERE
        
        assert(parameters['W' + str(l)].shape == (layer_dims[l], layer_dims[l - 1]))
        assert(parameters['b' + str(l)].shape == (layer_dims[l], 1))

        
    return parameters

def linear_forward(A, W, b):
    """
    Implement the linear part of a layer's forward propagation.

    Arguments:
    A -- activations from previous layer (or input data): (size of previous layer, number of examples)
    W -- weights matrix: numpy array of shape (size of current layer, size of previous layer)
    b -- bias vector, numpy array of shape (size of the current layer, 1)

    Returns:
    Z -- the input of the activation function, also called pre-activation parameter 
    cache -- a python tuple containing "A", "W" and "b" ; stored for computing the backward pass efficiently
    """
    
    #(≈ 1 line of code)
    # Z = ...
    # YOUR CODE STARTS HERE
    Z=np.dot(W,A)+b
    
    # YOUR CODE ENDS HERE
    cache = (A, W, b)
    
    return Z, cache

def linear_activation_forward(A_prev, W, b, activation):
    """
    Implement the forward propagation for the LINEAR->ACTIVATION layer

    Arguments:
    A_prev -- activations from previous layer (or input data): (size of previous layer, number of examples)
    W -- weights matrix: numpy array of shape (size of current layer, size of previous layer)
    b -- bias vector, numpy array of shape (size of the current layer, 1)
    activation -- the activation to be used in this layer, stored as a text string: "sigmoid" or "relu"

    Returns:
    A -- the output of the activation function, also called the post-activation value 
    cache -- a python tuple containing "linear_cache" and "activation_cache";
             stored for computing the backward pass efficiently
    """
    
    if activation == "sigmoid":
        #(≈ 2 lines of code)
        # Z, linear_cache = ...
        # A, activation_cache = ...
        # YOUR CODE STARTS HERE
        Z,linear_cache=linear_forward(A_prev, W, b)
        A,activation_cache=sigmoid(Z)
        # YOUR CODE ENDS HERE
    
    elif activation == "relu":
        #(≈ 2 lines of code)
        # Z, linear_cache = ...
        # A, activation_cache = ...
        # YOUR CODE STARTS HERE
        Z,linear_cache=linear_forward(A_prev, W, b)
        A,activation_cache=relu(Z)
        # YOUR CODE ENDS HERE
    cache = (linear_cache, activation_cache)

    return A, cache

def L_model_forward(X, parameters):
    """
    Implement forward propagation for the [LINEAR->RELU]*(L-1)->LINEAR->SIGMOID computation
    
    Arguments:
    X -- data, numpy array of shape (input size, number of examples)
    parameters -- output of initialize_parameters_deep()
    
    Returns:
    AL -- activation value from the output (last) layer
    caches -- list of caches containing:
                every cache of linear_activation_forward() (there are L of them, indexed from 0 to L-1)
    """

    caches = []
    A = X
    L = len(parameters) // 2                  # number of layers in the neural network
    
    # Implement [LINEAR -> RELU]*(L-1). Add "cache" to the "caches" list.
    # The for loop starts at 1 because layer 0 is the input
    for l in range(1, L):
        A_prev = A 
        #(≈ 2 lines of code)
        # A, cache = ...
        # caches ...
        # YOUR CODE STARTS HERE
        A, cache = linear_activation_forward(A_prev, parameters['W' + str(l)], parameters['b' + str(l)], "relu")
        caches.append(cache)
        # YOUR CODE ENDS HERE
    
    # Implement LINEAR -> SIGMOID. Add "cache" to the "caches" list.
    #(≈ 2 lines of code)
    # AL, cache = ...
    # caches ...
    # YOUR CODE STARTS HERE
    AL, cache = linear_activation_forward(A, parameters['W' + str(L)], parameters['b' + str(L)], "sigmoid")
    caches.append(cache)
  
    # YOUR CODE ENDS HERE
          
    return AL, caches

def compute_cost(AL, Y):
    """
    Implement the cost function defined by equation (7).

    Arguments:
    AL -- probability vector corresponding to your label predictions, shape (1, number of examples)
    Y -- true "label" vector (for example: containing 0 if non-cat, 1 if cat), shape (1, number of examples)

    Returns:
    cost -- cross-entropy cost
    """
    
    m = Y.shape[1]

    # Compute loss from aL and y.
    # (≈ 1 lines of code)
    # cost = ...
    # YOUR CODE STARTS HERE
    
    cost=-1/m*np.sum(Y*np.log(AL)+(1-Y)*np.log(1-AL))
    
    # YOUR CODE ENDS HERE
    
    cost = np.squeeze(cost)      # To make sure your cost's shape is what we expect (e.g. this turns [[17]] into 17).

    
    return cost

def linear_backward(dZ, cache):
    """
    Implement the linear portion of backward propagation for a single layer (layer l)

    Arguments:
    dZ -- Gradient of the cost with respect to the linear output (of current layer l)
    cache -- tuple of values (A_prev, W, b) coming from the forward propagation in the current layer

    Returns:
    dA_prev -- Gradient of the cost with respect to the activation (of the previous layer l-1), same shape as A_prev
    dW -- Gradient of the cost with respect to W (current layer l), same shape as W
    db -- Gradient of the cost with respect to b (current layer l), same shape as b
    """
    A_prev, W, b = cache
    m = A_prev.shape[1]

    ### START CODE HERE ### (≈ 3 lines of code)
    # dW = ...
    # db = ... sum by the rows of dZ with keepdims=True
    # dA_prev = ...
    # YOUR CODE STARTS HERE
    dW=1/m*np.dot(dZ,A_prev.T)
    db=np.sum(dZ,axis=1,keepdims=True)/m
    dA_prev=np.dot(W.T,dZ)
    # YOUR CODE ENDS HERE
    
    return dA_prev, dW, db

def linear_activation_backward(dA, cache, activation):
    """
    Implement the backward propagation for the LINEAR->ACTIVATION layer.
    
    Arguments:
    dA -- post-activation gradient for current layer l 
    cache -- tuple of values (linear_cache, activation_cache) we store for computing backward propagation efficiently
    activation -- the activation to be used in this layer, stored as a text string: "sigmoid" or "relu"
    
    Returns:
    dA_prev -- Gradient of the cost with respect to the activation (of the previous layer l-1), same shape as A_prev
    dW -- Gradient of the cost with respect to W (current layer l), same shape as W
    db -- Gradient of the cost with respect to b (current layer l), same shape as b
    """
    linear_cache, activation_cache = cache
    
    if activation == "relu":
        #(≈ 2 lines of code)
        # dZ =  ...
        # dA_prev, dW, db =  ...
        # YOUR CODE STARTS HERE
        dZ=relu_backward(dA, activation_cache)
        dA_prev, dW, db=linear_backward(dZ, linear_cache)
        # YOUR CODE ENDS HERE
        
    elif activation == "sigmoid":
        #(≈ 2 lines of code)
        # dZ =  ...
        # dA_prev, dW, db =  ...
        # YOUR CODE STARTS HERE
        dZ=sigmoid_backward(dA, activation_cache)
        dA_prev, dW, db=linear_backward(dZ, linear_cache)
        
        # YOUR CODE ENDS HERE
    
    return dA_prev, dW, db

def L_model_backward(AL, Y, caches):
    """
    Implement the backward propagation for the [LINEAR->RELU] * (L-1) -> LINEAR -> SIGMOID group
    
    Arguments:
    AL -- probability vector, output of the forward propagation (L_model_forward())
    Y -- true "label" vector (containing 0 if non-cat, 1 if cat)
    caches -- list of caches containing:
                every cache of linear_activation_forward() with "relu" (it's caches[l], for l in range(L-1) i.e l = 0...L-2)
                the cache of linear_activation_forward() with "sigmoid" (it's caches[L-1])
    
    Returns:
    grads -- A dictionary with the gradients
             grads["dA" + str(l)] = ... 
             grads["dW" + str(l)] = ...
             grads["db" + str(l)] = ... 
    """
    grads = {}
    L = len(caches) # the number of layers
    m = AL.shape[1]
    Y = Y.reshape(AL.shape) # after this line, Y is the same shape as AL
    
    # Initializing the backpropagation
    #(1 line of code)
    # dAL = ...
    # YOUR CODE STARTS HERE
    dAL=-np.divide(Y,AL)+np.divide((1-Y),(1-AL))
    
    # YOUR CODE ENDS HERE
    
    # Lth layer (SIGMOID -> LINEAR) gradients. Inputs: "dAL, current_cache". Outputs: "grads["dAL-1"], grads["dWL"], grads["dbL"]
    #(approx. 5 lines)
    # current_cache = ...
    # dA_prev_temp, dW_temp, db_temp = ...
    # grads["dA" + str(L-1)] = ...
    # grads["dW" + str(L)] = ...
    # grads["db" + str(L)] = ...
    # YOUR CODE STARTS HERE
    current_cache=caches[L-1]
    dA_prev_temp, dW_temp, db_temp =linear_activation_backward(dAL,current_cache,"sigmoid")
    grads["dA" + str(L-1)]=dA_prev_temp
    grads["dW" + str(L)] =dW_temp
    grads["db" + str(L)]=db_temp
    # YOUR CODE ENDS HERE
    
    # Loop from l=L-2 to l=0
    for l in reversed(range(L-1)):
        # lth layer: (RELU -> LINEAR) gradients.
        # Inputs: "grads["dA" + str(l + 1)], current_cache". Outputs: "grads["dA" + str(l)] , grads["dW" + str(l + 1)] , grads["db" + str(l + 1)] 
        #(approx. 5 lines)
        # current_cache = ...
        # dA_prev_temp, dW_temp, db_temp = ...
        # grads["dA" + str(l)] = ...
        # grads["dW" + str(l + 1)] = ...
        # grads["db" + str(l + 1)] = ...
        # YOUR CODE STARTS HERE
        current_cache=caches[l]
        dA_prev_temp, dW_temp, db_temp =linear_activation_backward(dA_prev_temp,current_cache,"relu")
        grads["dA" + str(l)]=dA_prev_temp
        grads["dW" + str(l+1)] =dW_temp
        grads["db" + str(l+1)]=db_temp
        
        
        # YOUR CODE ENDS HERE

    return grads

def update_parameters(params, grads, learning_rate):
    """
    Update parameters using gradient descent
    
    Arguments:
    params -- python dictionary containing your parameters 
    grads -- python dictionary containing your gradients, output of L_model_backward
    
    Returns:
    parameters -- python dictionary containing your updated parameters 
                  parameters["W" + str(l)] = ... 
                  parameters["b" + str(l)] = ...
    """
    parameters = params.copy()
    L = len(parameters) // 2 # number of layers in the neural network

    # Update rule for each parameter. Use a for loop.
    #(≈ 2 lines of code)
    for l in range(L):
        # parameters["W" + str(l+1)] = ...
        # parameters["b" + str(l+1)] = ...
        # YOUR CODE STARTS HERE
        parameters["W" + str(l+1)] = parameters["W" + str(l+1)]-learning_rate*grads["dW"+str(l+1)]
        parameters["b" + str(l+1)] = parameters["b" + str(l+1)]-learning_rate*grads["db"+str(l+1)]
        
        # YOUR CODE ENDS HERE
    return parameters
想改行的林
关注
多隐层神经网络
Harder_14的博客
09-11 878
多隐层神经网络步骤： 1.定义网络结构，初始化，包括参数和隐藏层数和单元数 def initialize_parameters_deep(layer_dims): """ Arguments: layer_dims -- python array (list) containing the dimensions of each layer in our network Returns: parameters -- python ...
Deep Leaning 学习笔记之神经网络（4）—— 多隐藏层神经网络
Mr.Zhang的笔记本
07-03 3719
1 预备函数 1.1 初始化参数 # GRADED FUNCTION: initialize_parameters_deep def initialize_parameters_deep(layer_dims): """ Arguments: layer_dims -- python array (list) containing the dimensions of ea...
【DeepLearning.ai实验笔记】课程1-week4：多隐藏层神经网络搭建
朱砂绛的博客
03-09 1309
构建多层网络
人工神经网络，支持任意数量隐藏层，多层隐藏层，python代码分享
weixin_30410119的博客
09-05 501
　　http://www.cnblogs.com/bambipai/p/7922981.html------误差逆传播算法讲解 　　人工神经网络包含多种不同的神经网络，此处的代码建立的是多层感知器网络，代码以《集体智慧编程》第四章 “nn.py" 为原型和框架，可以指定隐藏网络的层数和每层的节点数，利用反向传播法修正权值，并连接数据库，保存每层每个节点的权值等信息。代码在算法方面并没有做出改进，...
【深层神经网络】深度学习专项课程学习记录3——多隐藏层神经网络解决图像二分类问题
m0_46314771的博客
06-24 511
本文记录了笔者学习多层神经网络用于解决二分类问题的过程。
deeplearning-ai-books-深度学习资源包
05-10
深度学习（Deep Learning，简称DL）是机器学习（Machine Learning，简称ML）的一个子集，也是人工智能（Artificial Intelligence，简称AI）领域的一个重要分支。它被引入机器学习，旨在使机器更接近于实现人工智能的...
cn-deep-learning-vs-machine-learning-ebook(1).pdf
09-20
人工智能（AI）是让机器模拟人类智能行为的技术；机器学习（Machine Learning）是让机器通过统计方法从数据中学习任务的技术；而深度学习（Deep Learning）是机器学习的一个子集，它通过构建具有许多层次的神经网络...
deeplearning.ai-andrewNG-master.zip
10-04
《吴恩达深度学习课后作业完整版》是深度学习领域的宝贵资源，它包含了由著名计算机科学家吴恩达（Andrew Ng）在deeplearning.ai课程中的全套作业。这个压缩包"deeplearning.ai-andrewNG-master.zip"是学习者深入...
deeplearning.ai-coursera：deeplearning.ai-coursera，吴安德
02-04
deeplearning.ai-coursera deeplearning.ai-coursera，安德鲁·伍（Andrew Ng） 中文： 英语： 说明 1.本存储库包含自己做的答案，是为了学习交流，希望不要另做他用！（注：windows7 + 64位+ Anaconda3环境下调试...
Deep-Q-Learning-Deep-SARSA-LunarLander-v2:将深度强化学习算法Deep SARSA和Deep Q-Learning应用于OpenAI Gym的LunarLander-v2
03-19
在这个项目中，我试图从OpenAI体育馆解决Lunar Lander环境。这是一个二维环境，其目的是教导登月舱模块安全地着陆在固定在点（0,0）的着陆垫上。该代理具有3个推进器：一个在模块的底部，另一个在模块的每一侧。因此...
双，多隐含层BP神经网络预测代码，多数入单输出，MATLAB程序。 修改好的程序，注释清
最新发布
XzlxNzwghe的博客
07-05 287
在代码实现方面，我们使用MATLAB作为编程工具，利用其强大的矩阵运算功能和友好的用户界面，轻松实现双、多隐含层BP神经网络预测代码。首先，我们需要构建神经网络的结构，确定输入层、隐含层和输出层的节点数，并初始化隐含层和输出层的权重矩阵。然后，我们可以通过循环迭代的方式，不断更新权重矩阵，使得网络的预测结果与实际数值之间的误差不断减小，直到达到收敛的条件为止。总结起来，双、多隐含层BP神经网络预测代码在MATLAB中的实现，可以对各行各业中的数据预测和分析问题提供有效的解决方案。
神经网络
Sunning
08-02 794
目录 1、神经元模型 2、感知机与多层网络 3、BP神经网络算法 4、 全局最小与局部最小 5、 深度学习 在机器学习中，神经网络一般指的是“神经网络学习”，是机器学习与神经网络两个学科的交叉部分，是另一个经典的监督学习算法。所谓神经网络，目前用得最广泛的一个定义是“神经网络是由具有适应性（这里的适应性主要指权重和阈值的自动确定，即学习）的简单单元组成的广泛并行互连（某神经元，1与同层...
神经网络为什么要加深层（隐藏层）？
weixin_44943389的博客
10-11 605
总的来说，深度网络的加深可以使得网络学习到更加复杂的特征和模式，从而提高了模型的表现能力，但也需要仔细地进行设计和训练以克服深度学习中可能遇到的问题。例如，对于图像识别任务，低层次的特征可能是边缘和纹理，而高层次的特征可能是物体的部件或整体。：深层网络可以用更少的参数来表示复杂的函数，相对于一个相同规模的单层网络。通过增加隐藏层，网络可以学习到更加抽象和复杂的特征，从而提升了模型的表达能力。：深度网络可以学习到特征的层次性表示，每一层的输出都可以看作是前一层的输入的一种抽象。
深度学习隐藏层神经网络工作
赵广陆
12-06 2246
目录 1 神经网络拟合复杂函数 2 隐藏层介绍 3 代码实现 1 神经网络拟合复杂函数 大自然总是变化莫测，小蓝所在海底的生物们也经历了巨大的进化，豆豆的毒性与大小关系变得不再那么的简单，想要预测他们，只能靠一些不那么单调的函数：机器学习的局限性
为什么要叠多层的隐藏层
bolite的博客
08-01 319
笔记
【机器学习300问】72、神经网络的隐藏层数量和各层神经元节点数如何影响模型的表现？
qq_39780701的博客
04-17 2880
评估深度学习的模型的性能依旧可以用偏差和方差来衡量。它们反映了模型在预测过程中与理想情况的偏离程度，以及模型对数据扰动的敏感性。我们简单回顾一下什么是模型的偏差和方差？神经网络的深度和节点数对模型性能有何影响？
多个隐藏层深度神经网络的构建
OneForPlus的博客
01-09 531
多个隐藏层深度神经网络的构建
吴恩达深度学习deeplearning.ai——第一门课：神经网络与深度学习——第二节：神经网络基础（上）
weixin_43895667的博客
08-03 2000
吴恩达深度学习deeplearning.ai——第一门课：神经网络与深度学习——第二节：神经网络基础（上）
Deeplearning.ai - 浅层神经网络
Sunlight的博客
03-20 351
神经网络和深度学习 吴恩达 Andrew Ng 浅层神经网络 神经网络概览 神经网络表示 输入层a[0]a[0]a^{[0]}、隐藏层a[1]a[1]a^{[1]}、输出层a[2]a[2]a^{[2]} 多个逻辑回归的叠加 计算神经网络的输出 将各个元素竖向叠加起来构成一个大矩阵 向量化计算 各个矩阵的大小 多个样本的向量化 圆括...
deep-learning-in-phm
07-07
与传统的基于规则的方法相比，Deep Learning不需要人工定义特征和规则，能够更好地适应不同设备和系统的特征。 通过Deep Learning，PHM可以实现更可靠的故障预测和诊断，提高设备和系统的可用性和效率。例如，在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值