MXNet动手学深度学习笔记：ResNet实现

#coding:utf-8
'''
ResNet
'''
from mxnet.gluon import nn
from mxnet import nd
import sys
import os
sys.path.append(os.getcwd())
import utils
from mxnet import gluon
from mxnet import init

class Residual(nn.Block):
def __init__(self,channels,same_shape=True,**kwargs):
super(Residual,self).__init__(**kwargs)

self.same_shape = same_shape
strides = 1 if same_shape else 2

self.conv1 = nn.Conv2D(channels,kernel_size=3,
padding=1,strides=strides)
self.bn1 = nn.BatchNorm()

self.conv2 = nn.Conv2D(channels,kernel_size=3,
padding=1)
self.bn2 = nn.BatchNorm()

if not same_shape:
self.conv3 = nn.Conv2D(channels,kernel_size=1,
strides=strides)

def forward(self,x):
out = nd.relu(self.bn1(self.conv1(x)))
out = self.bn2(self.conv2(out))

if not self.same_shape:
x = self.conv3(x)

return nd.relu(out+x)

blk = Residual(3)
blk.initialize()

x = nd.random.uniform(shape=(4,3,6,6))
result = blk(x)
print(result.shape)

blk2 = Residual(8,same_shape=False)
blk2.initialize()
result = blk2(x)
print(result.shape)

class ResNet(nn.Block):
def __init__(self,num_class,verbose = False,**kwargs):
super(ResNet,self).__init__(**kwargs)
self.verbose = verbose
with self.name_scope():
# block 1
b1 = nn.Conv2D(64,kernel_size=7,strides=2)
# block 2
b2 = nn.Sequential()
b2.add(
nn.MaxPool2D(pool_size=3,strides=2),
Residual(64),
Residual(64)
)

# block 3
b3 = nn.Sequential()
b3.add(
Residual(128,same_shape=False),
Residual(128)
)

# block 4
b4 = nn.Sequential()
b4.add(
Residual(256,same_shape=False),
Residual(256)
)

# block 5
b5 = nn.Sequential()
b5.add(
Residual(512,same_shape=False),
Residual(512)
)

# block 6
b6 = nn.Sequential()
b6.add(
nn.AvgPool2D(pool_size=3),
nn.Dense(num_class))

self.net = nn.Sequential()
self.net.add(b1,b2,b3,b4,b5,b6)

def forward(self,x):
out = x
for i ,b in enumerate(self.net):
out = b(out)
if self.verbose:
print('Block %d output: %s'%(i+1, out.shape))
return out

net = ResNet(10, verbose=True)
net.initialize()
x = nd.random.uniform(shape=(4, 3, 96, 96))
y = net(x)
print(y)

train_data, test_data = utils.load_data_fashion_mnist(batch_size=64, resize=96)
ctx = utils.try_gpu()
net = ResNet(10)
net.initialize(ctx=ctx, init=init.Xavier())
loss = gluon.loss.SoftmaxCrossEntropyLoss()
trainer = gluon.Trainer(net.collect_params(),'sgd', {'learning_rate': 0.05})
utils.train(train_data, test_data, net, loss,trainer, ctx, num_epochs=5)