吴恩达神经网络学习-L2W2作业1

最新推荐文章于 2024-07-25 22:24:14 发布
最新推荐文章于 2024-07-25 22:24:14 发布
阅读量65 收藏
点赞数
分类专栏： 神经网络 文章标签： 神经网络 学习 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MarkAssassin/article/details/133245374
版权 
import numpy as np
import matplotlib.pyplot as plt
import scipy.io
import math
import sklearn
import sklearn.datasets

from opt_utils import load_params_and_grads, initialize_parameters, forward_propagation, backward_propagation
from opt_utils import compute_cost, predict, predict_dec, plot_decision_boundary, load_dataset
from testCases_L2W2 import *

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

#1.梯度下降
#实现梯度下降更新方法。
def update_parameters_with_gd(parameters,grads,learning_rate):
    """
        Update parameters using one step of gradient descent

        Arguments:
        parameters -- python dictionary containing your parameters to be updated:
                        parameters['W' + str(l)] = Wl
                        parameters['b' + str(l)] = bl
        grads -- python dictionary containing your gradients to update each parameters:
                        grads['dW' + str(l)] = dWl
                        grads['db' + str(l)] = dbl
        learning_rate -- the learning rate, scalar.

        Returns:
        parameters -- python dictionary containing your updated parameters
        """
    L=len(parameters)//2

    for l in range(L):
        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)]

    return parameters

parameters, grads, learning_rate=update_parameters_with_gd_test_case()
parameters = update_parameters_with_gd(parameters, grads, learning_rate)
# print("W1 = " + str(parameters["W1"]))
# print("b1 = " + str(parameters["b1"]))
# print("W2 = " + str(parameters["W2"]))
# print("b2 = " + str(parameters["b2"]))

# 它的一种变体是随机梯度下降（SGD），它相当于mini版的批次梯度下降，其中每个mini-batch只有一个数据示例。刚刚实现的更新规则不会更改。
# 不同的是，SGD一次仅在一个训练数据上计算梯度，而不是在整个训练集合上计算梯度。下面的代码示例说明了随机梯度下降和（批量）梯度下降之间的区别。

#(Batch) Gradient Descent:
# X = data_input
# Y = labels
# parameters = initialize_parameters(layers_dims)
# for i in range(0, num_iterations):
#     # Forward propagation
#     a, caches = forward_propagation(X, parameters)
#     # Compute cost.
#     cost = compute_cost(a, Y)
#     # Backward propagation.
#     grads = backward_propagation(a, caches, parameters)
#     # Update parameters.
#     parameters = update_parameters(parameters, grads)

#Stochastic Gradient Descent:
# X = data_input
# Y = labels
# parameters = initialize_parameters(layers_dims)
# for i in range(0, num_iterations):
#     for j in range(0, m):
#         # Forward propagation
#         a, caches = forward_propagation(X[:,j], parameters)
#         # Compute cost
#         cost = compute_cost(a, Y[:,j])
#         # Backward propagation
#         grads = backward_propagation(a, caches, parameters)
#         # Update parameters.
#         parameters = update_parameters(parameters, grads)

# 梯度下降，小批量梯度下降和随机梯度下降之间的差异是用于执行一个更新步骤的数据数量。
# 必须调整超参数学习率
# 在小批量的情况下，通常它会胜过梯度下降或随机梯度下降（尤其是训练集较大时）


#2.Mini-Batch 梯度下降
#学习如何从训练集（X，Y）中构建小批次数据
# 分两个步骤:
# 1.Shuffle：如下所示，创建训练集（X，Y）的随机打乱版本。X和Y中的每一列代表一个训练示例。注意，随机打乱是在X和Y之间同步完成的。
# 这样，在随机打乱之后，X的列就是对应于Y中标签的示例。打乱步骤可确保该示例将随机分为不同小批。
# 2.Partition：将打乱后的（X，Y）划分为大小为mini_batch_size（此处为64）的小批处理。请注意，训练示例的数量并不总是可以被mini_batch_size整除。

#实现random_mini_batches。我们为你编码好了shuffling部分。
# first_mini_batch_X = shuffled_X[:, 0 : mini_batch_size]
# second_mini_batch_X = shuffled_X[:, mini_batch_size : 2 * mini_batch_size]

def random_mini_batches(X,Y,mini_batch_size=64,seed=0):
    np.random.seed(seed)
    m=X.shape[1]
    mini_batches=[]

    # Step 1: Shuffle (X, Y)
    permutation=list(np.random.permutation(m)) #np.random.permutation()：随机排列序列
    shuffled_X=X[:,permutation]
    shuffled_Y=Y[:,permutation].reshape((1,m))

    # Step 2: Partition (shuffled_X, shuffled_Y). Minus the end case.
    num_complete_minibatches=math.floor(m/mini_batch_size) #math.floor(s)代表s向下舍入到最接近的整数
    for k in range(num_complete_minibatches):
        mini_batch_X=shuffled_X[:,k*mini_batch_size:(k+1)*mini_batch_size]
        mini_batch_Y=shuffled_Y[:,k*mini_batch_size:(k+1)*mini_batch_size]
        mini_batch=(mini_batch_X,mini_batch_Y)
        mini_batches.append(mini_batch)

    if m%mini_batch_size!=0:
        mini_batch_X=shuffled_X[:,num_complete_minibatches*mini_batch_size:m]
        mini_batch_Y=shuffled_Y[:,num_complete_minibatches*mini_batch_size:m]
        mini_batch = (mini_batch_X, mini_batch_Y)
        mini_batches.append(mini_batch)

    return mini_batches

X_assess, Y_assess, mini_batch_size = random_mini_batches_test_case()
mini_batches = random_mini_batches(X_assess, Y_assess, mini_batch_size)

# print ("shape of the 1st mini_batch_X: " + str(mini_batches[0][0].shape))
# print ("shape of the 2nd mini_batch_X: " + str(mini_batches[1][0].shape))
# print ("shape of the 3rd mini_batch_X: " + str(mini_batches[2][0].shape))
# print ("shape of the 1st mini_batch_Y: " + str(mini_batches[0][1].shape))
# print ("shape of the 2nd mini_batch_Y: " + str(mini_batches[1][1].shape))
# print ("shape of the 3rd mini_batch_Y: " + str(mini_batches[2][1].shape))
# print ("mini batch sanity check: " + str(mini_batches[0][0][0][0:3]))


#3.Momentum
#初始化速度。速度v是一个Python字典，需要使用零数组进行初始化。它的键与grads词典中的键相同，即：
# v["dW" + str(l+1)] = ... #(numpy array of zeros with the same shape as parameters["W" + str(l+1)])
# v["db" + str(l+1)] = ... #(numpy array of zeros with the same shape as parameters["b" + str(l+1)])

def initialize_velocity(parameters):
    L=len(parameters)//2
    v={}

    for l in range(L):
        v["dW"+str(l+1)]=np.zeros((parameters["W"+str(l+1)].shape[0],parameters["W"+str(l+1)].shape[1]))
        v["db"+str(l+1)]=np.zeros((parameters["b"+str(l+1)].shape[0],parameters["b"+str(l+1)].shape[1]))

    return v

parameters = initialize_velocity_test_case()

v = initialize_velocity(parameters)
# print("v[\"dW1\"] = " + str(v["dW1"]))
# print("v[\"db1\"] = " + str(v["db1"]))
# print("v[\"dW2\"] = " + str(v["dW2"]))
# print("v[\"db2\"] = " + str(v["db2"]))

#实现带冲量的参数更新
#冲量将过去的梯度考虑在内，以平滑梯度下降的步骤。它可以应用于批量梯度下降，小批次梯度下降或随机梯度下降。
def update_parameters_with_momentum(parameters,grads,v,beta,learning_rate):
    L=len(parameters)//2
    for l in range(L):
        v["dW"+str(l+1)]=beta*v["dW"+str(l+1)]+(1-beta)*grads["dW"+str(l+1)]
        v["db"+str(l+1)]=beta*v["db"+str(l+1)]+(1-beta)*grads["db"+str(l+1)]
        parameters["W"+str(l+1)]=parameters["W"+str(l+1)]-learning_rate*v["dW"+str(l+1)]
        parameters["b"+str(l+1)]=parameters["b"+str(l+1)]-learning_rate*v["db"+str(l+1)]

    return parameters,v

parameters, grads, v = update_parameters_with_momentum_test_case()

parameters, v = update_parameters_with_momentum(parameters, grads, v, beta = 0.9, learning_rate = 0.01)
# print("W1 = " + str(parameters["W1"]))
# print("b1 = " + str(parameters["b1"]))
# print("W2 = " + str(parameters["W2"]))
# print("b2 = " + str(parameters["b2"]))
# print("v[\"dW1\"] = " + str(v["dW1"]))
# print("v[\"db1\"] = " + str(v["db1"]))
# print("v[\"dW2\"] = " + str(v["dW2"]))
# print("v[\"db2\"] = " + str(v["db2"]))


#4.Adam
#初始化跟踪过去信息的Adam变量v和s,它们是需要用零数组初始化的python字典。它们的key与grads的key相同，即：
# v["dW" + str(l+1)] = ... #(numpy array of zeros with the same shape as parameters["W" + str(l+1)])
# v["db" + str(l+1)] = ... #(numpy array of zeros with the same shape as parameters["b" + str(l+1)])
# s["dW" + str(l+1)] = ... #(numpy array of zeros with the same shape as parameters["W" + str(l+1)])
# s["db" + str(l+1)] = ... #(numpy array of zeros with the same shape as parameters["b" + str(l+1)])

def initialize_adam(parameters):
    L=len(parameters)//2
    v={}
    s={}

    for l in range(L):
        v["dW"+str(l+1)]=np.zeros((parameters["W"+str(l+1)].shape[0],parameters["W"+str(l+1)].shape[1]))
        v["db" + str(l + 1)] = np.zeros((parameters["b" + str(l + 1)].shape[0], parameters["b" + str(l + 1)].shape[1]))
        s["dW" + str(l + 1)] = np.zeros((parameters["W" + str(l + 1)].shape[0], parameters["W" + str(l + 1)].shape[1]))
        s["db" + str(l + 1)] = np.zeros((parameters["b" + str(l + 1)].shape[0], parameters["b" + str(l + 1)].shape[1]))

    return v,s

parameters = initialize_adam_test_case()

v, s = initialize_adam(parameters)
# print("v[\"dW1\"] = " + str(v["dW1"]))
# print("v[\"db1\"] = " + str(v["db1"]))
# print("v[\"dW2\"] = " + str(v["dW2"]))
# print("v[\"db2\"] = " + str(v["db2"]))
# print("s[\"dW1\"] = " + str(s["dW1"]))
# print("s[\"db1\"] = " + str(s["db1"]))
# print("s[\"dW2\"] = " + str(s["dW2"]))
# print("s[\"db2\"] = " + str(s["db2"]))

def update_parameters_with_adam(parameters,grads,v,s,t,learning_rate=0.01,beta1=0.9,beta2=0.999,epsilon=1e-8):
    """
        Update parameters using Adam

        Arguments:
        parameters -- python dictionary containing your parameters:
                        parameters['W' + str(l)] = Wl
                        parameters['b' + str(l)] = bl
        grads -- python dictionary containing your gradients for each parameters:
                        grads['dW' + str(l)] = dWl
                        grads['db' + str(l)] = dbl
        v -- Adam variable, moving average of the first gradient, python dictionary
        s -- Adam variable, moving average of the squared gradient, python dictionary
        learning_rate -- the learning rate, scalar.
        beta1 -- Exponential decay hyperparameter for the first moment estimates
        beta2 -- Exponential decay hyperparameter for the second moment estimates
        epsilon -- hyperparameter preventing division by zero in Adam updates

        Returns:
        parameters -- python dictionary containing your updated parameters
        v -- Adam variable, moving average of the first gradient, python dictionary
        s -- Adam variable, moving average of the squared gradient, python dictionary
        """
    L=len(parameters)//2
    v_correct={}
    s_correct={}

    for l in range(L):
        v["dW"+str(l+1)]=beta1*v["dW"+str(l+1)]+(1-beta1)*grads["dW"+str(l+1)]
        v["db"+str(l+1)]=beta1*v["db"+str(l+1)]+(1-beta1)*grads["db"+str(l+1)]
        s["dW" + str(l + 1)] = beta2 * s["dW" + str(l + 1)] + (1 - beta2) * (grads["dW" + str(l + 1)]**2)
        s["db" + str(l + 1)] = beta2 * s["db" + str(l + 1)] + (1 - beta2) * (grads["db" + str(l + 1)]**2)

        v_correct["dW"+str(l+1)]=v["dW"+str(l+1)]/(1-beta1**t)
        v_correct["db" + str(l + 1)] = v["db" + str(l + 1)] / (1 - beta1 ** t)
        s_correct["dW"+str(l+1)]=s["dW" + str(l + 1)]/(1-beta2**t)
        s_correct["db" + str(l + 1)] = s["db" + str(l + 1)] / (1 - beta2 ** t)

        parameters["W"+str(l+1)]=parameters["W"+str(l+1)]-learning_rate*v_correct["dW"+str(l+1)]/(np.sqrt(s_correct["dW"+str(l+1)]+epsilon))
        parameters["b"+str(l+1)]=parameters["b"+str(l+1)]-learning_rate*v_correct["db"+str(l+1)]/(np.sqrt(s_correct["db"+str(l+1)]+epsilon))

    return parameters,v,s

parameters, grads, v, s = update_parameters_with_adam_test_case()
parameters, v, s = update_parameters_with_adam(parameters, grads, v, s, t=2)

# print("W1 = " + str(parameters["W1"]))
# print("b1 = " + str(parameters["b1"]))
# print("W2 = " + str(parameters["W2"]))
# print("b2 = " + str(parameters["b2"]))
# print("v[\"dW1\"] = " + str(v["dW1"]))
# print("v[\"db1\"] = " + str(v["db1"]))
# print("v[\"dW2\"] = " + str(v["dW2"]))
# print("v[\"db2\"] = " + str(v["db2"]))
# print("s[\"dW1\"] = " + str(s["dW1"]))
# print("s[\"db1\"] = " + str(s["db1"]))
# print("s[\"dW2\"] = " + str(s["dW2"]))
# print("s[\"db2\"] = " + str(s["db2"]))


#5.不同优化算法的模型
train_X, train_Y = load_dataset()
plt.show()

# 我们已经实现了一个三层的神经网络。你将使用以下方法进行训练：
#
# 小批次 Gradient Descent:它将调用你的函数：
#      - update_parameters_with_gd（）
# 小批次 冲量：它将调用你的函数：
#      - initialize_velocity（）和update_parameters_with_momentum（）
# 小批次 Adam：它将调用你的函数：
#      - initialize_adam（）和update_parameters_with_adam（）

def model(X,Y,layer_dims,optimizer,learning_rate=0.0007,mini_batch_size=64
          ,beta=0.9,beta1=0.9,beta2=0.999,epsilon=1e-8,num_epochs=10000,print_cost=True):
    """
        3-layer neural network model which can be run in different optimizer modes.

        Arguments:
        X -- input data, of shape (2, number of examples)
        Y -- true "label" vector (1 for blue dot / 0 for red dot), of shape (1, number of examples)
        layers_dims -- python list, containing the size of each layer
        learning_rate -- the learning rate, scalar.
        mini_batch_size -- the size of a mini batch
        beta -- Momentum hyperparameter
        beta1 -- Exponential decay hyperparameter for the past gradients estimates
        beta2 -- Exponential decay hyperparameter for the past squared gradients estimates
        epsilon -- hyperparameter preventing division by zero in Adam updates
        num_epochs -- number of epochs
        print_cost -- True to print the cost every 1000 epochs

        Returns:
        parameters -- python dictionary containing your updated parameters
        """

    L=len(layer_dims)
    costs=[]
    t=0
    seed=10

    parameters=initialize_parameters(layer_dims)

    if optimizer=="gd":
        pass
    elif optimizer=="momentum":
        v=initialize_velocity(parameters)
    elif optimizer=="adam":
        v,s=initialize_adam(parameters)

    for i in range(num_epochs):
        seed+=1
        mini_batches = random_mini_batches(X, Y, mini_batch_size, seed)

        for (batch_X,batch_Y) in mini_batches:
            a3,cache=forward_propagation(batch_X,parameters)
            cost=compute_cost(a3,batch_Y)
            grads=backward_propagation(batch_X,batch_Y,cache)

            if optimizer=="gd":
                parameters=update_parameters_with_gd(parameters,grads,learning_rate)
            elif optimizer=="momentum":
                parameters,v=update_parameters_with_momentum(parameters,grads,v,beta,learning_rate)
            elif optimizer=="adam":
                t+=1 # Adam counter
                parameters,v,s=update_parameters_with_adam(parameters,grads,v,s,t,learning_rate,beta1,beta2,epsilon)

        if print_cost and i % 100 == 0:
            print("Cost after iteration %i: %f" % (i, cost))
        if print_cost and i % 100 == 0:
            costs.append(cost)

    plt.plot(costs)
    plt.ylabel('cost')
    plt.xlabel('epochs (per 100)')
    plt.title("Learning rate = " + str(learning_rate))
    plt.show()

    return parameters

#5.1小批量梯度下降
# train 3-layer model
layers_dims = [train_X.shape[0], 5, 2, 1]
parameters = model(train_X, train_Y, layers_dims, optimizer = "gd")
# Predict
predictions = predict(train_X, train_Y, parameters)
# Plot decision boundary
plt.title("Model with Gradient Descent optimization")
axes = plt.gca()
axes.set_xlim([-1.5,2.5])
axes.set_ylim([-1,1.5])
plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X, train_Y)

#5.2 带冲量的小批量梯度下降
# train 3-layer model
layers_dims = [train_X.shape[0], 5, 2, 1]
parameters = model(train_X, train_Y, layers_dims, beta = 0.9, optimizer = "momentum")
# Predict
predictions = predict(train_X, train_Y, parameters)
# Plot decision boundary
plt.title("Model with Momentum optimization")
axes = plt.gca()
axes.set_xlim([-1.5,2.5])
axes.set_ylim([-1,1.5])
plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X, train_Y)

#5.3 Adam模式的小批量梯度下降
# train 3-layer model
layers_dims = [train_X.shape[0], 5, 2, 1]
parameters = model(train_X, train_Y, layers_dims, optimizer = "adam")
# Predict
predictions = predict(train_X, train_Y, parameters)
# Plot decision boundary
plt.title("Model with Adam optimization")
axes = plt.gca()
axes.set_xlim([-1.5,2.5])
axes.set_ylim([-1,1.5])
plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X, train_Y)

# Adam的优势包括：
# 相对较低的内存要求（尽管高于梯度下降和带冲量的梯度下降）
# 即使很少调整超参数，通常也能很好地工作

MarkAssassin
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
吴恩达深度学习2-Week3课后作业-Tensorflow
Apple_hzc的博客
11-03 923
一、Deeplearning-assignment 到目前为止，我们一直使用numpy来建立神经网络。这次作业将深入学习框架，可以更容易地建立神经网络。 TensorFlow，PaddlePaddle，Torch，Caffe，Keras等机器学习框架可以显著地加速机器学习开发。这些框架有很多文档，可以随意阅读。在本次任务中，将学习如何在TensorFlow中执行以下操作： 初始化变量 开始...
吴恩达-深度学习-课后作业-答案与总结
05-17
资源名称：人工智能+物理神经网络+利用物理信息神经网络和断层带声学监测预测实验室地震+源码 资源描述：【项目资源】：汇聚了云计算、区块链、网络安全、前端设计、后端架构、UI/UX设计、游戏开发、移动应用开发、...
2020-10-30 从0学习ctf (2)
weixin_45871770的博客
10-30 156
Python3 基础语法 编码 默认情况下，Python 3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串。 当然你也可以为源码文件指定不同的编码： # -*- coding: cp-1252 -*- 标识符 第一个字符必须是字母表中字母或下划线 _ 。 标识符的其他的部分由字母、数字和下划线组成。 标识符对大小写敏感。 在 Python 3 中，可以用中文作为变量名，非 ASCII 标识符也是允许的了。 python保留字 保留字即关键字，我们不能把它们用作任何标识符名称。Pyth
吴恩达神经网络学习-L2W1作业1
MarkAssassin的博客
09-24 55
【代码】吴恩达神经网络学习-L2W1作业1。
吴恩达神经网络学习-L2W3作业1
MarkAssassin的博客
09-24 121
【代码】吴恩达神经网络学习-L2W3作业1。
吴恩达神经网络学习-L2W1作业2
MarkAssassin的博客
09-24 147
【代码】吴恩达神经网络学习-L2W1作业2。
吴恩达神经网络学习-L2W1作业3
MarkAssassin的博客
09-24 59
【代码】吴恩达神经网络学习-L2W1作业3。
【深度学习-吴恩达】L2-2 优化算法 作业
u011315681的博客
08-03 371
【深度学习-吴恩达】L2-2 优化算法 作业笔记
吴恩达神经网络学习编程作业L1W2作业1
MarkAssassin的博客
09-14 61
【代码】吴恩达神经网络学习编程作业L1W2作业1。
pytorch入门：吴恩达Course 2-改善深层神经网络-week3作业 pytorch版
深度学习迭代中
02-24 3040
最后本地测试的图片来源于百度及这位大佬，他写了这份作业的Tensorflow版https://blog.csdn.net/u013733326/article/details/79971488 tensorflow实在有点用不来，所以入pytorch的坑了。。 以下文件的【下载地址】，提取码53lw C:. │ ex6 pytorch.py │ tf_utils.py │ ├─datase...
【深度学习-吴恩达】L1-3 浅层神经网络 作业
07-29
在这个"【深度学习-吴恩达】L1-3 浅层神经网络 作业"中，我们将关注三个核心概念：神经网络的基础、前向传播以及反向传播算法。 首先，神经网络是一种模仿人脑神经元结构的计算模型，由大量的节点（称为神经元）和...
【深度学习-吴恩达】L1-2 神经网络基础 作业
07-29
在本课程"深度学习-吴恩达"的L1-2部分，主要讲解了神经网络的基础知识，并提供了相应的作业以帮助学生巩固理解。这个压缩包包含以下内容： 1. **datasets文件夹**：通常，这个文件夹包含了用于训练和测试神经网络...
【深度学习-吴恩达】L1-4 深层神经网络 作业
07-29
在本课程中，"【深度学习-吴恩达】L1-4 深层神经网络 作业"，我们将深入探讨深度学习的基础及其在实际应用中的实现。吴恩达是机器学习领域的知名专家，他在Coursera上的深度学习专项课程深受全球学员喜爱。这部分...
吴恩达老师深度学习作业 L2W3-TensorFlow教程
11-21
在本课程“吴恩达老师深度学习作业 L2W3-TensorFlow教程”中，我们将深入探讨使用TensorFlow这一强大的开源库进行深度学习的基本概念和实践。TensorFlow是由Google Brain团队开发的一个平台，广泛用于机器学习和人工...
认识神经网络【多层感知器数学原理】
逐梦苍穹的博客
07-24 1241
简单认识神经网络，学习多层感知器的数学原理和公式
Python编程学习第一篇——Python零基础快速入门（六）（4）异常处理
urhero的专栏
07-25 382
我们已经了解了Python的基本数据类型、变量和基本的逻辑控制语句，基于这些基础知识可以编写一些小程序了，但是在写程序的时候我们会发现，有时候程序并不是按我们预期的方向执行，有的直接报错，有的没有报错，却并未得到我们预期的结果。在这个例子中，除数为0会引发ZeroDivisionError异常，我们将异常信息赋值给变量e，并输出"除数不能为0"和异常信息。在这个例子中，由于除数不为0，所以没有发生ZeroDivisionError异常，代码会执行else语句块，并输出结果2.0。
AvaloniaUI的学习
最新发布
lishuangquan1987的博客
07-25 940
官方中文文档：https://docs.avaloniaui.net/zh-Hans/docs/welcome。
学习日志：JVM垃圾回收
weixin_46117680的博客
07-23 1030
当需要排查各种内存溢出问题、当垃圾收集成为系统达到更高并发的瓶颈时，我们就需要对这些“自动化”的技术实施必要的监控和调节。可达性算法中描述的对象引用，一般指的是强引用，即是GCRoot对象对普通对象有引用关系，只要这层关系存在普通对象就不会被回收。
吴恩达-深度学习-改善深层神经网络
04-04
吴恩达在改善深层神经网络方面提出了多种方法，包括： 1. 激活函数：使用ReLU（Rectified Linear Unit）代替传统的sigmoid函数，可以加速训练过程并提高准确率。 2. 正则化：使用L1或L2正则化，可以防止过拟合，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值