8. 網路結構的權重共享量化

網路權重共享量化也是一類重要的網路壓縮方法，其本質在於先通過聚類方法得到該層權重的聚類中心，然後通過聚類中心值來表示原權重值。因此權重值並不是由32位的浮點數來表示，而是由其對應的聚類中心的序號表示，如果聚類級別為8位，此時權重值只需要用8位就能表示。

對於網路權重量化也有三個問題：

1. 量化級別的確定，同修剪率一樣，可以通過試錯的試驗的方法來確定
2. 量化後網路重新訓練問題
3. 量化中心的初始選擇問題：聚類中心採用線性方法初始化，將初始點均勻分散，這種初始化方法不僅操作簡單，而且能夠將對網路影響較大但實際分佈較少的較大權重值也包含到初始中心點中，因此不容易造成較大權重的丟失。

8.1 Kmean聚類得到每層的聚類中心

對於Kmean聚類方法，這裡呼叫的是scipy庫的聚類函式

    # 獲得各層的量化碼錶
    def kmeans_net(net, layers, num_c=16, initials=None):
        # net: 網路
        # layers: 需要量化的層
        # num_c: 各層的量化級別
        # initials: 初始聚類中心
        codebook = {} # 量化碼錶
        if type(num_c) == type(1):
            num_c = [num_c] * len(layers)
        else:
            assert len(num_c) == len(layers)

        # 對各層進行聚類分析
        print "==============Perform K-means============="
        for idx, layer in enumerate(layers):
            print "Eval layer:", layer
            W = net.params[layer][0].data.flatten()
            W = W[np.where(W != 0)] # 篩選不為0的權重
            # 預設情況下，聚類中心為線性分佈中心
            if initials is None:  # Default: uniform sample
                min_W = np.min(W)
                max_W = np.max(W)
                initial_uni = np.linspace(min_W, max_W, num_c[idx] - 1)
                codebook[layer], _ = scv.kmeans(W, initial_uni)
            elif type(initials) == type(np.array([])):
                codebook[layer], _ = scv.kmeans(W, initials)
            elif initials == 'random':
                codebook[layer], _ = scv.kmeans(W, num_c[idx] - 1)
            else:
                raise Exception

            # 將0權重值附上
            codebook[layer] = np.append(0.0, codebook[layer])
            print "codebook size:", len(codebook[layer])

        return codebook

8.2 量化各層

通過各層聚類來進行各層權重的量化

    def quantize_net_with_dict(net, layers, codebook, use_stochastic=False, timing=False):
        start_time = time.time()
        codeDict = {} # 記錄各個量化中心所處的位置
        maskCode = {} # 各層量化結果
        for layer in layers:
            print "Quantize layer:", layer
            W = net.params[layer][0].data
            if use_stochastic:
                codes = stochasitc_quantize2(W.flatten(), codebook[layer])
            else:
                codes, _ = scv.vq(W.flatten(), codebook[layer])
            W_q = np.reshape(codebook[layer][codes], W.shape)
            net.params[layer][0].data[...] = W_q

            maskCode[layer] = np.reshape(codes, W.shape)
            codeBookSize = len(codebook[layer])
            a = maskCode[layer].flatten()
            b = xrange(len(a))

            codeDict[layer] = {}
            for i in xrange(len(a)):
                codeDict[layer].setdefault(a[i], []).append(b[i])

        if timing:
            print "Update codebook time:%f" % (time.time() - start_time)

        return codeDict, maskCode

8.3 重新訓練及聚類中心的更新

    @static_vars(step_cache={}, step_cache2={}, count=0)
    def update_codebook_net(net, codebook, codeDict, maskCode, args, update_layers=None, snapshot=None):

        start_time = time.time()
        extra_lr = args['lr'] # 基礎學習速率
        decay_rate = args['decay_rate'] # 衰減速率
        momentum = args['momentum'] # 遺忘因子
        update_method = args['update'] # 更新方法
        smooth_eps = 0

        normalize_flag = args['normalize_flag'] # 是否進行歸一化


        if update_method == 'rmsprop':
            extra_lr /= 100

        # 對碼錶與量化結果的初始化
        if update_codebook_net.count == 0:
            step_cache2 = update_codebook_net.step_cache2
            step_cache = update_codebook_net.step_cache
            if update_method == 'adadelta':
                for layer in update_layers:
                    step_cache2[layer] = {}
                    for code in xrange(1, len(codebook[layer])):
                        step_cache2[layer][code] = 0.0
                smooth_eps = 1e-8

            for layer in update_layers:
                step_cache[layer] = {}
                for code in xrange(1, len(codebook[layer])):
                    step_cache[layer][code] = 0.0

            update_codebook_net.count = 1

        else:
            # 讀入上次運算的結果
            step_cache2 = update_codebook_net.step_cache2
            step_cache = update_codebook_net.step_cache
            update_codebook_net.count += 1

        # 所有層名
        total_layers = net.params.keys()
        if update_layers is None: # 所有層都需要進行更新
            update_layers = total_layers

        # 權重碼錶的更新
        for layer in total_layers:
            if layer in update_layers:
                diff = net.params[layer][0].diff.flatten() # 誤差梯度
                codeBookSize = len(codebook[layer])
                dx = np.zeros((codeBookSize)) # 編碼表的誤差更新
                for code in xrange(1, codeBookSize):
                    indexes = codeDict[layer][code] # codeDict儲存屬於某編碼的權重的序號
                    #diff_ave = np.sum(diff[indexes]) / len(indexes)
                    diff_ave = np.sum(diff[indexes]) # 統計該編碼所有的誤差更新和

                    # 針對於不同方法進行更新
                    if update_method == 'sgd':
                        dx[code] = -extra_lr * diff_ave
                    elif update_method == 'momentum':
                        if code in step_cache[layer]:
                            dx[code] = momentum * step_cache[layer][code] - (1 - momentum) * extra_lr * diff_ave
                            step_cache[layer][code] = dx
                    elif update_method == 'rmsprop':
                        if code in step_cache[layer]:
                            step_cache[layer][code] = decay_rate * step_cache[layer][code] + (1.0 - decay_rate) * diff_ave ** 2
                            dx[code] = -(extra_lr * diff_ave) / np.sqrt(step_cache[layer][code] + 1e-6)
                    elif update_method == 'adadelta':
                        if code in step_cache[layer]:
                            step_cache[layer][code] = step_cache[layer][code] * decay_rate + (1.0 - decay_rate) * diff_ave ** 2
                            dx[code] = -np.sqrt((step_cache2[layer][code] + smooth_eps) / (step_cache[layer][code] + smooth_eps)) * diff_ave
                            step_cache2[layer][code] = step_cache2[layer][code] * decay_rate + (1.0 - decay_rate) * (dx[code] ** 2)

                # 是否需要進行歸一化更新引數
                if normalize_flag:
                    codebook[layer] += extra_lr * np.sqrt(np.mean(codebook[layer] ** 2)) / np.sqrt(np.mean(dx ** 2)) * dx
                else:
                    codebook[layer] += dx
            else:
                pass

            # maskCode儲存編碼結果
            W2 = codebook[layer][maskCode[layer]]
            net.params[layer][0].data[...] = W2 # 量化後權重值

        print "Update codebook time:%f" % (time.time() - start_time)

重新訓練時，其精度的變化圖，可以看到隨著迭代次數增加，其精度也逐漸提升

8.4 網路壓縮未來的方向

從上面可以看出來，在訓練中，各網路中的權重仍是32位的浮點數，而不是用8位來表示，而即使在實際執行中，也必須通過聚類中心表將量化後權重值轉換為32位的浮點數，因此並不能在減少網路的實際執行記憶體，只是減少網路的記憶體消耗。

要真正減少網路記憶體消耗，從而達到網路實際執行速度的提高，目前有兩類主流方法：

1. 讓網路保證結構上的稀疏性，而不是隨機分佈的稀疏性。可以參考論文：
   Wen W, Wu C, Wang Y, et al. Learning Structured Sparsity in Deep Neural Networks[J]. 2016.

2. 設計量化運算的網路，比如QNN及BNN等等。可以參考論文：Hubara I, Courbariaux M, Soudry D, et al. Quantized neural networks: Training neural networks with low precision weights and activations[J]. Journal of Machine Learning Research. 2016, 1: 1–29.

8.5 具體程式碼下載