本身動手實現深度學習框架-3 自動分批訓練, 緩解過擬合

代碼倉庫: https://github.com/brandonlyg/cute-dl

目標

1. 爲Session類增長自動分批訓練模型的功能, 使框架更好用。
2. 新增緩解過擬合的算法: L2正則化, 隨機丟棄。

實現自動分批訓練

設計方案

• 增長Dataset類負責管理數據集, 自動對數據分批。
• 在Session類中增長fit方法, 從Dataset獲得數據, 使用事件機制告訴外界訓練狀況, 最後返回一個訓練歷史記錄。
• 增長FitListener類, 用於監聽fit方法訓練過程當中觸發的事件。

fit方法

定義:

fit(self, data, epochs, **kargs)

data: 訓練數據集Dataset對象。
epochs: 訓練輪數, 把data中的每一批數據遍歷訓練一次稱爲一輪。
kargs:
val_data: 驗證數據集。
val_epochs: 執行驗證的訓練輪數. 每val_epochs輪訓練驗證一次。
val_steps: 執行驗證的訓練步數. 每val_steps步訓練驗證一次. 只有val_steps>0纔有效, 優先級高於val_epochs。
listeners: 事件監聽器FitListener對象列表.

fit方法觸發的事件

• epoch_start: 每輪訓練開始時觸發。
• epoch_end: 每輪訓練結束時觸發。
• val_start: 每次執行驗證時觸發。
• val_end: 每次執行驗證結束時觸發。

訓練過程當中, fit方法會把觸發的事件派發到全部的FitListener對象, FitListener對象本身決定處理或忽略。

訓練歷史記錄(history)

        history的格式:

{
  'loss': [],
  'val_loss': [],
  'steps': [],
  'val_pred': darray,
  'cost_time': float
}

• loss: 記錄訓練偏差。
• val_loss: 記錄驗證偏差。loss會和val_loss同步記錄。
• steps: 每一個偏差記錄對應的訓練步數。
• val_pred: 最後一次執行驗證時模型使用驗證數據集預測的結果。
• cost_time: 整個訓練過程花費的時間(s)。

代碼

fit方法實現

        代碼文件: cutedl/session.py。
        fit方法比較複雜, 先看主幹代碼:

#初始化訓練歷史數據結構
    history = {
        'loss': [],
        'val_loss': [],
        'steps': [],
        'val_pred': None,
        'cost_time': 0
    }
    #打開訓練開關, 當調用stop_fit方法後會關閉這個開關, 中止訓練。
    self.__fit_switch = True

    #獲得參數
    val_data = kargs.get('val_data')
    val_epochs = kargs.get('val_epochs', 1)
    val_steps = kargs.get('val_steps', 0)
    listeners = kargs.get('listeners', [])

    if val_data is None:
        history['val_loss'] = None

    #計算將會訓練的最大步數
    if val_epochs <= 0 or val_epochs >= epochs:
        val_epochs = 1

    if val_steps <= 0:
        val_steps = val_epochs * data.batch_count

      #開始訓練
      step = 0
      history['cost_time'] = time.time()
      for epoch in range(epochs):
          if not self.__fit_switch:
              break

          #觸發並派發事件
          event_dispatch("epoch_start")
          for batch_x, batch_y in data.as_iterator():
              if not self.__fit_switch:
                  break
              #pdb.set_trace()
              loss = self.batch_train(batch_x, batch_y)
              step += 1
              if step % val_steps == 0:
                  #使用驗證數據集驗證模型
                  event_dispatch("val_start")
                  val_loss, val_pred = validation()
                  record(loss, val_loss, val_pred, step)
                  event_dispatch("val_end")
                  #顯示訓練進度
                  display_progress(epoch+1, epochs, step, val_steps, loss, val_loss)
              else:
                  display_progress(epoch+1, epochs, step, val_steps, loss)

          event_dispatch("epoch_end")

      #記錄訓練耗時
      history['cost_time'] = time.time() - history['cost_time']

      return history

        主幹代碼中使用了一些局部函數, 這些局部函數每一個都是實現了一個小功能。

        派發事件:

def event_dispatch(event):
    #pdb.set_trace()
    for listener in listeners:
        listener(event, history)

        執行驗證:

def validation():
    if val_data is None:
        return None, None

    val_pred = None #保存全部的預測結果
    losses = [] #保存全部的損失值
    #分批驗證
    for batch_x, batch_y in val_data.as_iterator():
        #pdb.set_trace()
        y_pred = self.__model.predict(batch_x)
        loss = self.__loss(batch_y, y_pred)
        losses.append(loss)

        if val_pred is None:
            val_pred = y_pred
        else:
            val_pred = np.vstach((val_pred, y_pred))
    #計算平均損失
    loss = np.mean(np.array(losses))
    return loss, val_pred

        記錄訓練歷史:

def record(loss, val_loss, val_pred, step):
    history['loss'].append(loss)
    history['steps'].append(step)

    if history['val_loss'] is not None and val_loss is not None :
        history['val_loss'].append(val_loss)
        history['val_pred'] = val_pred

        顯示訓練進度:

def display_progress(epoch, epochs, step, steps, loss, val_loss=-1):
      prog = (step % steps)/steps
      w = 20

      str_epochs = ("%0"+str(len(str(epochs)))+"d/%d")%(epoch, epochs)

      txt = (">"*(int(prog * w))) + (" "*w)
      txt = txt[:w]
      if val_loss < 0:
          txt = txt + (" loss=%f   "%loss)
          print("%s %s"%(str_epochs, txt), end='\r')
      else:
          txt = "loss=%f, val_loss=%f"%(loss, val_loss)
          print("")
          print("%s %s\n"%(str_epochs, txt))

實現L2正則化參數優化器

設計方案

• 加強Optimizer類的功能, 可以本身匹配要更新的參數。
• 給出L2正則化算法的Optimizer實現。
• 在Session類中增長對廣義優化器的支持(L2優化器就是廣義優化器)。

數學原理

        設模型每一層的損失函數爲:

\[J=f(XW+b) \]

        X是數據, W是權重參數，b是偏移量參數. L2算法是在原損失函數上加上W範數平方的衰減量, 獲得一個新的損失函數:

\[J_{L2} = J + \frac{λ}{2}||W||^2 \]

        λ是衰減率, 是一個至關於學習率的超參數。對於一個模型來講, 只有輸出層的損失函數是明確知道的, 其餘層是不明確的。不過不要緊, 更新參數是在反向傳播階段，這個時候須要的是梯度, 並不關心原函數的形式, 新損失函數的梯度爲:

\[\frac{\partial}{\partial W_i}J_{L2} = \frac{\partial}{\partial W_i} J + λW_i \]

        其中

\[\frac{\partial}{\partial W_i} J \]

        能夠在反向傳播時候獲得. 在梯度降低法訓練模型時, 更新參數的表達式變成:

\[W_i = W_i - (α\frac{\partial}{\partial W_i} J + λW_i) = (1-λ)W_i - α\frac{\partial}{\partial W_i} J, \quad \text{α是學習率} \]

        這個表達式的含義是: 在使用學習率更新參數以前，先把參數(W的範數)縮小到原來的(1-λ)倍。

代碼

加強Optimizer功能

        代碼文件: cutedl/optimizer.py
        修改__call__代碼:

def __call__(self, model):
      params = self.match(model)
      for p in params:
          self.update_param(model, p)

match方法用來把名字匹配的參數過濾出來。
update_param方法實現實際的更新參數操做, 由子類實現。

        match實現:

'''
  獲得名字匹配pattern的參數
  '''
  def match(self, model):
      params = []
      rep = re.compile(self.pattern)
      for ly in model.layer_iterator():
          for p in ly.params:
              if rep.match(p.name) is None:
                  continue

              params.append(p)

      return params

        這個方法使用正則表達式經過參數名匹配參數, 並返回匹配的參數列表。pattern是正則表達式屬性, 子類能夠經過覆蓋這個屬性, 改變匹配行爲。

實現L2正則化優化器

'''
L2 正則化
'''
class L2(Optimizer):
    '''
    damping 參數衰減率
    '''
    def __init__(self, damping):
        self.__damping = damping

    def update_param(self, model, param):
        #pdb.set_trace()
        param.value = (1 - self.__damping) * param.value

在Session中支持廣義參數優化器

        代碼文件: cutedl/session.py。
        首先爲__init__ 方法添加參數:

'''
genoptms: list[Optimizer]對象, 廣義參數優化器列表,
                  列表中的優化器將會在optimizer以前按順序執行
'''
def __init__(self, model, loss, optimizer, genoptms=None):
  self.__genoptms = genoptms

        而後在batch_train方法中調用優化器:

#執行廣義優化器更新參數
    if self.__genoptms is not None:
        for optm in self.__genoptms:
            optm(self.__model)

實現隨機丟棄層: Dropout

數學原理

        向前傳播的函數:

\[Y_i = \frac{A_i}{p} X_i, \quad A_i服從參數爲p的伯努利分佈, p∈(0, 1) \]

        p是咱們要給出的常數。算法使用p構造隨機變量A, 使得A=1的機率爲p, A=0的機率爲1-p. 對這個函數的直觀解釋是: A將有1-p的機率被丟棄掉(置爲0), p的機率被保留, 若是被保留, 它將會被拉伸1/p倍。 這個函數有一個頗有用的性質, 它的輸入和輸出的均值不變:

\[E(Y_i) = \frac{E(A_i)}{p} E(X_i) = \frac{p}{p} E(X_i) = E(X_i) \]

        反向傳播的梯度爲:

\[\frac{\partial}{\partial X_i} = \frac{A_i}{p} \]

代碼

        代碼文件: nn_layers.py。
        Dropout類實現了隨機丟棄算法。向前傳播實現:

def forward(self, in_batch, training=False):
    kp = self.__keep_prob
    #pdb.set_trace()
    if not training or kp <= 0 or kp>=1:
        return in_batch

    #生成[0, 1)之間的均價分佈
    tmp = np.random.uniform(size=in_batch.shape)
    #保留/丟棄索引
    mark = (tmp <= kp).astype(int)
    #丟棄數據, 並拉伸保留數據
    out = (mark * in_batch)/kp

    self.__mark = mark

    return out

        隨機丟棄層傳入的參數是keep_prob保留機率, 這意味這丟棄的機率爲1 - keep_prob. 只有處於訓練狀態且0<keep_prob<1才執行丟棄操做。代碼中的變量mark就是用保留機率構造隨機變量, 它服從參數爲keep_prob的伯努利分佈。
        反向傳播實現:

def backward(self, gradient):
    #pdb.set_trace()
    if self.__mark is None:
        return gradient

    out = (self.__mark * gradient)/self.__keep_prob

    return out

驗證

        目前階段所須要的代碼已經完成，如今咱們來進行驗證，驗證代碼位於: examples/mlp/linear-regression-1.py。

對比基準

        首先咱們來構造一個欠擬合模型做爲對比基準。

'''
過擬合對比基準
'''
def fit0():
    print("fit0")
    model = Model([
        nn.Dense(128, inshape=1, activation='relu'),
        nn.Dense(256, activation='relu'),
        nn.Dense(1)
    ])
    model.assemble()

    sess = Session(model,
                loss=losses.Mse(),
                optimizer = optimizers.Fixed(),
            )

    history = sess.fit(ds, 200000, val_data=val_ds, val_epochs=1000,
                    listeners=[
                        FitListener('val_end', callback=lambda h:on_val_end(sess, h))
                        ]
                    )

    fit_report(history, report_path+'00.png', 10)

        能夠看到這裏再也不須要本身寫訓練函數, 直接調用fit方法便可實現自動訓練。on_val_end函數監聽val_end事件, 它的功能是在盡是條件時調用Session的stop_fit方法中止訓練, 這裏中止訓練的條件是: 最初的10次驗證事後, 檢查每次驗證的val_loss值, 若是連續10次沒有變得更小就中止訓練。
        擬合報告:

使用L2優化器緩解過擬合

'''
使用L2正則化緩解過擬合
'''
def fit1():
    print("fit1")
    model = Model([
        nn.Dense(128, inshape=1, activation='relu'),
        nn.Dense(256, activation='relu'),
        nn.Dense(1)
    ])
    model.assemble()


    sess = Session(model,
                loss=losses.Mse(),
                optimizer = optimizers.Fixed(),
                #L2正則化
                genoptms = [optimizers.L2(0.00005)]
            )

    history = sess.fit(ds, 200000, val_data=val_ds, val_epochs=1000,
                    listeners=[
                        FitListener('val_end', callback=lambda h:on_val_end(sess, h))
                        ]
                    )
    fit_report(history, report_path+'01.png', 10)

        擬合報告:

        從訓練損失值圖像上看有明顯的緩解跡象。

使用Dropout層緩解過擬合

'''
使用dropout緩解過擬合
'''
def fit2():
    print("fit2")
    model = Model([
        nn.Dense(128, inshape=1, activation='relu'),
        nn.Dense(256, activation='relu'),
        nn.Dropout(0.80), #0.8的保留機率
        nn.Dense(1)
    ])
    model.assemble()

    sess = Session(model,
                loss=losses.Mse(),
                optimizer = optimizers.Fixed(),
            )

    history = sess.fit(ds, 200000, val_data=val_ds, val_epochs=1000,
                    listeners=[
                        FitListener('val_end', callback=lambda h:on_val_end(sess, h))
                        ]
                    )

    fit_report(history, report_path+'02.png', 15)

        擬合報告:

        從訓練損失值圖像上隨機丟棄的效果更好一些。

總結

        驗證結果代表, cute-dl目前能夠用不多代碼實現模型的自動分批訓練, 和linear-regression.py相比, linear-regression-1.py中已經不須要關注具體的訓練過程了, 而且可以獲得基本訓練歷史記錄。另外, L2正則化優化器和Dropout層也能有效地緩解過擬合。 本階段目標基本達成。         到目前爲止, 用來驗證框架的是一個線性迴歸任務, 數據集是從一個二次函數採樣獲得, 這個任務本質上是訓練模型預測連續值。可是在深度學習領域，還要求模型可以預測離散值，即可以執行分類任務。下個階段, 將會給框架添加新的損失函數, 使之可以支持分類任務, 並討論這些損失函數的數學性質。