首页 > 编程语言 >10 对比不同的优化算法

10 对比不同的优化算法

时间：2023-10-07 09:27:34浏览次数：46  
标签：10 parameters mini batch 算法 train 参数 str 对比 

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 import *

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

主要用于导入必要的库和设置一些绘图参数。

  1. import numpy as np：导入NumPy库，并将其重命名为np，以便在代码中使用更短的别名引用它。

  2. import matplotlib.pyplot as plt：导入Matplotlib库，并将其重命名为plt，以便在代码中使用更短的别名引用它。

  3. import scipy.io：导入SciPy库，用于处理科学计算中的各种任务，包括加载和保存数据。

  4. import math：导入Python的数学库，用于执行数学运算。

  5. import sklearn：导入scikit-learn库，它是一个机器学习库，提供了许多用于机器学习和数据挖掘的工具和算法。

  6. import sklearn.datasets：导入scikit-learn的datasets模块，用于加载示例数据集。

  7. from opt_utils import ...：从名为opt_utils的模块中导入一些函数和类。这些函数和类用于优化算法的实现，如参数初始化、前向传播、反向传播、成本计算、预测等。

  8. %matplotlib inline：这是一个Jupyter Notebook的魔法命令，用于在Notebook中显示Matplotlib生成的图形。

  9. plt.rcParams['figure.figsize'] = (7.0, 4.0)：设置Matplotlib图形的默认大小为宽度7.0和高度4.0。

  10. plt.rcParams['image.interpolation'] = 'nearest'：设置Matplotlib图像的插值方式为"nearest"，这意味着图像以最接近邻居的方式显示，通常用于显示像素化的图像。

  11. plt.rcParams['image.cmap'] = 'gray'：设置Matplotlib图像的颜色映射为灰度，这意味着图像将以黑白灰度显示。

这段代码的目的是为了准备必要的工具和环境，以便在接下来的代码中执行机器学习任务。

def update_parameters_with_gd(parameters, grads, learning_rate):
 
    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

这段代码实现了一个梯度下降（Gradient Descent）算法，用于更新神经网络的参数。以下是对代码的详细解释：

  1. def update_parameters_with_gd(parameters, grads, learning_rate):：这是一个Python函数的定义，名称为update_parameters_with_gd，接受三个参数：parameters（神经网络的参数），grads（梯度，即参数的变化率），和learning_rate（学习率，用于控制参数更新的步长）。

  2. L = len(parameters) // 2：计算神经网络的层数（L），这是通过parameters字典的长度除以2得到的。parameters字典通常包含权重（W）和偏置（b）参数。

  3. for l in range(L):：使用一个循环迭代神经网络的每一层。

  4. parameters["W" + str(l + 1)]：访问第 l+1 层的权重参数，参数的名称以"W"开头并加上层数的编号。

  5. parameters["b" + str(l + 1)]：访问第 l+1 层的偏置参数，参数的名称以"b"开头并加上层数的编号。

  6. parameters["W" + str(l + 1)] - learning_rate * grads["dW" + str(l + 1)]：这一行代码执行了梯度下降的参数更新步骤，根据梯度下降的规则，将当前层的权重参数减去学习率乘以当前层的权重参数的梯度（grads["dW" + str(l + 1)]）。

  7. parameters["b" + str(l + 1)] - learning_rate * grads["db" + str(l + 1)]：同样，这一行代码执行了梯度下降的参数更新步骤，将当前层的偏置参数减去学习率乘以当前层的偏置参数的梯度（grads["db" + str(l + 1)]）。

  8. 最后，函数返回更新后的参数parameters。

总之，这段代码实现了梯度下降算法的一步，通过计算梯度并根据学习率来更新神经网络的参数，以使成本函数最小化。这有助于神经网络学习数据的模式和特征。

def random_mini_batches(X, Y, mini_batch_size = 64, seed = 0):

    np.random.seed(seed)           
    m = X.shape[1]                
    mini_batches = []

    permutation = list(np.random.permutation(m))
    shuffled_X = X[:, permutation]
    shuffled_Y = Y[:, permutation].reshape((1,m))

 
    num_complete_minibatches = math.floor(m/mini_batch_size) 
    for k in range(0, 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:
  
        end = m - mini_batch_size * math.floor(m / mini_batch_size)
        mini_batch_X = shuffled_X[:,num_complete_minibatches * mini_batch_size:]
        mini_batch_Y = shuffled_Y[:,num_complete_minibatches * mini_batch_size:]
 
        mini_batch = (mini_batch_X, mini_batch_Y)
        mini_batches.append(mini_batch)
    
    return mini_batches

这段代码实现了一个函数 random_mini_batches，用于将数据集 X 和标签 Y 划分为多个小批量（mini-batches），以便进行小批量随机梯度下降（Mini-batch Stochastic Gradient Descent）训练。以下是对代码的详细解释：

  1. def random_mini_batches(X, Y, mini_batch_size = 64, seed = 0):：这是一个Python函数的定义，名称为 random_mini_batches，接受四个参数：X（输入数据），Y（对应的标签），mini_batch_size（每个小批量的样本数量，默认为64），和 seed（用于随机数生成的种子，默认为0）。

  2. np.random.seed(seed)：设置随机数生成器的种子，以确保每次运行代码时生成的随机数是相同的。这对于复现结果很重要。

  3. m = X.shape[1]：获取数据集中样本的总数量 m，X.shape[1] 表示样本数量。

  4. mini_batches = []：创建一个空列表 mini_batches 用于存储生成的小批量数据。

  5. permutation = list(np.random.permutation(m))：生成一个随机排列的样本索引列表 permutation，这将用于将数据集中的样本顺序打乱。

  6. shuffled_X = X[:, permutation] 和 shuffled_Y = Y[:, permutation].reshape((1,m))：使用随机排列的索引对输入数据 X 和标签 Y 进行重新排列，以打乱样本的顺序。这确保了每次迭代时都从随机的样本中选择小批量数据。

  7. num_complete_minibatches = math.floor(m/mini_batch_size)：计算可以创建的完整小批量的数量，取整到最接近的整数。

  8. for k in range(0, num_complete_minibatches):：使用循环迭代完整的小批量。

    • mini_batch_X = shuffled_X[:,k * mini_batch_size:(k + 1) * mini_batch_size]：从打乱顺序的数据中选择 k 到 k+1 小批量的输入数据。

    • mini_batch_Y = shuffled_Y[:,k * mini_batch_size:(k + 1) * mini_batch_size]：从打乱顺序的标签中选择 k 到 k+1 小批量的标签。

    • mini_batch = (mini_batch_X, mini_batch_Y)：将选择的小批量数据和标签组合成一个元组。

    • mini_batches.append(mini_batch)：将小批量数据添加到 mini_batches 列表中。

  9. 最后，如果数据集中的样本数量不能被 mini_batch_size 整除，还需要处理最后一个小批量。

    • end = m - mini_batch_size * math.floor(m / mini_batch_size)：计算最后一个小批量的样本数量，即余下的样本数量。

    • mini_batch_X = shuffled_X[:,num_complete_minibatches * mini_batch_size:]：选择余下的输入数据作为最后一个小批量。

    • mini_batch_Y = shuffled_Y[:,num_complete_minibatches * mini_batch_size:]：选择余下的标签作为最后一个小批量。

    • mini_batch = (mini_batch_X, mini_batch_Y)：将最后一个小批量数据和标签组合成一个元组。

    • mini_batches.append(mini_batch)：将最后一个小批量添加到 mini_batches 列表中。

  10. 最后，函数返回一个包含小批量数据的列表 mini_batches，每个小批量包含输入数据和对应的标签。

这个函数的主要目的是将数据集划分为小批量，以便在训练神经网络时进行小批量随机梯度下降优化。这有助于提高训练效率和泛化性能。

def initialize_velocity(parameters):
 
    L = len(parameters) // 2 
    v = {}
    
   
    for l in range(L):
   
        v["dW" + str(l + 1)] = np.zeros_like(parameters["W" + str(l+1)])
        v["db" + str(l + 1)] = np.zeros_like(parameters["b" + str(l+1)])
      
        
    return v

这段代码实现了一个函数 initialize_velocity，用于初始化用于动量优化算法的速度（velocity）参数。def initialize_velocity(parameters):：这是一个Python函数的定义，名称为 initialize_velocity，接受一个参数 parameters，它是一个包含神经网络参数的字典。

  1. L = len(parameters) // 2：计算神经网络的层数（L），这是通过参数字典的长度除以2得到的。在标准的神经网络中，参数通常包括权重（W）和偏置（b），因此每一层有两个参数。

  2. v = {}：创建一个空字典 v，用于存储速度参数。

  3. 使用循环迭代神经网络的每一层，从第1层到第L层（包括输入层和输出层）。

    • v["dW" + str(l + 1)]：创建一个与当前层的权重参数形状相同的零矩阵，用于存储权重参数的速度。参数的名称以"dW"开头并加上层数的编号。

    • v["db" + str(l + 1)]：创建一个与当前层的偏置参数形状相同的零矩阵，用于存储偏置参数的速度。参数的名称以"db"开头并加上层数的编号。

  4. 最后，函数返回一个包含初始化速度参数的字典 v。

这个函数的目的是为了在动量优化算法中使用，它初始化速度参数，以便在训练过程中累积梯度信息，从而改进梯度下降的性能。速度参数的初始化为零是一个常见的起点，然后在每次迭代中根据梯度信息进行更新。

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

这段代码实现了一个带有动量（momentum）的参数更新函数 update_parameters_with_momentum，用于更新神经网络的参数。动量是一种优化算法，通过在更新中累积梯度信息来改进梯度下降的性能。

  1. def update_parameters_with_momentum(parameters, grads, v, beta, learning_rate):：这是一个Python函数的定义，名称为 update_parameters_with_momentum，接受五个参数：

    • parameters：神经网络的参数。
    • grads：梯度信息，包含了每一层的权重梯度 dW 和偏置梯度 db。
    • v：速度参数，用于存储动量信息。
    • beta：动量的超参数，通常取值在0到1之间。
    • learning_rate：学习率，用于控制参数更新的步长。

  2. L = len(parameters) // 2：计算神经网络的层数（L），这是通过参数字典的长度除以2得到的。

  3. 使用循环迭代神经网络的每一层，从第1层到第L层（包括输入层和输出层）。

    • v["dW" + str(l + 1)] 和 v["db" + str(l + 1)]：更新速度参数，使用动量的计算方式，其中 beta 控制了新的速度与旧速度的权重。具体来说，新速度是旧速度的一部分，加上梯度的一部分。这可以看作是在更新时考虑了过去的速度信息。

    • parameters["W" + str(l + 1)] 和 parameters["b" + str(l + 1)]：使用更新后的速度参数来更新神经网络的权重和偏置参数。这一步是标准的参数更新步骤，但使用了动量修正后的速度信息。

  4. 最后，函数返回更新后的参数 parameters 和速度参数 v。

这个函数的目的是为了在动量优化算法中使用，动量能够在梯度下降的过程中平滑参数更新，有助于更快地收敛到局部最优解。动量算法使用了指数加权移动平均来保持过去梯度的影响，从而减少了参数更新的方差，提高了训练的稳定性。

def initialize_adam(parameters) :
       
    L = len(parameters) // 2 
    v = {}
    s = {}
    
   
    for l in range(L):

        v["dW" + str(l + 1)] = np.zeros_like(parameters["W" + str(l + 1)])
        v["db" + str(l + 1)] = np.zeros_like(parameters["b" + str(l + 1)])

        s["dW" + str(l+1)] = np.zeros_like(parameters["W" + str(l + 1)])
        s["db" + str(l+1)] = np.zeros_like(parameters["b" + str(l + 1)])
     
    return v, s

这段代码实现了一个函数 initialize_adam，用于初始化Adam优化算法中的速度参数（v）和移动平均梯度参数（s）。Adam是一种自适应学习率的优化算法，结合了动量和RMSProp。

  1. def initialize_adam(parameters):：这是一个Python函数的定义，名称为 initialize_adam，接受一个参数 parameters，它是一个包含神经网络参数的字典。

  2. L = len(parameters) // 2：计算神经网络的层数（L），这是通过参数字典的长度除以2得到的。在标准的神经网络中，参数通常包括权重（W）和偏置（b），因此每一层有两个参数。

  3. 创建两个空字典 v 和 s，分别用于存储速度参数和移动平均梯度参数。

  4. 使用循环迭代神经网络的每一层，从第1层到第L层（包括输入层和输出层）。

    • v["dW" + str(l + 1)] 和 v["db" + str(l + 1)]：创建一个与当前层的权重参数形状相同的零矩阵，用于存储权重参数的速度。参数的名称以"dW"开头并加上层数的编号。

    • s["dW" + str(l+1)] 和 s["db" + str(l+1)]：创建一个与当前层的权重参数形状相同的零矩阵，用于存储权重参数的移动平均梯度。参数的名称以"dW"开头并加上层数的编号。

  5. 最后，函数返回两个字典 v 和 s，分别包含了初始化的速度参数和移动平均梯度参数。

这个函数的目的是为了在Adam优化算法中使用，Adam算法使用了指数加权移动平均来估计梯度的一阶矩（均值）和二阶矩（方差），以自适应地调整学习率。初始化这些参数为零是一个常见的起点，然后在每次迭代中根据梯度信息进行更新。

def update_parameters_with_adam(parameters, grads, v, s, t, learning_rate=0.01,
                                beta1=0.9, beta2=0.999, epsilon=1e-8):
 
    L = len(parameters) // 2                 
    v_corrected = {}                        
    s_corrected = {}                        
    
    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)]
       
        v_corrected["dW" + str(l + 1)] = v["dW" + str(l + 1)] / (1 - np.power(beta1, t))
        v_corrected["db" + str(l + 1)] = v["db" + str(l + 1)] / (1 - np.power(beta1, t))
        
        s["dW" + str(l + 1)] = beta2 * s["dW" + str(l + 1)] + (1 - beta2) * np.power(grads['dW' + str(l + 1)], 2)
        s["db" + str(l + 1)] = beta2 * s["db" + str(l + 1)] + (1 - beta2) * np.power(grads['db' + str(l + 1)], 2)
        
        s_corrected["dW" + str(l + 1)] = s["dW" + str(l + 1)] / (1 - np.power(beta2, t))
        s_corrected["db" + str(l + 1)] = s["db" + str(l + 1)] / (1 - np.power(beta2, t))
       
        parameters["W" + str(l + 1)] = parameters["W" + str(l + 1)] - learning_rate * v_corrected["dW" + str(l + 1)] / np.sqrt(s_corrected["dW" + str(l + 1)] + epsilon)
        parameters["b" + str(l + 1)] = parameters["b" + str(l + 1)] - learning_rate * v_corrected["db" + str(l + 1)] / np.sqrt(s_corrected["db" + str(l + 1)] + epsilon)
       
    return parameters, v, s

这段代码实现了一个带有Adam优化算法的参数更新函数 update_parameters_with_adam，用于更新神经网络的参数。Adam是一种自适应学习率的优化算法，结合了动量和RMSProp，具有良好的性能。

  1. def update_parameters_with_adam(parameters, grads, v, s, t, learning_rate=0.01, beta1=0.9, beta2=0.999, epsilon=1e-8):：这是一个Python函数的定义，名称为 update_parameters_with_adam，接受七个参数：

    • parameters：神经网络的参数。
    • grads：梯度信息，包含了每一层的权重梯度 dW 和偏置梯度 db。
    • v：速度参数，用于存储动量信息。
    • s：移动平均梯度参数，用于存储二阶矩（方差）信息。
    • t：时间步（也称为迭代次数），用于调整偏差修正。
    • learning_rate：学习率，用于控制参数更新的步长，默认为0.01。
    • beta1：第一个动量超参数，通常取值在0.9左右，默认为0.9。
    • beta2：第二个动量超参数，通常取值接近1，但略小于1，默认为0.999。
    • epsilon：小数值，用于避免分母为零的情况，默认为1e-8，以确保数值稳定性。

  2. L = len(parameters) // 2：计算神经网络的层数（L），这是通过参数字典的长度除以2得到的。

  3. 创建两个字典 v_corrected 和 s_corrected，用于存储修正后的速度和移动平均梯度信息。

  4. 使用循环迭代神经网络的每一层，从第1层到第L层（包括输入层和输出层）。

    • 更新速度参数 v，使用动量的计算方式，其中 beta1 控制了新速度与旧速度的权重。具体来说，新速度是旧速度的一部分，加上梯度的一部分。

    • 计算修正后的速度 v_corrected，通过除以一个修正项来校正速度的偏差。这个修正项是 (1 - beta1^t)，其中 t 是时间步。

    • 更新移动平均梯度参数 s，使用RMSProp的计算方式，其中 beta2 控制了新梯度平方和旧梯度平方的权重。

    • 计算修正后的移动平均梯度 s_corrected，通过除以一个修正项来校正梯度平方的偏差。这个修正项是 (1 - beta2^t)，其中 t 是时间步。

    • 使用修正后的速度和移动平均梯度信息来更新神经网络的权重和偏置参数。这一步使用了Adam的参数更新规则，包括学习率和一个小的常数 epsilon 用于数值稳定性。

  5. 最后，函数返回更新后的参数 parameters、速度参数 v 和移动平均梯度参数 s。

这个函数的目的是为了在Adam优化算法中使用，Adam算法结合了动量和RMSProp，自适应地调整学习率以提高训练的效率和性能。

train_X, train_Y = load_dataset()

加载一个训练数据集，并将其分别存储在 train_X 和 train_Y 中。这里假设 load_dataset() 函数是用于加载数据集的自定义函数。

通常，训练数据集 train_X 包含输入特征（样本）的数据，而 train_Y 包含与每个输入样本相关联的标签或目标值。这些数据通常用于训练机器学习模型，例如神经网络。

def model(X, Y, layers_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):
    
    L = len(layers_dims)            
    costs = []                       
    t = 0                           
    seed = 10                      
    
    parameters = initialize_parameters(layers_dims)

    # 为不同的优化算法做初始化工作
    if optimizer == "gd":
        pass # 纯的梯度下降不需要初始化任何变量
    elif optimizer == "momentum":
        v = initialize_velocity(parameters) # 初始化v
    elif optimizer == "adam":
        v, s = initialize_adam(parameters) # 初始化v和s
    
    # 一个epoch就是遍历整个数据集一遍，一个epoch里面可以有多个minibatch
    for i in range(num_epochs):
        
        # 下面的seed进行了加1处理，是为了让每个epoch中的洗牌后数据集都不同。这样一来，每次的minibatch都包含了不同的训练样本。
        seed = seed + 1
        minibatches = random_mini_batches(X, Y, mini_batch_size, seed)

        # 遍历每个minibatch
        for minibatch in minibatches:

            # 分出x和y
            (minibatch_X, minibatch_Y) = minibatch

            a3, caches = forward_propagation(minibatch_X, parameters)

            cost = compute_cost(a3, minibatch_Y)

            grads = backward_propagation(minibatch_X, minibatch_Y, caches)

            # 使用不同的优化算法来更新参数
            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 = t + 1 # 梯度下降的次数，用来进行修正指数加权平均值
                parameters, v, s = update_parameters_with_adam(parameters, grads, v, s,
                                                               t, learning_rate, beta1, beta2,  epsilon)
        
        if print_cost and i % 1000 == 0:
            print("Cost after epoch %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

这段代码实现了一个深度神经网络模型，该模型可以使用不同的优化算法进行训练，例如梯度下降（Gradient Descent）、动量（Momentum）和Adam。

  1. def model(X, Y, layers_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):：这是一个Python函数的定义，名称为 model，接受多个参数：

    • X：训练数据集的输入特征。
    • Y：训练数据集的标签。
    • layers_dims：包含神经网络各层的单元数量的列表。
    • optimizer：选择的优化算法，可以是 "gd"（梯度下降）、"momentum"（动量）或 "adam"（Adam）。
    • learning_rate：学习率，用于控制参数更新的步长，默认为0.0007。
    • mini_batch_size：小批量大小，用于小批量随机梯度下降，默认为64。
    • beta：动量算法中的超参数，用于控制速度更新，默认为0.9。
    • beta1：Adam算法中的超参数，用于控制第一个动量估计，默认为0.9。
    • beta2：Adam算法中的超参数，用于控制第二个动量估计，默认为0.999。
    • epsilon：Adam算法中的小数值，用于数值稳定性，默认为1e-8。
    • num_epochs：训练的迭代次数，默认为10000。
    • print_cost：是否打印每1000次迭代的成本，默认为True。

  2. L = len(layers_dims)：计算神经网络的层数（L），即神经网络中隐藏层的数量加上输入层和输出层。

  3. costs = []：创建一个空列表 costs，用于存储每100次迭代的成本值，以便后续绘制学习曲线。

  4. t = 0：初始化时间步 t，用于Adam算法中修正指数加权平均值。

  5. seed = 10：设置随机数生成器的种子，以确保每次运行代码时生成的随机数是相同的。

  6. parameters = initialize_parameters(layers_dims)：初始化神经网络的参数，使用函数 initialize_parameters。

  7. 根据选择的优化算法，初始化相应的参数：

    • 如果 optimizer 为 "gd"，则不需要初始化额外的参数。
    • 如果 optimizer 为 "momentum"，则初始化速度参数 v。
    • 如果 optimizer 为 "adam"，则初始化速度参数 v 和移动平均梯度参数 s。

  8. 开始训练循环，共进行 num_epochs 次迭代。

  9. 在每个epoch中，随机洗牌并划分成小批量数据（minibatch），然后遍历每个小批量进行训练。

  10. 对于每个小批量，执行前向传播（forward_propagation）和反向传播（backward_propagation）来计算成本和梯度。

  11. 根据选择的优化算法，使用相应的参数更新函数来更新神经网络的参数：

    • 如果 optimizer 为 "gd"，使用梯度下降算法更新参数。
    • 如果 optimizer 为 "momentum"，使用动量算法更新参数。
    • 如果 optimizer 为 "adam"，使用Adam算法更新参数。

  12. 如果 print_cost 为True且迭代次数符合条件（每1000次迭代），则打印当前成本值。

  13. 每100次迭代，将当前成本值添加到 costs 列表中。

  14. 训练完成后，绘制学习曲线，显示成本随迭代次数的变化情况。

  15. 返回训练完毕后的参数 parameters。

这个函数的目的是训练深度神经网络，用户可以选择不同的优化算法来更新参数。这个模型的核心是训练神经网络并输出训练后的参数，以便进行预测。

layers_dims = [train_X.shape[0], 5, 2, 1]
parameters = model(train_X, train_Y, layers_dims, optimizer="gd")

predictions = predict(train_X, train_Y, parameters)

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.ravel())

这段代码执行了以下操作：

  1. 定义了神经网络的层结构 layers_dims，包括输入层、2个隐藏层（每层5个神经元）、输出层（1个神经元）。

  2. 调用了 model 函数，使用梯度下降优化算法（"gd"）训练了神经网络。训练的结果存储在 parameters 中。

  3. 使用训练好的参数 parameters 对训练数据进行预测，预测结果存储在 predictions 中。

  4. 绘制了模型的决策边界，用于可视化模型在训练数据上的分类情况。

下面是对每个部分的详细解释：

  1. layers_dims = [train_X.shape[0], 5, 2, 1]：定义了神经网络的层结构，其中 train_X.shape[0] 表示输入层的大小，具体大小由训练数据集 train_X 决定。

  2. parameters = model(train_X, train_Y, layers_dims, optimizer="gd")：调用 model 函数来训练神经网络。训练过程中会使用梯度下降优化算法，训练结果存储在 parameters 中。

  3. predictions = predict(train_X, train_Y, parameters)：使用训练好的参数 parameters 对训练数据集进行预测，将预测结果存储在 predictions 中。

  4. plt.title("Model with Gradient Descent optimization")：设置图表标题。

  5. axes = plt.gca()：获取当前图表的坐标轴对象。

  6. axes.set_xlim([-1.5, 2.5]) 和 axes.set_ylim([-1, 1.5])：设置坐标轴的范围，用于限定绘制决策边界的显示范围。

  7. plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X, train_Y.ravel())：绘制决策边界。这里使用 plot_decision_boundary 函数，其中传入了一个 lambda 函数 lambda x: predict_dec(parameters, x.T)，这个函数用于根据模型的预测结果来确定每个点的分类，然后绘制决策边界。同时，还传入了训练数据 train_X 和标签 train_Y。

这段代码的目的是训练一个神经网络模型，并可视化模型在训练数据上的分类效果。

layers_dims = [train_X.shape[0], 5, 2, 1]
parameters = model(train_X, train_Y, layers_dims, beta=0.9, optimizer="momentum")

predictions = predict(train_X, train_Y, parameters)

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.ravel())

您在这段代码中选择了动量优化算法来训练神经网络，并可视化了训练结果。

  1. layers_dims = [train_X.shape[0], 5, 2, 1]：定义了神经网络的层结构，包括输入层、2个隐藏层（每层5个神经元）和输出层（1个神经元）。

  2. parameters = model(train_X, train_Y, layers_dims, beta=0.9, optimizer="momentum")：调用 model 函数，使用动量优化算法（"momentum"）训练神经网络。训练结果存储在 parameters 中。

  3. predictions = predict(train_X, train_Y, parameters)：使用训练好的参数 parameters 对训练数据集进行预测，将预测结果存储在 predictions 中。

  4. plt.title("Model with Momentum optimization")：设置图表标题。

  5. axes = plt.gca()：获取当前图表的坐标轴对象。

  6. axes.set_xlim([-1.5, 2.5]) 和 axes.set_ylim([-1, 1.5])：设置坐标轴的范围，用于限定绘制决策边界的显示范围。

  7. plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X, train_Y.ravel())：绘制决策边界。这里使用 plot_decision_boundary 函数，其中传入了一个 lambda 函数 lambda x: predict_dec(parameters, x.T)，这个函数用于根据模型的预测结果来确定每个点的分类，然后绘制决策边界。同时，还传入了训练数据 train_X 和标签 train_Y。

这段代码的目的是训练一个神经网络模型，并可视化模型在训练数据上的分类效果，使用了动量优化算法。

layers_dims = [train_X.shape[0], 5, 2, 1]
parameters = model(train_X, train_Y, layers_dims, optimizer="adam")

predictions = predict(train_X, train_Y, parameters)

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.ravel())

  1. layers_dims = [train_X.shape[0], 5, 2, 1]：定义了神经网络的层结构，包括输入层、2个隐藏层（每层5个神经元）和输出层（1个神经元）。

  2. parameters = model(train_X, train_Y, layers_dims, optimizer="adam")：调用 model 函数，使用Adam优化算法（"adam"）训练神经网络。训练结果存储在 parameters 中。

  3. predictions = predict(train_X, train_Y, parameters)：使用训练好的参数 parameters 对训练数据集进行预测，将预测结果存储在 predictions 中。

  4. plt.title("Model with Adam optimization")：设置图表标题。

  5. axes = plt.gca()：获取当前图表的坐标轴对象。

  6. axes.set_xlim([-1.5, 2.5]) 和 axes.set_ylim([-1, 1.5])：设置坐标轴的范围，用于限定绘制决策边界的显示范围。

  7. plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X, train_Y.ravel())：绘制决策边界。这里使用 plot_decision_boundary 函数，其中传入了一个 lambda 函数 lambda x: predict_dec(parameters, x.T)，这个函数用于根据模型的预测结果来确定每个点的分类，然后绘制决策边界。同时，还传入了训练数据 train_X 和标签 train_Y。

这段代码的目的是训练一个神经网络模型，并可视化模型在训练数据上的分类效果，使用了Adam优化算法。

标签：10,parameters,mini,batch,算法,train,参数,str,对比
From： https://www.cnblogs.com/wzbzk/p/17745482.html

相关文章

  • 《流畅的Python》 读书笔记 231007(第二章第一部分)
    第2章数据结构ABC语言是Python的爸爸~很多点子在现在看来都很有Python风格：序列的泛型操作、内置的元组和映射类型、用缩进来架构的源码、无需变量声明的强类型不管是哪种数据结构，字符串、列表、字节序列、数组、XML元素，抑或是数据库查询结果，它们都共用一套丰富的操作：迭......
  • 【算法】国庆加班，火锅与Linq.AddRange的奇妙螺旋
    在国庆假期的一个傍晚，小悦正在家中享受火锅美食。她嘴里咀嚼着鲜嫩的牛肉，脸上洋溢着满足的微笑。突然，手机铃声响起，打破了这温馨的氛围。她拿起手机一看，是公司打来的电话。“小悦，有个紧急的项目需要处理，你能来公司加一下班吗？”电话那头传来领导焦急的声音。小悦顿时嘟起嘴，不太情......
  • 2310-数组习题
     strlen函数-求字符串长度的，找\0之前出现的字符个数 sizeof-操作符-计算变量/类型所占内存大小，单位是字节答案为A  #include<stdio.h>voidinit(intarr[],intsz){for(inti=0;i<sz;i++)arr[i]=0;}voidprint(intarr[],intsz){......
  • ElasticSearch8.10.2接入SpringBoot3.+
    pom.xml文件引入依赖 <!--https://mvnrepository.com/artifact/org.elasticsearch.client/elasticsearch-rest-client--> <dependency> <groupId>co.elastic.clients</groupId> <artifactId>elasticsearch-java</artifactId> &l......
  • 【愚公系列】2023年10月 二十三种设计模式(五)-单例模式(Singleton Pattern)
    ......
  • 2023.10-12 日记
    10.6只买到了石家庄到天津的票，所以先去zsy家玩了zsy他妈买了酱香拿铁，尝了尝感觉还行，酒味很淡且和咖啡并不冲突，可以接受。瑞幸敢上市确实是有道理的一等座确实舒服，几乎没有坐车的疲惫......
  • 2023.10.6——每日总结
    学习所花时间（包括上课）：0h代码量（行）：0行博客量（篇）：1篇今天，上午学习+休息，下午学习+休息；我了解到的知识点：1.任务明日计划：学习+休息......
  • 2023/10/6软件工程日报
    今天使用elementui+springboot实现了一个增删改查的小案例，附上代码       ......
  • 工作感受月记(202310月)
    2023年10月06日小天地有作为Keepongoingnevergiveup.今日在家值班，下午班，平安无事过一天。今日工作事项:1/看邮件，完成一个copilot的course。同时，在dfm中需要开始使用copilot，提高工作效率。 今日关键字: 归，指要回归正常的生活了。常规的工作和规律的作息。 ......
  • 扩展欧几里得算法
    算法阅读此篇前可先阅读欧几里得算法。给定\(a,b,s\)，求\(ax+by=s\)的任意一组解。证明:由裴蜀定理得：二元一次方程\(ax+by=c\)的有解条件是\(\gcd(a,b)\midc\)。由欧几里得算法得知\(\gcd(a,b)=\gcd(b,a\modb)\)假设我们求出了\(\gcd(b,a\modb)\)的两个解\((x'......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99