gluon的使用經驗

---

• 深度學習
• 目標檢測
• 深度學習
• 神經網絡

---

學到的新知識

bn放在relu後面

BN應該放在relu後

用於分類、檢測和分割的移動網絡 MobileNetV2

如何評價MobileNetV2

卷積核的數量

卷積神經網絡 — 從0開始

當輸入數據有多個通道的時候，每個通道會有對應的權重，然後會對每個通道做卷積之後在通道之間求和。所以當輸出只有一個的時候，卷積的channel數目和data的channel數目是一樣的。

當輸出需要多通道時，每個輸出通道有對應權重，然後每個通道上做卷積。所以當輸入有n個channel，輸出有h個channel時，卷積核channel數目爲n * h，每個輸出channel對應一個bias ,卷積核的維度爲(h,n,w,h)

$conv(data, w, b)[:,i,:,:] = conv(data, w[i,:,:,:], b[i])$

$\Gamma(z) = \int_0^\infty t^{z-1}e^{-t}dt\,.$

123

gluon語法

nn.Block與nn.sequential的嵌套使用

class RecMLP(nn.Block):
    def __init__(self, **kwargs):
        super(RecMLP, self).__init__(**kwargs)
        self.net = nn.Sequential()
        with self.name_scope():
            self.net.add(nn.Dense(256, activation="relu"))
            self.net.add(nn.Dense(128, activation="relu"))
            self.dense = nn.Dense(64)

    def forward(self, x):
        return nd.relu(self.dense(self.net(x)))

rec_mlp = nn.Sequential()
rec_mlp.add(RecMLP())
rec_mlp.add(nn.Dense(10))
print(rec_mlp)

初始化與參數訪問

from mxnet import init
params.initialize(init=init.Normal(sigma=0.02), force_reinit=True)
print(net[0].weight.data(), net[0].bias.data())

我們也可以通過collect_params來訪問Block裏面所有的參數（這個會包括所有的子Block）。它會返回一個名字到對應Parameter的dict。

也可以自定義各層的初始化方法，沒有自定義的按照net.initialize裏面的方法進行定義

from mxnet.gluon import nn
from mxnet import nd
from mxnet import init

def get_net():
    net = nn.Sequential()
    with net.name_scope():
        net.add(nn.Dense(4,activation="relu"))#,weight_initializer=init.Xavier()))
        net.add(nn.Dense(2,weight_initializer=init.Zero(),bias_initializer=init.Zero()) )
    return net

x = nd.random.uniform(shape=(3,5))
net = get_net()
net.initialize(init.One())
net(x)
print(net[1].weight.data

GPU訪問

1. 刪除cpu版本mxnet

pip uninstall mxnet

2. 更新GPU版本mxnet

pip install -U --pre mxnet-cu80

3. 查看版本號

import pip
for pkg in ['mxnet', 'mxnet-cu75', 'mxnet-cu80']:
    pip.main(['show', pkg])

使用jupyter的相關插件

1. notedown插件
   可以在jupyter 中查看markdown文件

2. nb_conda
   是conda的插件，可以在jupyter裏面修改python內核版本

優化方法

momentum
gluon.Trainer的learning_rate屬性和set_learning_rate函數可以隨意調整學習率。

trainer = gluon.Trainer(net.collect_params(), 'sgd',
                            {'learning_rate': lr, 'momentum': mom})

adagrad
Adagrad是一個在迭代過程中不斷自我調整學習率，並讓模型參數中每個元素都使用不同學習率的優化算法。

    trainer = gluon.Trainer(net.collect_params(), 'adagrad',
                            {'learning_rate': lr})

Adam

trainer = gluon.Trainer(net.collect_params(), 'adam',
                            {'learning_rate': lr})

通過以上分析, 理論上可以說, 在數據比較稀疏的時候, adaptive 的方法能得到更好的效果, 例如, adagrad, adadelta, rmsprop, adam 等. 在數據稀疏的情況下, adam 方法也會比 rmsprop 方法收斂的結果要好一些, 所以, 通常在沒有其它更好的理由的前框下, 我會選用 adam 方法, 可以比較快地得到一個預估結果. 但是, 在論文中, 我們看到的大部分還是最原始的 mini-batch 的 SGD 方法. 因爲馬鞍面的存在等問題, SGD 方法有時候較難收斂. 另外, SGD 對於參數的初始化要求也比較高. 所以, 如果要是想快速收斂的話, 建議使用 adam 這類 adaptive 的方法

延遲執行

延後執行使得系統有更多空間來做性能優化。但我們推薦每個批量裏至少有一個同步函數，例如對損失函數進行評估，來避免將過多任務同時丟進後端系統。

from mxnet import autograd

mem = get_mem()

total_loss = 0
for x, y in get_data():
    with autograd.record():
        L = loss(y, net(x))
    total_loss += L.sum().asscalar()
    L.backward()
    trainer.step(x.shape[0])

nd.waitall()
print('Increased memory %f MB' % (get_mem() - mem))

多GPU訓練

ctx = [gpu(i) for i in range(num_gpus)]
data_list = gluon.utils.split_and_load(data, ctx)
label_list = gluon.utils.split_and_load(label, ctx)

fintune 微調

gluon微調

一些可以重複使用的代碼

讀取數據

from mxnet import gluon
from mxnet import ndarray as nd

def transform(data, label):
    return data.astype('float32')/255, label.astype('float32')
mnist_train = gluon.data.vision.FashionMNIST(train=True, transform=transform)
mnist_test = gluon.data.vision.FashionMNIST(train=False, transform=transform)

計算精度

def accuracy(output, label):
    return nd.mean(output.argmax(axis=1)==label).asscalar()

我們先使用Flatten層將輸入數據轉成 batch_size x ? 的矩陣，然後輸入到10個輸出節點的全連接層。照例我們不需要制定每層輸入的大小，gluon會做自動推導。

激活函數

sigmoid

from mxnet import nd
def softmax(X):
    exp = nd.exp(X)
    # 假設exp是矩陣，這裏對行進行求和，並要求保留axis 1，
    # 就是返回 (nrows, 1) 形狀的矩陣
    partition = exp.sum(axis=1, keepdims=True)
    return exp / partition

relu

def relu(X):
    return nd.maximum(X, 0)

損失函數

平方誤差

square_loss = gluon.loss.L2Loss()

def square_loss(yhat, y):
    # 注意這裏我們把y變形成yhat的形狀來避免矩陣形狀的自動轉換
    return (yhat - y.reshape(yhat.shape)) ** 2
 

交叉熵損失

def cross_entropy(yhat, y):
    return - nd.pick(nd.log(yhat), y)

softmax_cross_entropy = gluon.loss.SoftmaxCrossEntropyLoss()

取一個batch_size的代碼

scratch版本

import random
batch_size = 1
def data_iter(num_examples):
    idx = list(range(num_examples))
    random.shuffle(idx)
    for i in range(0, num_examples, batch_size):
        j = nd.array(idx[i:min(i+batch_size,num_examples)])
        yield X.take(j), y.take(j)

gluon版本

batch_size = 1
dataset_train = gluon.data.ArrayDataset(X_train, y_train)
data_iter_train = gluon.data.DataLoader(dataset_train, batch_size, shuffle=True)

初始化權值

scratch版本

def get_params():
    w = nd.random.normal(shape=(num_inputs, 1))*0.1
    b = nd.zeros((1,))
    for param in (w, b):
        param.attach_grad()
    return (w, b)

gluon版本

net.initialize()


net.collect_params().initialize(mx.init.Normal(sigma=1))

SGD

scratch版本

def SGD(params, lr):
    for param in params:
        param[:] = param - lr * param.grad

L2正則

def L2_penalty(w, b):
    return ((w**2).sum() + b**2) / 2

gluon版本

    trainer = gluon.Trainer(net.collect_params(), 'sgd', {
        'learning_rate': learning_rate, 'wd': weight_decay})

這裏的weight_decay表明這裏添加了L2正則，正則化
w = w -lr * grad - wd * w

訓練過程

scratch版本

    for e in range(epochs):        
        for data, label in data_iter(num_train):
            with autograd.record():
                output = net(data, lambd, *params)
                loss = square_loss(
                    output, label) + lambd * L2_penalty(*params)
            loss.backward()
            SGD(params, learning_rate)
        train_loss.append(test(params, X_train, y_train))
        test_loss.append(test(params, X_test, y_test))

gluon版本

    for e in range(epochs):        
        for data, label in data_iter_train:
            with autograd.record():
                output = net(data)
                loss = square_loss(output, label)
            loss.backward()
            trainer.step(batch_size)            
        train_loss.append(test(net, X_train, y_train))
        test_loss.append(test(net, X_test, y_test))

%matplotlib inline
import matplotlib as mpl
mpl.rcParams['figure.dpi']= 120
import matplotlib.pyplot as plt

def train(X_train, X_test, y_train, y_test):
    # 線性迴歸模型
    net = gluon.nn.Sequential()
    with net.name_scope():
        net.add(gluon.nn.Dense(1))
    net.initialize()
    # 設一些默認參數
    learning_rate = 0.01
    epochs = 100
    batch_size = min(10, y_train.shape[0])
    dataset_train = gluon.data.ArrayDataset(X_train, y_train)
    data_iter_train = gluon.data.DataLoader(
        dataset_train, batch_size, shuffle=True)
    # 默認SGD和均方誤差
    trainer = gluon.Trainer(net.collect_params(), 'sgd', {
        'learning_rate': learning_rate})
    square_loss = gluon.loss.L2Loss()
    # 保存訓練和測試損失
    train_loss = []
    test_loss = []
    for e in range(epochs):
        for data, label in data_iter_train:
            with autograd.record():
                output = net(data)
                loss = square_loss(output, label)
            loss.backward()
            trainer.step(batch_size)
        train_loss.append(square_loss(
            net(X_train), y_train).mean().asscalar())
        test_loss.append(square_loss(
            net(X_test), y_test).mean().asscalar())
    # 打印結果
    plt.plot(train_loss)
    plt.plot(test_loss)
    plt.legend(['train','test'])
    plt.show()
    return ('learned weight', net[0].weight.data(),
            'learned bias', net[0].bias.data())

最終版

def train(train_data, test_data, net, loss, trainer, ctx, num_epochs, print_batches=None):
    """Train a network"""
    print("Start training on ", ctx)
    if isinstance(ctx, mx.Context):
        ctx = [ctx]
    for epoch in range(num_epochs):
        train_loss, train_acc, n, m = 0.0, 0.0, 0.0, 0.0
        if isinstance(train_data, mx.io.MXDataIter):
            train_data.reset()
        start = time()
        for i, batch in enumerate(train_data):
            data, label, batch_size = _get_batch(batch, ctx)
            losses = []
            with autograd.record():
                outputs = [net(X) for X in data]
                losses = [loss(yhat, y) for yhat, y in zip(outputs, label)]
            for l in losses:
                l.backward()
            train_acc += sum([(yhat.argmax(axis=1)==y).sum().asscalar()
                              for yhat, y in zip(outputs, label)])
            train_loss += sum([l.sum().asscalar() for l in losses])
            trainer.step(batch_size)
            n += batch_size
            m += sum([y.size for y in label])
            if print_batches and (i+1) % print_batches == 0:
                print("Batch %d. Loss: %f, Train acc %f" % (
                    n, train_loss/n, train_acc/m
                ))

        test_acc = evaluate_accuracy(test_data, net, ctx)
        print("Epoch %d. Loss: %.3f, Train acc %.2f, Test acc %.2f, Time %.1f sec" % (
            epoch, train_loss/n, train_acc/m, test_acc, time() - start
        ))

reference

從零開始碼一個皮卡丘檢測器

圖片標註工具

mxnet 使用自己的圖片數據訓練CNN模型

mxnet image API

Create a Dataset Using RecordIO

基於MXNet gluon 的SSD模型訓練

解決conda與ipython notebook的python版本問題

神經網絡計算參數量的方法

神經網絡計算特徵圖的大小的方法

BN應該放在relu後