Mxnet基础知识(二)

#命令式编程

def add(a, b):
    return a + b

def fancy_func(a, b, c, d):
    e = add(a, b)
    f = add(c, d)
    g = add(e, f)
    return g

fancy_func(1, 2, 3, 4)

#符号式编程

def add_str():
    return '''
def add(a, b):
    return a + b
'''

def fancy_func_str():
    return '''
def fancy_func(a, b, c, d):
    e = add(a, b)
    f = add(c, d)
    g = add(e, f)
    return g
'''

def evoke_str():
    return add_str() + fancy_func_str() + '''
print(fancy_func(1, 2, 3, 4))
'''

prog = evoke_str()
print(prog)
y = compile(prog, '', 'exec')
exec(y)

#coding:utf-8
from mxnet.gluon import nn
from mxnet import nd

class HybridNet(nn.HybridBlock):
    def __init__(self, **kwargs):
        super(HybridNet, self).__init__(**kwargs)
        self.hidden = nn.Dense(10)
        self.output = nn.Dense(2)

    def hybrid_forward(self, F, x):
        print('F: ', F)
        print('x: ', x)
        x = F.relu(self.hidden(x))
        print('hidden: ', x)
        return self.output(x)

#按原始命令式编程方程，逐行执行
net = HybridNet()
net.initialize()
x = nd.random.normal(shape=(1, 4))
net(x)

#net.hybridize()会对代码结构进行优化，转变成符号式编程
net.hybridize()
net(x)

#再次执行时，不会打印代码中的print部分，这是因为hybride后，构建成符号式代码网络，mxnet会缓存符号图，直接执行符号图，不会再去调用python原始代码
net(x)

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


def getnet():
    net = nn.Sequential()
    net.add(nn.Dense(256, activation='relu'))
    net.add(nn.Dense(10))
    return net

#网络参数未初始化，无具体值
net = getnet()
print(1, net.collect_params())   #print(1, net[0].weight.data())

#网络参数未初始化，无具体值
net.initialize()
print(2, net.collect_params())  #print(2, net[0].weight.data())

#根据输入x的尺寸，网络推断出各层参数的尺寸，然后进行初始化
x = nd.random.uniform(shape=(2, 30))
net(x)
print(3, net.collect_params())
print(3, net[0].weight.data())

#第二次执行时，不会再进行初始化
net(x)

init.Zero()               #初始化为常数0
init.One()                 #初始化为常数1
init.Constant(value=0.05)  #初始化为常数0.05
init.Orthogonal()          #初始化为正交矩阵
init.Uniform(scale=0.07)  #(-0.07, 0.07)之间的随机分布
init.Normal(sigma=0.01)  #均值为0, 标准差为0.01的正态分布
init.Xavier(magnitude=3)  # magnitude初始化， 适合tanh
init.MSRAPrelu(slope=0.25)  #凯明初始化，适合relu

#第一层和第二层采用不同的方法进行初始化，
# force_reinit：无论网络是否初始化，都重新初始化
net[0].weight.initialize(init=init.Xavier(), force_reinit=True)
net[1].initialize(init=init.Constant(42), force_reinit=True)

#自定义初始化，需要继承init.Initializer， 并实现 _init_weight
class MyInit(init.Initializer):
    def _init_weight(self, name, data):
        print('Init', name, data.shape)
        data[:] = nd.random.uniform(low=-10, high=10, shape=data.shape)
        data *= data.abs() >= 5   # 绝对值小于5的赋值为0， 大于等于5的保持不变

net.initialize(MyInit(), force_reinit=True)
net[0].weight.data()[0]

mydense = nn.Dense(100, prefix="mydense_")
print(mydense.prefix)  #mydense_
print(mydense.collect_params())    #mydense_weight, mydense_bias
 
dense0 = nn.Dense(100)
print(dense0.prefix)      #dense0_
print(dense0.collect_params())  #dense0_weight, dense0_bias

dense1 = nn.Dense(100)     
print(dense1.prefix)   #dense1_
print(dense1.collect_params())  #dense1_weight, dense1_bias

from mxnet import gluon
import mxnet as mx

class Model(gluon.Block):
    def __init__(self, **kwargs):
        super(Model, self).__init__(**kwargs)
        with self.name_scope():
            self.dense0 = gluon.nn.Dense(20)
            self.dense1 = gluon.nn.Dense(20)
            self.mydense = gluon.nn.Dense(20, prefix='mydense_')

    def forward(self, x):
        x = mx.nd.relu(self.dense0(x))
        x = mx.nd.relu(self.dense1(x))
        return mx.nd.relu(self.mydense(x))

model0 = Model()
model0.initialize()
model0(mx.nd.zeros((1, 20)))
print(model0.prefix)         #model0_
print(model0.dense0.prefix)  #model0_dense0_
print(model0.dense1.prefix)  #model0_dense1_
print(model0.mydense.prefix) #model0_mydense_


model1 = Model()
model1.initialize()
model1(mx.nd.zeros((1, 20)))
print(model1.prefix)          #model1_
print(model1.dense0.prefix)   #model1_dense0_
print(model1.dense1.prefix)   #model1_dense1_
print(model1.mydense.prefix)  #model1_mydense_

#如下方式保存和加载：model0保存的参数，model1加载会报错
model0.collect_params().save('model.params')
try:
    model1.collect_params().load('model.params', mx.cpu())
except Exception as e:
    print(e)
print(model0.collect_params(), '\n')
print(model1.collect_params())


#如下方式保存和加载：model0保存的参数，model1加载不会报错
model0.save_parameters('model.params')
model1.load_parameters('model.params')
print(mx.nd.load('model.params').keys())

#加载预训练模型，最后一层为1000类别的分类器
alexnet = gluon.model_zoo.vision.alexnet(pretrained=True)
print(alexnet.output)
print(alexnet.output.prefix)

#修改最后一层结构为 100类别的分类器，进行finetune
with alexnet.name_scope():
    alexnet.output = gluon.nn.Dense(100)
alexnet.output.initialize()
print(alexnet.output)

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


net = nn.Sequential()
net.add(nn.Dense(256, activation='relu'))
net.add(nn.Dense(10))
net.initialize()  # Use the default initialization method

x = nd.random.uniform(shape=(2, 20))
net(x)            # Forward computation

print(net[0].params)
print(net[1].params)

#通过属性获取
print(net[1].bias)
print(net[1].bias.data())
print(net[0].weight.grad())
#通过字典方式获取
print(net[0].params['dense0_weight'])
print(net[0].params['dense0_weight'].data())
#获取所有参数
print(net.collect_params())
print(net[0].collect_params())
net.collect_params()['dense1_bias'].data()
#正则匹配
print(net.collect_params('.*weight'))  
print(net.collect_params('dense0.*'))

from mxnet import gluon
import mxnet as mx

class Model(gluon.Block):
    def __init__(self, **kwargs):
        super(Model, self).__init__(**kwargs)
        with self.name_scope():
            self.dense0 = gluon.nn.Dense(20)
            self.dense1 = gluon.nn.Dense(20)
            self.mydense = gluon.nn.Dense(20, prefix='mydense_')

    def forward(self, x):
        x = mx.nd.relu(self.dense0(x))
        x = mx.nd.relu(self.dense1(x))
        return mx.nd.relu(self.mydense(x))

model0 = Model()
model0.initialize()
model0(mx.nd.zeros((1, 20)))

#通过有序字典_children
print(model0._children)
print(model0._children['dense0'].weight._data)
print(model0._children['dense0'].bias._data)

#通过收集所有参数
print(model0.collect_params()['model0_dense0_weight']._data)
print(model0.collect_params()['model0_dense0_bias']._data)

class MyDense(nn.Block):

    def __init__(self, units, in_units, **kwargs):
        # units: the number of outputs in this layer
        # in_units: the number of inputs in this layer

        super(MyDense, self).__init__(**kwargs)
        self.weight = gluon.Parameter('weight', shape=(in_units, units))  #创建名为weight的参数
        self.bias = gluon.Parameter('bias', shape=(units,))    #创建名为bias的参数

    def forward(self, x):
        linear = nd.dot(x, self.weight.data()) + self.bias.data()
        return nd.relu(linear)


net = nn.Sequential()
net.add(MyDense(units=8, in_units=64),
        MyDense(units=1, in_units=8))
#初始化参数
for block in net:
    if hasattr(block, "weight"):
        block.weight.initialize()
    if hasattr(block, "bias"):
        block.bias.initialize()
print(net(nd.random.uniform(shape=(2, 64))))
print(net)

#创建一个parameterdict，包含一个名为param2的parameter
params = gluon.ParameterDict()
params.get('param2', shape=(2, 3))
print(params)
print(params.keys())
print(params['param2'])

class MyInit(init.Initializer):
    def _init_weight(self, name, data):
        print('Init', name, data.shape)
        data[:] = nd.random.uniform(low=-10, high=10, shape=data.shape)
        data *= data.abs() >= 5

net.initialize(MyInit(), force_reinit=True)
net[0].weight.data()[0]

net[0].weight.set_data(net[0].weight.data() + 1)
net[0].weight.data()[0]

作用：根据指定索引，检索出ndarray中的数据
参数：  
pick(data=None, index=None, axis=_Null, keepdims=_Null, mode=_Null, out=None, name=None, **kwargs)  
   data:输入数据，ndarray类型  
   index: 索引，ndarray类型  
   axis：维度  
   keepdims: True时表示输出ndarray保持输入ndarray的维度不变  
   mode: clip表示截断模式，索引超过输入ndarray的尺寸时，截断未最大的尺寸；wrap表示循环模式，索引超过输入ndarray的尺寸时，从开始出循环处理  

import mxnet as mx

x = mx.nd.array([[1.,  2.],
                [3.,  4.],
                [5.,  6.]])
print(mx.nd.pick(x, index=mx.nd.array([0, 1]), axis=0))  #[ 1.,  4.]
print(mx.nd.pick(x, index=mx.nd.array([0, 1, 0]), axis=1))  #[ 1.,  4.,  5.]
print(mx.nd.pick(x, index=mx.nd.array([0, 1, 0]), axis=1, keepdims=True))  #[[1.],[4.],[5.]]
print(mx.nd.pick(x, index=mx.nd.array([2, -1, -2]), axis=1, mode='wrap'))  #[ 1.,  4.,  5.]
print(mx.nd.pick(x, index=mx.nd.array([[1.],[0.],[2.]]), axis=1, keepdims=True))  #[[ 2.],[ 3.],[ 6.]]

作用：求平均值
参数：
mean(data=None, axis=_Null, keepdims=_Null, exclude=_Null, out=None, name=None, **kwargs):
    data: 输入ndarray
    axis：平均的维度，默认情况下会计算ndarray所有值的平均值，返回一个标量
           为int时，如axis=1，只计算1这个维度上的平均值
           为tuple时，如axis=(1, 2), 计算1和2这两个维度上的平均值
    keepdims:输出数据保持输入数据的维度不变
    exclude: 默认为False, 设为True，则计算平均值时，不是axis设置的维度会被计算，如：总共有三个维度(0, 1, 2), axis=0, exclude=True时，会计算1和2这两个维度上的平均值

import mxnet as mx
x = mx.nd.array([[[1.,  2.],[1, 2]],
                [[3.,  4.], [3.,  4.]],
                [[5.,  6.], [5.,  6.]]])  # 3*3*2
print(mx.nd.mean(x, axis=0))
print(mx.nd.mean(x, axis=1))
print(mx.nd.mean(x, axis=2))
print(mx.nd.mean(x, axis=0, exclude=True))
输出信息如下：
[[3. 4.]
 [3. 4.]]
<NDArray 2x2 @cpu(0)>

[[1. 2.]
 [3. 4.]
 [5. 6.]]
<NDArray 3x2 @cpu(0)>

[[1.5 1.5]
 [3.5 3.5]
 [5.5 5.5]]
<NDArray 3x2 @cpu(0)>

[1.5 3.5 5.5]
<NDArray 3 @cpu(0)>

作用：对于多个box进行nms(非最大值抑制)，目标检测时一般要对模型预测的大量检测框进行nms
参数：
box_nms(data=None, overlap_thresh=_Null, valid_thresh=_Null, topk=_Null, coord_start=_Null, score_index=_Null, id_index=_Null, background_id=_Null, force_suppress=_Null, 
              in_format=_Null, out_format=_Null, out=None, name=None, **kwargs)
    data: 输入的Ndarray,包括预测类别,分数和box信息。典型输入ndarray尺寸信息为b*n*k, b为batch(b也可以不设置), n为多少个box, k一般为6,表示box格式为[id, score, xmin, ymin, xmax, ymax]
    overlap_thresh: IOU阈值，默认值为0.5；两个box的重叠面积比例超过阈值时会舍弃掉分数低的
    valid_thresh：分数阈值, 默认值为0；box的score超过阈值时才进行nms处理
    topk：默认值-1，只对分数排序前topk的box进行nms，默认对所有box进行nms
    coord_start：默认为2, box坐标开始的index ([id, score, xmin, ymin, xmax, ymax]中xmin的index为2)
    id_index：默认-1， id的index，-1表示忽略id数据
    background_id：默认-1， 背景的类别id，-1表示忽略。(若设为0，则进行nms时，id=0的box不进行nms)
    force_suppress：默认0， 当force_suppress=0, id_index!=-1时，只会对id属于同一类别的box进行nms
    in_format: 默认为'corner'；'corner'表示输入数据box是[id, score, xmin, ymin, xmax, ymax]; 'center'表示输入数据box是[id, score, x_center, y_center, width, height]
    out_format: 输出数据box的格式, 默认'corner'

ids = mx.nd.array([[0], [1], [0], [2]])  #4x1
scores = mx.nd.array([[0.5], [0.4], [0.3], [0.6]])  #4x1
bboxs = mx.nd.array([[10., 10., 20., 20],
                     [10., 10., 20., 20],
                     [10., 10., 14., 14],
                     [50., 50., 70., 80.]])  #4x4
x = mx.nd.concat(ids, scores, bboxs, dim=-1) #4*6
print(x)

result1 = mx.nd.contrib.box_nms(x, overlap_thresh=0.1, coord_start=2, score_index=1, id_index=-1,
        force_suppress=True, in_format='corner', out_format='corner')
print(result1)

result2 = mx.nd.contrib.box_nms(x, overlap_thresh=0.1, coord_start=2, score_index=1, id_index=0,
        force_suppress=False, in_format='corner', out_format='corner')
print(result2)

输出结果：
[[ 0.   0.5 10.  10.  20.  20. ]
 [ 1.   0.4 10.  10.  20.  20. ]
 [ 0.   0.3 10.  10.  14.  14. ]
 [ 2.   0.6 50.  50.  70.  80. ]]
<NDArray 4x6 @cpu(0)>

[[ 2.   0.6 50.  50.  70.  80. ]
 [ 0.   0.5 10.  10.  20.  20. ]
 [-1.  -1.  -1.  -1.  -1.  -1. ]
 [-1.  -1.  -1.  -1.  -1.  -1. ]]
<NDArray 4x6 @cpu(0)>

[[ 2.   0.6 50.  50.  70.  80. ]
 [ 0.   0.5 10.  10.  20.  20. ]
 [ 1.   0.4 10.  10.  20.  20. ]
 [-1.  -1.  -1.  -1.  -1.  -1. ]]
<NDArray 4x6 @cpu(0)>