本文深入解析MXNet深度学习框架的基本概念与核心组件，包括NDArray与SymbolAPI的使用方法，以及Gluon模块的高度封装特性。涵盖自动求导、设备管理、层实现等关键技术，并提供模型训练与优化的实际案例。
MXNet是基础，Gluon是封装，两者犹如TensorFlow和Keras，不过得益于动态图机制，两者交互比TensorFlow和Keras要方便得多，其基础操作和pytorch极为相似，但是方便不少，有pytorch基础入门会很简单。注意和TensorFlow不同，MXNet的图片维度是 batch x channel x height x width 。
MXNet的API主要分为3层，最基础的时mxnet.ndarray（NDArray API），它以近似numpy数组的形式记录了诸多基础的函数式的操作，支持自动求导和GPU加速应该是它针对numpy的最主要改进；然后是mxnet.Symbol（Symbol API）模块，它是MXNet符号式编程的基石，与mxnet.model（Module API）模块相互搭配可以灵活、快速地构建网络，这一层比较类似TensorFlow；最后就是Gloun（Gluon API）模块，它更近似于Keras，高度的封装了代码。
市面上的大部分教程（包含框架作者的"动手学习深度学习"）都以ndarray的简要上手为引入，以Gloun为主要学习内容，不过，如果经常浏览MXNet开源项目的话，会发现，实际上Symbol的使用才是主流。我对于Symbol的了解也很肤浅，有希望学习MXNet的新人如果看到这段引文希望能有针对的避开我掉进去的坑。
库导入写法，
from mxnet import ndarray as nd
from mxnet import autograd
from mxnet import gluon
import mxnet as mx实际上第一个包 from mxnet import nd 也行，简化工作很厉害……
MXNet.ndarray
mxnet.ndarray是整个科学计算系统的基础，整体API和numpy的nparray一致，这一点类似于pytorch，不过不同于pytorch内置变量、张量等不同数据类型，mxnet简化了只有ndarray一种，通过mxnet.autograd可以直接实现求导，十分便捷.
自动求导
x = nd.arange(4).reshape((4, 1))
# 标记需要自动求导的量
x.attach_grad()
# 有自动求导就需要记录计算图
with autograd.record():
y = 2 * nd.dot(x.T, x)
# 反向传播输出
y.backward()
# 获取梯度
print('x.grad: ', x.grad)设备
array.copyto() # 传入设备则复制进设备，传入array则覆盖(也会进入传入的设备)
array.as_in_context() # 修改设备
nd转化为数字
nd.asscalar()
nd与np数组互化
y = nd.array(x) # NumPy转换成NDArray。
z = y.asnumpy() # NDArray转换成NumPy。
节约内存的加法
nd.elemwise_add(x, y, out=z)
持久化
nd.save(file, [arr1, arr2, ……])
nd.load(file)
层实现
拉伸
nd.flatten(array)
relu激活
内置，
nd.nn.relu()
手动实现，
def relu(X):
return nd.maximum(X, 0)卷积层
# 输入输出数据格式是 batch x channel x height x width，这里batch和channel都是1
# 权重格式是 output_channels x in_channels x height x width，这里input_filter和output_filter都是1。
w = nd.arange(4).reshape((1,1,2,2))
b = nd.array([1])
data = nd.arange(9).reshape((1,1,3,3))
out = nd.Convolution(data, w, b, kernel=w.shape[2:], num_filter=w.shape[1], stride=(2,2), pad=(1,1))
池化层
data = nd.arange(18).reshape((1,2,3,3))
max_pool = nd.Pooling(data=data, pool_type="max", kernel=(2,2))
avg_pool = nd.Pooling(data=data, pool_type="avg", kernel=(2,2))
全连接层
# 变量生成
w = nd.random.normal(scale=1, shape=(num_inputs, 1))
b = nd.zeros(shape=(1,))
params = [w, b]
# 变量挂载梯度
for param in params:
param.attach_grad()
# 实现全连接
def net(X, w, b):
return nd.dot(X, w) + b批量归一化层
在测试时我们还是需要继续使用批量归一化的，只是需要做些改动。在测试时，我们需要把原先训练时用到的批量均值和方差替换成整个训练数据的均值和方差。但 是当训练数据极大时，这个计算开销很大。因此，我们用移动平均的方法来近似计算（参见实现中的moving_mean和moving_variance）。
def batch_norm(X, gamma, beta, is_training, moving_mean, moving_variance,
eps = 1e-5, moving_momentum = 0.9):
assert len(X.shape) in (2, 4)
# 全连接: batch_size x feature
if len(X.shape) == 2:
# 每个输入维度在样本上的平均和方差
mean = X.mean(axis=0)
variance = ((X - mean)**2).mean(axis=0)
# 2D卷积: batch_size x channel x height x width
else:
# 对每个通道算均值和方差，需要保持4D形状使得可以正确的广播
mean = X.mean(axis=(0,2,3), keepdims=True)
variance = ((X - mean)**2).mean(axis=(0,2,3), keepdims=True)
# 变形使得可以正确的广播
moving_mean = moving_mean.reshape(mean.shape)
moving_variance = moving_variance.reshape(mean.shape)
# 均一化
if is_training:
X_hat = (X - mean) / nd.sqrt(variance + eps)
#!!! 更新全局的均值和方差
moving_mean[:] = moving_momentum * moving_mean + (
1.0 - moving_momentum) * mean
moving_variance[:] = moving_momentum * moving_variance + (
1.0 - moving_momentum) * variance
else:
#!!! 测试阶段使用全局的均值和方差
X_hat = (X - moving_mean) / nd.sqrt(moving_variance + eps)
# 拉升和偏移
return gamma.reshape(mean.shape) * X_hat + beta.reshape(mean.shape)Droupout
def dropout(X, drop_probability):
keep_probability = 1 - drop_probability
assert 0 <= keep_probability <= 1
# 这种情况下把全部元素都丢弃。
if keep_probability == 0:
return X.zeros_like()
# 随机选择一部分该层的输出作为丢弃元素。
mask = nd.random.uniform(
0, 1.0, X.shape, ctx=X.context) < keep_probability
# 保证 E[dropout(X)] == X
scale = 1 / keep_probability
return mask * X * scaleSGD实现
def sgd(params, lr, batch_size):
for param in params:
param[:] = param - lr * param.grad / batch_size
Gluon
内存数据集加载
import mxnet as mx
from mxnet import autograd, nd
import numpy as np
num_inputs = 2
num_examples = 1000
true_w = [2, -3.4]
true_b = 4.2
features = nd.random.normal(scale=1, shape=(num_examples, num_inputs))
labels = true_w[0] * features[:, 0] + true_w[1] * features[:, 1] + true_b
labels += nd.random.normal(scale=0.01, shape=labels.shape)
from mxnet.gluon import data as gdata
batch_size = 10
dataset = gdata.ArrayDataset(features, labels)
data_iter = gdata.DataLoader(dataset, batch_size, shuffle=True)
for X, y in data_iter:
print(X, y)
break[[-1.74047375 0.26071024] [ 0.65584248 -0.50490594] [-0.97745866 -0.01658815] [-0.55589193 0.30666101] [-0.61393601 -2.62473822] [ 0.82654613 -0.00791582] [ 0.29560572 -1.21692061] [-0.35985938 -1.37184834] [-1.69631028 -1.74014604] [ 1.31199837 -1.96280086]] <NDArray 10x2 @cpu(0)> [ -0.14842382 7.22247267 2.30917668 2.0601418 11.89551163 5.87866735 8.94194221 8.15139961 6.72600317 13.50252151] <NDArray 10 @cpu(0)>
模型定义
- 序列模型生成
- 层填充
- 初始化模型参数
net = gluon.nn.Sequential()
with net.name_scope():
net.add(gluon.nn.Dense(1))
net.collect_params().initialize(mx.init.Normal(sigma=1)) # 模型参数初始化选择normal分布优化器：gluon.Trainer
wd参数为模型添加了L2正则化，机制为：w = w - lr*grad - wd*w
trainer = gluon.Trainer(net.collect_params(), 'sgd', {
'learning_rate': learning_rate, 'wd': weight_decay})
trainer.step(batch_size)需要运行在每一次反向传播之后，会更新参数，一次模拟的训练过程如下，
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))设备
net.collect_params().reset_ctx()可以重置model设备
持久化
net.save_params(file)
net.load_params(file, ctx) # 可以指定加载设备
层函数API：gluon.nn
拉伸
nn.Flatten()
卷积层
nn.Conv2D(1, kernel_size=(1, 2)) # 输出通道1，卷积核横2纵
nn.Conv2D(channels=6, kernel_size=5, activation='sigmoid')
池化层
最大池化层
nn.MaxPool2D(pool_size=2, strides=2)
全连接层
nn.Dense(256, activation="relu") # 参数表示输出节点数
激活函数
nn.Activation("relu")
批量归一化层
nn.BatchNorm(axis=1) # 卷积层后的BN层对每个通道求一个平均
损失函数class API：gluon.loss
交叉熵
loss = gluon.loss.SoftmaxCrossEntropyLoss()
扫一扫
1007
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
