paddle04-paddle.optimizer(优化相关) 【暂不更新】

🌟 paddle.optimizer

• 1.class paddle.optimizer.Adam(learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-08, parameters=None, weight_decay=None, grad_clip= None, lazy_mode=False) Adam优化器

  利用梯度的 一阶矩估计 和 二阶矩估计 动态调整每个参数的学习率。  
  
  参数: 
      1.learning_rate: float, 学习率,用于参数更新的计算， 默认0.001  
      2.beta1: float/tensor, 可选, 一阶矩估计的指数衰减率，默认 0.9
      3.beat2: float/tensor, 可选, 二阶矩估计的指数衰减率，默认 0.999
      4.epsilon: float, 可选, 保持数值稳定性的短浮点类型值，默认值为1e-08
      5.parameters: list, 可选, 指定优化器需要优化的参数。在动态图模式下必须提供该参数;静态图模式下默认值为None,优化所有的参数。 
      6.weight_decay: float/... , 可选，正则化方法. 可以是 float 类型的L2正则化系数 或 正则化策略。 如果一个参数在 ParamAttr 中已经设置了正则化，这里的正则化将 被忽略。  
      7.grad_clip: 可选,梯度裁剪的策略,支持三种，默认None，不裁剪
      8.lazy_mode: bool,可选, 默认False.  lazy_mode=True, 仅更新当前具有梯度的元素。  
  
  inp = np.random.uniform(-0.1, 0.1, [10, 10]).astype("float32")
  linear = paddle.nn.Linear(10, 10)
  inp = paddle.to_tensor(inp)
  out = linear(inp)
  loss = paddle.mean(out)
  adam = paddle.optimizer.Adam(learning_rate=0.1,
          parameters=linear.parameters())
  out.backward()
  adam.step()
  adam.clear_grad()
  

  • 方法: step() 仅在动态图模式下生效，执行一次优化器并进行参数更新,返回None

    out = linear(a)
    

  out.backward()
  adam.step()
  adam.clear_grad()

  
  * 方法: minimize(loss, startup_program=None, parameters=None, no_grad_set=None)  
      ```
      为网络添加反向计算过程，并根据反向计算所得的梯度，更新parameters中的Parameters，最小化网络损失值loss
      ```
  * 方法: clear_grad()   动态图下生效,清除需要优化的参数的梯度;optimizer.clear_grad()
  * 方法: set_lr(value) 动态图生效,手动设置当前 optimizer 的学习率。当使用_LRScheduler时，无法使用该API手动设置学习率，因为这将导致冲突  
      ```
      linear = paddle.nn.Linear(10, 10)
  
      adam = paddle.optimizer.Adam(0.1, parameters=linear.parameters())
  
      # set learning rate manually by python float value
      lr_list = [0.2, 0.3, 0.4, 0.5, 0.6]
      for i in range(5):
          adam.set_lr(lr_list[i])
          lr = adam.get_lr()
          print("current lr is {}".format(lr))
      # Print:
      #    current lr is 0.2
      #    current lr is 0.3
      #    current lr is 0.4
      #    current lr is 0.5
      #    current lr is 0.6
      ```
  * 方法: get_lr() 动态图有效, 获取当前步骤的学习率。当不使用_LRScheduler时，每次调用的返回值都相同，否则返回当前步骤的学习率  
      ```
      import paddle
      # example1: _LRScheduler is not used, return value is all the same
      emb = paddle.nn.Embedding(10, 10, sparse=False)
      adam = paddle.optimizer.Adam(0.001, parameters = emb.parameters())
      lr = adam.get_lr()
      print(lr) # 0.001
      ```
  
  
  
      
  

• 2.paddle.optimizer.SGD(learning_rate=0.001, parameters=None, weight_decay=None, grad_clip=None) SGD优化器

  为网络添加反向计算过程，并根据反向计算所得的梯度，更新parameters中的Parameters，最小化网络损失值loss  
  参数: 
      1.learning_rate: float, 可选，默认: 0.001
      2.parameters: list, 可选, 需要优化参数，动态图必选  
      3.weight_decay: float, 可选， 权重衰减系数，默认: 0.01
      4.grad_clip: 可选,梯度裁剪策略  
  
  inp = paddle.uniform(min=-0.1, max=0.1, shape=[10, 10], dtype='float32')
  linear = paddle.nn.Linear(10, 10)
  inp = paddle.to_tensor(inp)
  out = linear(inp)
  loss = paddle.mean(out)
  sgd = paddle.optimizer.SGD(learning_rate=0.1, parameters=linear.parameters())
  out.backward()
  sgd.step()
  sgd.clear_grad()
  

  • 方法:step()
  • 方法: minimize()
  • 方法: clear_grad()
  • 方法: set_lr()

• 3.paddle.optimizer.Adagrad()

• 4.paddle.optimizer.Adadelta()

• 5.paddle.optimizer.Adamax()

• 6.paddle.optimizer.AdamW()

• 7.paddle.optimizer.Momentum()

• 8.paddle.optimizer.Optimizer()

• 9.paddle.optimizer.RMSProp()