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