mxnet出了gluon好久了，沐神也出了一系列精品课程，这么好的东西就系统的看了一遍教程。做了如下笔记，希望以后回顾的时候能有些用处。
另外，gluon有自己的官方中文社区，而且有大牛坐镇，推荐！
0 什么是Gluon ？
如解浚源知乎中所言：
Gluon是MXNet的动态图接口;Gluon学习了Keras，Chainer，和Pytorch的优点，并加以改进。接口更简单，且支持动态图（Imperative）编程。相比TF，Caffe2等静态图（Symbolic）框架更加灵活易用。同时Gluon还继承了MXNet速度快，省显存，并行效率高的优点，并支持静、动态图混用，比Pytorch更快。
1 预备知识
1.1 NDArray
NDArray 是 MXNet用于储存和变化数据的主要工具。使用方法与Numpy相似。
这里只写一下数据替换操作
from mxnet import ndarray as nd
x=nd.ones((3,4))
y=nd.ones((3,4))
y=y+x #此时等号左右两边的y不是同一个id
#下面两种方法可避免新内存开销
y[:]=y+x#此时等号左右两边相同
y+=x#此时等号左右两边相同
###
z=nd.zeros_like(x)
z[:]=x+y #此时z的id相同，但是仍有额外临时x+y的开销，下面方法可避免
nd.elemwise_add(x,y,out=z)1.2 autograd自动求导
mxnet.autograd可以方便对算式记性求导，使用方法：
import mxnet.ndarray as nd
import mxnet.autograd as ag
# f=2*x*x
x=nd.array([[1,2],[3,4]])
x.attach_grad()# 对x求导，先开辟导数所需要的空间
with ag.record():
y=2*x*x
y.bachward()
print(x.grad)另外还可以将链式求导的head gradient 显示的作为backward的参数
2 深度学习基础
2.1 线性回归
这节的意义在于手动实现一遍使用SGD求解线性回归的过程。对于新手还是挺重要的。
所谓线性回归就是对于数据x及目标y，求映射参数w和b使得，yhat=xw+b与y的值尽量接近，即sum((yhat-y)^2) 最小，求解伪代码如下：
for batch(x,y) in data_iter():
with autograd.record():
yhat=dot(x,w)+b# x，w需要事先attach_grad
loss=sum((yhat-y)^2)
loss.backward()
for p in [w,b]:
w[:]=w-lr*w.grad#注意替换的用法哦； 这里的grad其实是batch数据的sum，sgd中应该使用平均下面是gluon的代码
net=gluon.nn.Sequential()
net.add(gluon.nn.Dense(1))#指明输出数量为1
net.initialize()#初始化时默认随机初始化
square_loss=gluon.loss.L2Loss()
trainer=gluon.Trainer(
net.collect_params,
'sgd',
{'learning_rate':0.1})
###############
epochs = 5
batch_size = 10
for e in range(epochs):
total_loss = 0
for data, label in data_iter:
with autograd.record():
output = net(data)
loss = square_loss(output, label)
loss.backward()
trainer.step(batch_size)
total_loss += nd.sum(loss).asscalar()
print("Epoch %d, average loss: %f" % (e, total_loss/num_examples))对于dense的权重访问：
net[0].weight.data();net[0].bias.data()2.2 多分类逻辑回归
例子中使用多分类逻辑回归对Fashion MNIST数据集进行分类。
对于分类如果使用线性回归，得到对于输入数据x的线性映射，这时候不能很好的表示类别，为了将映射结果转为类别表示，就用了softmax即yhat=exp(x)/exp(x).sum(axis=1,keepdims)（为了避免overflow，通常会在exp之前减去最大值）
为了表示分类的效果，使用交叉熵损失表示即loss=-log(yhat)yhat为对应的y为1时的值，此时如果yhat为1，则得到的损失为0.
有了yhat和loss，替换2.1中的伪代码即可。
gluon实现：
net=gluon.nn.Sequential()
with net.name_scope():#name scope便于命名
net.add(gluon.nn.Flatten())
net.add(gluon.nn.Dense(10))
net.initialize()
softmax_cross_entropy=gluon.loss.SoftmaxCrossEntropyLoss()
trainer=gluon.Trainer(net.collect_params(),'sgd',{'learning_rate:0.1})
#后续autograd.record();backward;trainer.step(batch_size)；不再赘述2.3 多层感知机
类似于2.2，此处yhat的得到时多了一各求中间隐含层的过程。gluon中net的多了个一各Dense层
net=gluon.nn.Squential()
with net.name_scope():
net.add(gluon.nn.Dense(256,activtion='relu'))
net.add(gluon.nn.Dense(10))
net.initialize()2.4 欠拟合与过拟合
欠拟合与过拟合是机器学习模型训练过程中必须要知道的概念，欠拟合是指模型还没有充分的从训练数据集中学到东西，过拟合是指对于数据集中细枝末节过于学习，造成了不能get到更有代表性的特征，解决过拟合的方法有很多比如添加正则项、增加训练数据、ensemble、dropout等等。
教程中关于欠拟合和过拟合的例子非常好。
2.5 正则化
教程中使用输入数据维度较大，训练样本比较少的时候，查看了正则化的好处，所谓正则化就是在loss中增加参数（通常只是w）的范数，直观上来说不能使权重过大，这样可以使分类界限更加平滑。
贝叶斯的角度，l2正则是先验为高斯分布下的后验最大估计，l1正则是先验为拉普拉斯分布下的后验最大估计
gluon实现的时候，在trainer中加入weight_decay项
trainer = gluon.Trainer(
net.collect_params(), 'sgd',
{'learning_rate': learning_rate, 'wd': weight_decay})2.6 dropout
dropout可以看成每次随机 扔掉某一层的某一些输入数据，使用部分输入用以学习特征，可以看成ensemble的一种变种，注意的是只在训练过程中使用，且输入数据在去掉后要扩大相应的倍数，以使前传与训练时输入分布相似。
gluon中的使用方法如下：
net=nn.Sequential()
with net.name_scope():
net.add(nn.Flatten())
net.add(nn.Dense(256,activation='relu'))
net.add(nn.Dropout(0.2))
net.add(nn.Dense(256,activation='relu'))
net.add(nn.Dropout(0.5))
net.add(nn.Dense(10))
net.initialize()2.7 正向传播与反向传播
简单来说正向传播计算loss，反向传播利用loss计算各参数的梯度，用梯度来更新参数
3 Gluon使用基础
3.1 模型构造
Gluon中主要使用Block来构造模型，Block是Gluon里的一个类，位于incubator-mxnet/python/mxnet/gluon/block.py,前面使用的Sequential是他的一个子类，位于incubator-mxnet/python/mxnet/gluon/nn/basic_layers.py。
3.1.1 使用block将模型定义一个类
使用Block无需定义求导或反传函数，MXNet会使用autograd对forward自动生成相应的backward函数。
class MLP(nn.block):
def __init__(self,**kwargs):
super(MLP,self).__init__(**kwargs)
with self.name_scope():
self.hidden =nn.Dense(256,active='relu')
self.output =nn.Dense(10)
def forward(self,x)
return self.output(self.hidden(x))使用的时候只需要实例化之后initialize一下赋予输入值即可进行一次forward：
net=MLP()
net.initialize()3.1.2 Sequential与Block嵌套使用
class NestMLP（nn.Block）:
def __init__(self,**kwargs):
super(NestMLP,self).__init__(**kwargs)
self.net = nn.Squential()
with self.name_scope():
self.net.add(nn.Dense(64,activation='relu'))
self.net.add(nn.Dense(32,activation='relu'))
self.dense=nn.Dense(16,activation='relu')
def forward(self,x):
return self.dense(self.net(x))
###
net=nn.Sequential()
net.add(NestMLP())
net.add(nn.Dense(10))
net.initialize()值得注意的是使用block时，定义的网络需要为block类型，如self.denses = [nn.Dense(256), nn.Dense(128), nn.Dense(64)]赋值为list不是block会出现无法注册的问题
3.2 模型初始化
在Gluon 中，模型参数的类型是Parameter。
collect_params 来访问Block ⾥的所有参数。
使用Siamese或者其他网络时可能需要共享参数，这时候只需要通过Block 的params
来指定模型参数即可如：
net.add(nn.Dense(4, activation='relu', params=net[1].params))
#或者
self.hidden3 = nn.Dense(4, activation='relu',params=self.hidden2.params)
3.3 自定义层
搞深度自定义层还是经常用到的
这里只列出简单的自定义层的方法，与使用Block构建模型相似：
class mydense(nn.Block):
def __init__(self,uints,in_units,**kwargs):#uints，in_uints分别是输出单元个数及输入单元个数
super (mydense,self).__init__(**kwargs)
with self.name_scope():
self.weight=self.params.get('weight',shape=(in_uints,uints))
self.bias=self.params.get('bias',shape=(uints,))
def forward(self,x):
linear=nd.dot(x,self.weight.data())+self.bias.data()
return nd.relu(linear)自己定义延迟初始化层稍微麻烦点，建议看下gluon源代码。需要hybridize，以及intializer延后调用
3.4 模型参数读写
block支持直接使用save_params及load_params记性模型的写与读：
net1.save_params('./net1.params')
net2.load_params('./net1.params')3.5 gpu计算
mx.cpu(), mx.gpu()可以用来指定ctx
如net.initialize(ctx=mx.gpu())
可以使用copyto 和as_in_context函数在CPU/GPU 之间传输数据，如果源变量和⽬标变量的context ⼀致，as_in_context 使⽬标变量和源变量共享源变量的内存，而copyto 总是为⽬标变量新创建内存。
y = x.copyto(mx.gpu())
z = x.as_in_context(mx.gpu())打印NDArray 或将NDArray 转换成NumPy 格式时，MXNet 会⾃动将数据复制到主
内存
4. 计算性能
4.1 混合编程
命令式编程比较灵活，符号式编程效率较高且容易部署，Gluon使用混合编程，集两者之长
在混合式编程中，我们可以通过使⽤HybridBlock 或者HybridSequential 类构建模型。默认情况下，它们和Block 或者Sequential类⼀样依据命令式编程的⽅式执⾏。当我们调⽤hybridize 函数后，Gluon 会转换成依据符号式编程的⽅式执⾏。事实上，绝⼤多数模型都可以享受符号式编程的优势。
4.1.1 HybridSequential
使用方法与Sequential类似
net=nn.HybridSequential()
with net.name_scope():
net.add(
nn.Dense(256,activation='relu'),
nn.Dense(256,activation='relu'),
nn.Dense(2,activation='relu')
)
net.initialize()
net.hybridize()#通过调⽤hybridize 函数来编译和优化HybridSequential 实例中串联的层的计算。
net(x)
net.export('sy')#export 函数保存符号式程序和模型参数4.1.2 HybridBlock
class HybridNet(nn.HybridBlock):
def __init__(self,**kwargs):
super(HybridNet,self).__init__(**kwargs)
with self.name_scope():
self.hidden=nn.Dense(10)
self.output=nn.Dense(2)
def hybrid_forward(self,F,x):#多了一个F，命令编程时F为NDArray，符号式编程时为Symbol（mxnet中的符号式程序类）
x=F.relu(self.hidden(x))
return self.output(x)
net=HybridNet()
net.initialize()
net.hybridize()#####
net(x)调用hybridize 函数后运⾏net(x) 的时候，得到符号式程序，之后再运⾏net(x)的时候MXNet 将不再访问Python 代码，而是直接在C++ 后端执⾏符号式程序。
4.2 惰性计算
所谓惰性计算简单点说就是用到啥再算啥
MXNet 包括⽤⼾直接⽤来交互的前端和系统⽤来执⾏计算的后端，⽤⼾可以使⽤不同的前端语⾔编写MXNet 程序，像Python、R、Scala 和C++。⽆论使⽤何种前端编程语⾔，MXNet 程序的执⾏主要都发⽣在C++ 实现的后端。换句话说，⽤⼾写好的前端MXNet 程序会传给后端执⾏计算。后端有⾃⼰的线程来不断收集任务，构造、优化并执⾏计算图。
MXNet 后端将默认使⽤惰性计算来获取最⾼的计算性能。
如果想让后端结果与前端同步可以使用wait_to_read 或nd.waitall来等待后端计算，同时像print/ asnumpy /asscalar等也可以实现同步。
惰性计算与内存
惰性计算会优化计算效率，但是可能会增加使用内存，所以：
由于深度学习模型通常⽐较⼤，而内存资源通常有限，我们建议读者在训练模型时对每个小批量都使⽤同步函数。类似地，在使⽤模型预测时，为了减小内存开销，我们也建议读者对每个小批量预测时都使⽤同步函数，例如直接打印出当前批量的预测结果。
4.3 并行运算
4.3.1 cpu/gpu
同时又cpu和gpu程序运行时会mxnet会自动优化（包括从CPU到GPU的复制数据），而非两个程序顺序执行。
4.3.2 多GPU并行
Gluon 提供了split_and_load函数。它可以划分⼀个小批量的数据样本并
复制到各个CPU/GPU 上，当我们使⽤多个GPU 来训练模型时，gluon.Trainer 会⾃动做数据并⾏，可以划分一个batch数据样本并复制到各个GPU 上，对各个GPU 上的梯度求和再同步到所有GPU 上。
sce_loss = gluon.loss.SoftmaxCrossEntropyLoss()
ctx=[mx.gpu(i) for i in range(yourdevice)]
net.collect_params().initialize(init=init.Xavier(),ctx=ctx,force_reinit=True)# 多卡同时初始化
trainer=gluon.Trainer(net.collect_params(),'sgd',{'learning_rate':lr})
for epoch in range(1,epoch_num):
total_loss=0
for feature,label in train_data:
gpu_data=gluon.utils.split_and_load(feature,ctx)
gpu_label=gluon.utils.split_and_load(label,ctx)
with autograd.record():
losses=[sec_loss(net(x),y)for x,y in zip(gpu_data,gpu_labels)]
total_loss+=sum([loss.sum().asscalar() for loss in losses])
trainer.step(batch_size)
nd.waitall()5. 其他
5.1 图像扩增
mxnet提供了image工具
from mxnet import image
img = image.imdecode(open('../img/cat1.jpg', 'rb').read())
augs = [image.HorizontalFlipAug(.5),\
image.RandomCropAug([200,200]),\
image.RandomSizedCropAug((200,200), .1, (.5,2))\#随机裁剪，要求保留⾄少0.1 的区域，随机长宽⽐在.5 和2 之间。
image.BrightnessJitterAug(.5)\#随机将亮度增加或者减⼩在0-50% 间的⼀个量
aug = image.HueJitterAug(.5)#随机⾊调变化
]
for f in augs:
img = f(img)
5.2 设置学习率
conv0 = gluon.nn.Conv2D(我的参数)
conv0.bias.lr_mult = 2.
net = gluon.nn.Sequential()
net.add(conv0）
#或者
net[k].bias.lr_mult = 2.5.3 输入数据
gluon.data.DataLoader自带多进程读取数据
5.4 其他
到这里就基本会使用gluon了。教程之后从AlexNet 、VGG、 GoogLeNet 讲到ResNet、DenseNet。还有计算机视觉中的检测、分割入门，自然语义处理、时间序列、GAN等等方面的入门知识，非常适合刚刚深度学习的同学用来学习，这里就不展开了。
从零开始系列也是非常的利于理解基础知识