def test_stblock(self):
from model.base_layers import St_conv_block, Output_layer
num_of_vertices = 228
cheb_polys = nd.random_uniform(shape=(num_of_vertices,
num_of_vertices * 3))
net = gluon.nn.Sequential()
net.add(St_conv_block(3, 3, [1, 32, 64], 1.0, cheb_polys),
St_conv_block(3, 3, [64, 32, 128], 1.0, cheb_polys),
Output_layer(128, 4))
net.initialize()
x = nd.random_uniform(shape=(8, 1, 12, num_of_vertices))
o = net(x)
y = nd.random_uniform(shape=o.shape)
trainer = gluon.Trainer(net.collect_params(), 'adam')
trainer.set_learning_rate(1e-3)
loss = gluon.loss.L2Loss()
with autograd.record():
l = loss(net(x), y)
l.backward()
trainer.step(8)
self.assertEqual((8, 1, 1, num_of_vertices), o.shape)
self.assertIsInstance(l.mean().asscalar().item(), float)
def test_stgcn(self):
from model import base_model
ctx = mx.gpu(1)
num_of_vertices = 228
batch_size = 8
cheb_polys = nd.random_uniform(shape=(num_of_vertices,
num_of_vertices * 3),
ctx=ctx)
blocks = [[1, 32, 64], [64, 32, 128]]
x = nd.random_uniform(shape=(batch_size, 1, 12, num_of_vertices),
ctx=ctx)
y = nd.random_uniform(shape=(batch_size, 1, 1, num_of_vertices),
ctx=ctx)
net = base_model.STGCN(12, 3, 3, blocks, 1.0, cheb_polys)
net.initialize(ctx=ctx)
self.assertEqual((batch_size, 1, 1, num_of_vertices), net(x).shape)
trainer = gluon.Trainer(net.collect_params(), 'adam')
trainer.set_learning_rate(1e-3)
loss = gluon.loss.L2Loss()
for i in range(5):
with autograd.record():
l = loss(net(x), y)
l.backward()
trainer.step(batch_size)
self.assertIsInstance(l.mean().asscalar().item(), float)
print(l.mean().asscalar())
def test_evaluate(self):
from model import hybrid_model
from model import trainer
from data_loader.data_utils import data_gen
import numpy as np
from mxboard import SummaryWriter
import os
import shutil
ctx = mx.gpu(1)
num_of_vertices = 897
batch_size = 50
PeMS_dataset = data_gen('datasets/PeMSD7_V_897.csv', 24)
print('>> Loading dataset with Mean: {0:.2f}, STD: {1:.2f}'.format(
PeMS_dataset.mean, PeMS_dataset.std))
test = PeMS_dataset['test'].transpose((0, 3, 1, 2))
test_x, test_y = test[:100, :, :12, :], test[:100, :, 12:, :]
test_loader = gluon.data.DataLoader(gluon.data.ArrayDataset(
nd.array(test_x), nd.array(test_y)),
batch_size=batch_size,
shuffle=False)
print(test_x.shape, test_y.shape)
cheb_polys = nd.random_uniform(shape=(num_of_vertices,
num_of_vertices * 3))
blocks = [[1, 32, 64], [64, 32, 128]]
x = nd.random_uniform(shape=(batch_size, 1, 12, num_of_vertices),
ctx=ctx)
net = hybrid_model.STGCN(12, 3, 3, blocks, 1.0, num_of_vertices,
cheb_polys)
net.initialize(ctx=ctx)
net.hybridize()
net(x)
ground_truth = (
np.concatenate([y.asnumpy() for x, y in test_loader], axis=0) *
PeMS_dataset.std + PeMS_dataset.mean)[:100]
if os.path.exists('test_logs'):
shutil.rmtree('test_logs')
sw = SummaryWriter('test_logs', flush_secs=5)
trainer.evaluate(net, ctx, ground_truth, test_loader, 12,
PeMS_dataset.mean, PeMS_dataset.std, sw, 0)
self.assertEqual(os.path.exists('test_logs'), True)
sw.close()
if os.path.exists('test_logs'):
shutil.rmtree('test_logs')
def query(self, image_text_pairs):
if self.pool_size == 0:
return image_text_pairs
ret_images = []
ret_text_feats = []
images, text_feats = image_text_pairs
for i in range(images.shape[0]):
image = nd.expand_dims(images[i], axis=0)
text_feat = nd.expand_dims(text_feats[i], axis=0)
if self.num_imgs < self.pool_size:
self.num_imgs = self.num_imgs + 1
self.images.append(image)
self.text_feats.append(text_feat)
ret_images.append(image)
ret_text_feats.append(text_feat)
else:
p = nd.random_normal(0, 1, shape=(1, )).asscalar()
if p < 0.5:
random_index = nd.random_uniform(0, self.pool_size-1, shape=(1, )).astype(np.uint8).asscalar()
tmp_img = self.images[random_index].copy()
tmp_text_feat = self.text_feats[random_index].copy()
self.images[random_index] = image
self.text_feats[random_index] = text_feat
ret_images.append(tmp_img)
ret_text_feats.append(tmp_text_feat)
else:
ret_images.append(image)
ret_text_feats.append(text_feat)
ret_images = nd.concat(*ret_images, dim=0)
ret_text_feats = nd.concat(*ret_text_feats, dim=0)
return [ret_images, ret_text_feats]
def test_predict2():
from model.astgcn import ASTGCN
from model.model_config import get_backbones
import mxnet as mx
ctx = mx.cpu()
all_backbones = get_backbones('configurations/PEMS08.conf',
'data/PEMS08/distance.csv', ctx)
net = ASTGCN(12, all_backbones)
net.initialize(ctx=ctx)
test_w = nd.random_uniform(shape=(8, 170, 3, 12), ctx=ctx)
test_d = nd.random_uniform(shape=(8, 170, 3, 12), ctx=ctx)
test_r = nd.random_uniform(shape=(8, 170, 3, 36), ctx=ctx)
output = net([test_w, test_d, test_r])
assert output.shape == (8, 170, 12)
assert type(output.mean().asscalar()) == np.float32
def test_anchor(h=40, w=40):
x = nd.random_uniform(shape=(1, 3, h, w))
y = MultiBoxPrior(x, sizes=[0.5, 0.25, 0.1], ratios=[1, 2, 0.5])
boxes = y.reshape((h, w, -1, 4))
print('The first anchor box at row 21, column 21:', boxes[20, 20, 0, :])
return boxes
def Initial(self):
# Initail your session or somethingself.target_net
# restore neural net parameters
# self.buffer_size = 0
self.ctx = try_gpu(GPU_INDEX)
self.frame_cnt = 0
self.train_count = 0
self.loss_sum = 0
self.q_count = 0
self.q_sum = 0
self.dtype = DTYPE
INPUT_SAMPLE = nd.random_uniform(0,1,(1, FRAME_SKIP, 11), self.ctx, self.dtype)
self.target_net = self.get_net(INPUT_SAMPLE)
self.policy_net = self.get_net(INPUT_SAMPLE)
if MODEL_FILE is not None:
print('%s: read trained results from [%s]' % (tm.strftime("%Y-%m-%d %H:%M:%S"), MODEL_FILE))
self.policy_net.load_params(MODEL_FILE, ctx=self.ctx)
self.update_target_net()
# adagrad
self.trainer = Trainer(self.policy_net.collect_params(),
optimizer=mx.optimizer.RMSProp(LEARNING_RATE, 0.95, 0.95))
self.loss_func = loss.L2Loss()
self.epsilon = EPSILON_START
self.epsilon_min = EPSILON_MIN
self.epsilon_rate = (EPSILON_START - EPSILON_MIN) / EPSILON_DECAY
self.rng = np.random.RandomState(int(time() * 1000) % 100000000)
def dropout(X, drop_prob):
keep_prob = 1.0 - drop_prob
mask = nd.random_uniform(0, 1.0, X.shape, ctx=X.context) < keep_prob
if keep_prob > 0.0:
scale = (1 / keep_prob)
else:
scale = 0.0
return mask * X * scale
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
scale = 1 / keep_probability
return mask * X * scale
def test_cpu(self):
x = nd.random_uniform(0, 1, (10000, ))
start = time.time()
c = 0.1
for i in range(10000):
x += c
t = time.time() - start
print(x)
print("time: " + str(t))
def dropout(X, drop_probability):
keep_probability = 1 - drop_probability
mask = nd.random_uniform(0, 1.0, X.shape, ctx=X.context) < keep_probability
#############################
# Avoid division by 0 when scaling
#############################
if keep_probability > 0.0:
scale = (1 / keep_probability)
else:
scale = 0.0
return mask * X * scale
def main():
parse = argparse.ArgumentParser()
parse.add_argument('--epoches', type=int, default=10)
args = parse.parse_args()
net = model.ASENet(10)
net.initialize(mx.init.Xavier())
net.hybridize()
#print(net)
rgb = nd.random_uniform(0, 1, (1, 3, 512, 512))
depth = nd.random_uniform(0, 1, (1, 1, 512, 512))
y1, y2, y3, y4, y5 = net(rgb, depth)
#y1, y2 = net(rgb, depth)
print('y1.shape: ', y1.shape)
print('y2.shape: ', y2.shape)
print('y3.shape: ', y3.shape)
print('y4.shape: ', y4.shape)
print('y5.shape: ', y5.shape)
def test_predict(self):
from model import hybrid_model
from model import trainer
ctx = mx.gpu(1)
num_of_vertices = 228
batch_size = 8
cheb_polys = nd.random_uniform(shape=(num_of_vertices,
num_of_vertices * 3),
ctx=ctx)
blocks = [[1, 32, 64], [64, 32, 128]]
x = nd.random_uniform(shape=(batch_size, 1, 12, num_of_vertices))
net = hybrid_model.STGCN(12, 3, 3, blocks, 1.0, num_of_vertices,
cheb_polys)
net.initialize(ctx=ctx)
net.hybridize()
y = trainer.predict_batch(net, ctx, x, 12)
self.assertEqual(y.shape, (batch_size, 1, 12, num_of_vertices))
def forward(self, is_train, req, in_data, out_data, aux):
x = in_data[0]
if is_train:
self._spatial_dropout_mask = nd.broadcast_greater(
nd.random_uniform(low=0, high=1, shape=(1, self._num_filters, 1, 1), ctx=self._ctx),
nd.ones(shape=(1, self._num_filters, 1, 1), ctx=self._ctx) * self._p,
ctx=self._ctx
)
y = nd.broadcast_mul(x, self._spatial_dropout_mask, ctx=self._ctx) / (1 - self._p)
self.assign(out_data[0], req[0], y)
else:
self.assign(out_data[0], req[0], x)
def query(self, images):
if self.pool_size == 0:
return images
ret_imgs = []
for i in range(images.shape[0]):
image = nd.expand_dims(images[i], axis=0)
if self.num_imgs < self.pool_size:
self.num_imgs = self.num_imgs + 1
self.images.append(image)
ret_imgs.append(image)
else:
p = nd.random_uniform(0, 1, shape=(1,)).asscalar()
if p > 0.5:
random_id = nd.random_uniform(0, self.pool_size - 1, shape=(1,)).astype(np.uint8).asscalar()
tmp = self.images[random_id].copy()
self.images[random_id] = image
ret_imgs.append(tmp)
else:
ret_imgs.append(image)
ret_imgs = nd.concat(*ret_imgs, dim=0)
return ret_imgs
def test_ASTGCN_submodule():
from model.astgcn import ASTGCN_submodule
x = nd.random_uniform(shape=(32, 307, 3, 24))
K = 3
cheb_polynomials = [nd.random_uniform(shape=(307, 307)) for i in range(K)]
backbone = [{
"K": K,
"num_of_chev_filters": 64,
"num_of_time_filters": 64,
"time_conv_strides": 2,
"cheb_polynomials": cheb_polynomials
}, {
"K": K,
"num_of_chev_filters": 64,
"num_of_time_filters": 64,
"time_conv_strides": 1,
"cheb_polynomials": cheb_polynomials
}]
net = ASTGCN_submodule(12, backbone)
net.initialize()
output = net(x)
assert output.shape == (32, 307, 12)
assert type(output.mean().asscalar()) == np.float32
def dropout(X, drop_probability):
keep_probability = 1 - drop_probability
assert 0 <= keep_probability <= 1
if keep_probability == 0:
return X.zeros_like()
# uniform生成 0 ～ 1均匀分布的数值（是否保留的概率），
# 然后在于keep_probability（概率阀值）进行比较，如果为true则当前位置的元素为1，否则为0
mask = nd.random_uniform(0, 1.0, X.shape, ctx=X.context) < keep_probability
# 伸缩变换
scale = 1 / keep_probability
# 最后返回mask之后的X，注意除此之外数值的范围进行伸缩变换
return mask * X * scale
def _init_weight(self, _, arr):
#初始化权重，使用out=arr后不需指定形状
nd.random_uniform(low=5, high=10, out=arr)
from mxnet import nd
from mxnet.gluon import nn
net = nn.Sequential()
with net.name_scope():
net.add(nn.Dense(256, activation='relu'))
net.add(nn.Dense(10))
print(net)
# 使用nn.Block来定义
class MLP(nn.Block):
def __init__(self, **kwargs):
super(MLP, self).__init__(**kwargs)
with self.name_scope():
self.dense0 = nn.Dense(256)
self.dense1 = nn.Dense(10) # 输出为10
# 定义网络的计算 Dense0->relu->Dense1
def forward(self, x):
return self.dense1(nd.relu(self.dense0(x)))
net2 = MLP()
print(net2)
net2.initialize()
x = nd.random_uniform(shape=(4, 20)) # 输入为4
y = net2(x)
print(y) # 输入为4，输出为10
import mxnet as mx
from mxnet import nd
from mxnet.contrib.ndarray import MultiBoxPrior
import matplotlib.pyplot as plt
n = 40
# shape: batch x channel x height x weight
x = nd.random_uniform(shape=(1, 3, n, n))
y = MultiBoxPrior(x, sizes=[.5, .25, .1], ratios=[1, 2, .5])
# the first anchor box generated for pixel at (20,20)
# its format is (x_min, y_min, x_max, y_max)
boxes = y.reshape((n, n, -1, 4))
print('The first anchor box at row 21, column 21:', boxes[20, 20, 0, :])
from mxnet.gluon import nn
def class_predictor(num_anchors, num_classes):
"""return a layer to predict classes"""
return nn.Conv2D(num_anchors * (num_classes + 1), 3, padding=1)
cls_pred = class_predictor(5, 10)
cls_pred.initialize()
x = nd.zeros((2, 3, 20, 20))
print('Class prediction', cls_pred(x).shape)
def box_predictor(num_anchors):
"""return a layer to predict delta locations"""
return nn.Conv2D(num_anchors * 4, 3, padding=1)
box_pred = box_predictor(10)
out = nn.Sequential()
for _ in range(num_convs):
out.add(
nn.Conv2D(channels=channel,
kernel_size=3,
padding=1,
activation='relu'))
out.add(nn.MaxPool2D(pool_size=2, strides=2))
return out
blk = vggBlock(2, 128)
blk.initialize()
x = nd.random_uniform(shape=(2, 3, 16, 16))
y = blk(x)
print(y.shape)
# define VGG11
def vggStack(architecture):
out = nn.Sequential()
for (num_convs, channel) in architecture:
out.add(vggBlock(num_convs, channel))
return out
num_outputs = 10
architecture = ((1, 64), (1, 128), (2, 256), (2, 256), (2, 512))
net = nn.Sequential()
super(DenseBlock, self).__init__(**kwargs)
self.net = nn.Sequential()
for i in range(layers):
self.net.add(conv_block(growth_rate))
def forward(self, x):
for layers in self.net:
out = layers(x)
x = nd.concat(x, out, dim=1)
return x
dblk = DenseBlock(2, 10)
dblk.initialize()
x = nd.random_uniform(shape=(4, 3, 8, 8))
print(dblk(x).shape)
# Transition Block
def transition_block(channels):
out = nn.Sequential()
out.add(nn.BatchNorm(), nn.Activation('relu'),
nn.Conv2D(channels, kernel_size=1),
nn.AvgPool2D(pool_size=2, strides=2))
return out
tblk = transition_block(10)
tblk.initialize()
return nd.dot(final_conv_output, self.final_fc_weight.data()) + self.final_fc_bias.data()
if __name__ == "__main__":
ctx = mx.cpu()
distance_df = pd.read_csv('../data/METR-LA/preprocessed/distance.csv', dtype={'from': 'int', 'to': 'int'})
num_of_vertices = 207
A = get_adjacency_matrix(distance_df, num_of_vertices, 0.1)
L_tilde = scaled_Laplacian(A)
cheb_polys = [nd.array(i, ctx = ctx) for i in cheb_polynomial(L_tilde, 3)]
backbones = [
{
'num_of_time_conv_filters1': 64,
'num_of_time_conv_filters2': 64,
'K_t': 3,
'num_of_cheb_filters': 32,
'K': 3,
'cheb_polys': cheb_polys
},
{
'num_of_time_conv_filters1': 64,
'num_of_time_conv_filters2': 64,
'K_t': 3,
'num_of_cheb_filters': 32,
'K': 3,
'cheb_polys': cheb_polys
}]
net = STGCN(backbones, 64)
net.initialize(ctx = ctx)
print(net(nd.random_uniform(shape = (16, 1, 207, 12))).shape)
#!/usr/bin/env python
#-*- coding:utf-8 -*-
import mxnet as mx
from mxnet import nd
from mxnet.contrib.ndarray import MultiBoxPrior##MultiBoxPrior产生预设框
n = 40
# 输入形状: batch × channel × height × weight
x = nd.random_uniform(shape=(1, 3, n, n))
## 图像 n 个预设尺寸 m 个预设的长宽比 输出为 n+m-1 个方框
y = MultiBoxPrior(x, sizes=[.5, .25, .1], ratios=[1, 2, .5])
## 取位于 (20,20) 像素点的第一个预设框
# box的格式为 (x_min, y_min, x_max, y_max) 且为比例
boxes = y.reshape((n, n, -1, 4))
print('The first anchor box at row 21, column 21:', boxes[20, 20, 0, :])
import matplotlib.pyplot as plt
#"""convert an anchor box to a matplotlib rectangle"""
def box_to_rect(box, color, linewidth=3):
box = box.asnumpy()
return plt.Rectangle(
(box[0], box[1]), (box[2]-box[0]), (box[3]-box[1]),
fill=False, edgecolor=color, linewidth=linewidth)
colors = ['blue', 'green', 'red', 'black', 'magenta']# 3+3-1=5个
plt.imshow(nd.ones((n, n, 3)).asnumpy())
anchors = boxes[20, 20, :, :]
for i in range(anchors.shape[0]):
plt.gca().add_patch(box_to_rect(anchors[i,:]*n, colors[i]))
plt.show()
activation='relu')
self.p4_pool_1 = nn.MaxPool2D(pool_size=3, padding=1, strides=1)
self.p4_conv_2 = nn.Conv2D(n4, kernel_size=1, activation='relu')
def forward(self, x):
p1 = self.p1_conv_1(x)
p2 = self.p2_conv_2(self.p2_conv_1(x))
p3 = self.p3_conv_2(self.p3_conv_1(x))
p4 = self.p4_conv_2(self.p4_pool_1(x))
return nd.Concat(p1, p2, p3, p4, dim=1)
incp = Inception(64, 96, 128, 16, 32, 32)
incp.initialize()
x = nd.random_uniform(shape=(32, 3, 64, 64))
print(incp(x).shape)
# define GoogLeNet
class GoogLeNet(nn.Block):
def __init__(self, num_classes, verbose=False, **kwargs):
super(GoogLeNet, self).__init__(**kwargs)
self.verbose = verbose
with self.name_scope():
b1 = nn.Sequential()
b1.add(
nn.Conv2D(64,
kernel_size=7,
strides=2,
padding=3,
def train(epoch, train_loader, model,loss, optimizer, opt,ctx,train_loss,train_iou):
"""
one epoch training for program executor
"""
loss_sum,iou_sum,n = 0.0,0.0,0
for idx, data in enumerate(train_loader):
start_t = time.time()
shape, label, param = data
bsz = shape.shape[0]
n_step = label.shape[1]
#print("label.shape:",label)
#print("n_step:",n_step,"bsz:",bsz,"stop_id:",stop_id)
index = np.array(list(map(lambda x: n_step, label)))-1
#index = label
# add noise during training, making the executor accept
# continuous output from program generator
label = label.reshape(-1,1).asnumpy()
pgm_vector = 0.2 * np.random.uniform(0,1,(bsz * n_step, stop_id))
pgm_noise = 0.2 *np.random.uniform(0,1,label.shape)
pgm_value = 1 - pgm_noise
#print('pgm_val.shape:',pgm_value.shape,'label.shape:',label.shape,'label.shape:',label.shape)
pgm_vector = scatter_numpy(pgm_vector,1,label,pgm_value).reshape(bsz,n_step,stop_id)
param_noise = nd.random_uniform(0,1,shape=param.shape)
param_vector = param + 0.6 * (param_noise - 0.5)
#print("param_vector.shape:",param_vector.shape)
gt = shape.as_in_context(ctx)
#print(pgm_vector.dtype)
index = nd.from_numpy(index).astype('int64').as_in_context(ctx)
pgm_vector = nd.from_numpy(pgm_vector).astype('float32').as_in_context(ctx)
param_vector = param_vector.as_in_context(ctx)
with autograd.record():
pred = model(pgm_vector, param_vector, index)
scores = nd.log_softmax(pred,axis=1)
pred0 = scores[:,0].squeeze()*opt.n_weight
pred1 = scores[:,1].squeeze()*opt.p_weight
l = -nd.where(gt, pred1, pred0).mean((1,2,3))
#l = -(nd.pick(scores1, gt, axis=1, keepdims=True)*opt.n_weight
# +nd.pick(scores2,(1-gt), axis=1, keepdims=True)*opt.p_weight).mean((1,2,3,4))
l.backward()
#clip_gradient(optimizer, opt.grad_clip)
#optimizer._allreduce_grads();
optimizer.step(l.shape[0],ignore_stale_grad=True)
l = l.mean().asscalar()
pred = nd.softmax(pred,axis = 1)
pred = pred[:, 1, :, :, :]
s1 = gt.reshape(-1, 32, 32, 32).astype('float32').as_in_context(mx.cpu())
s2 = pred.squeeze().as_in_context(mx.cpu())
#print(s2.shape)
s2 = (s2 > 0.5)
batch_iou = BatchIoU(s1, s2)
iou = batch_iou.mean()
end_t = time.time()
loss_sum+=l
n+=1
iou_sum+=iou
if idx % (opt.info_interval * 10) == 0:
print("Train: epoch {} batch {}/{}, loss13 = {:.3f}, iou = {:.3f}, time = {:.3f}"
.format(epoch, idx, len(train_loader), l, iou, end_t - start_t))
sys.stdout.flush()
train_loss.append(loss_sum/n)
train_iou.append(iou_sum/n)
layer3 = self.layer3(layer2)
layer4 = self.layer4(layer3)
flattened = self.flatten(layer4)
dropout1 = self.dropout1(self.denselayer1(flattened))
dense2 = self.denselayer2(dropout1)
outputs = self.outputlayer(dense2)
return outputs
# for test the model
if __name__ == '__main__':
net = ResNet3D(10)
net.initialize(mx.init.Xavier())
net.hybridize()
x = nd.random_uniform(0, 1,
shape=(1, 1, 200, 9,
9)) # the shape is same as training samples
y = net(x)
print(y.shape) # output (1, 10)
'''
net = gluon.nn.Sequential()
net.add(gluon.nn.Conv3D(16, (3, 3, 3), padding=(1, 1, 1), activation='relu')) # layout: NCDHW, weight's shape: (out_channels, input_channels, 3, 3, 3)
net.initialize()
#x = nd.random_uniform(0, 1, shape=(1, 1, 200, 9, 9)) # output: (1, 16, 200, 9, 9)
x = nd.random_uniform(0, 1, shape=(1, 1, 200, 9, 9)) # output: (1, 16, 200, 9, 9)
y = net(x)
print(net.collect_params())
print(y.shape)
'''
import numpy as np
from mxnet import nd
data_in = nd.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
print(data_in)
kernel = nd.array([[0, 1], [2, 3]])
net = gluon.nn.Sequential()
net.add(gluon.nn.Conv2D(channels=1, kernel_size=(3, 3), strides=(1, 1)),
gluon.nn.MaxPool2D())
net.initialize()
x = nd.random_uniform(shape=(1, 1, 10, 10))
y = net(x)
print(net[0].params)
print(net[0].weight)
print(net[0].weight.data())
print('x = ', x)
print('y = ', y)
Decov = gluon.nn.Sequential()
Decov.add(gluon.nn.Conv2DTranspose(channels=1, kernel_size=(4, 4), strides=(2, 2)))
Decov.initialize()
y_ = Decov(y)
nn.Conv2D(256, kernel_size=5, padding=2, activation="relu"),
nn.MaxPool2D(pool_size=3, strides=2),
nn.BatchNorm(),
# 13*13*256
nn.Conv2D(384, padding=1, kernel_size=3, activation="relu"),
nn.Conv2D(384, padding=1, kernel_size=3, activation="relu"),
nn.Conv2D(256, kernel_size=3, padding=1, activation="relu"),
nn.MaxPool2D(pool_size=3, strides=2),
# fc 1
nn.Dense(4096, activation="relu"),
nn.Dropout(.5),
nn.Dense(4096, activation="relu"),
nn.Dropout(0.5),
nn.Dense(10))
net.initialize()
x = nd.random_uniform(shape=[1, 1, 224, 224])
print(net(x))
def load_data_fashion_mnist(batch_size,
resize=None,
root=os.path.join('~', '.mxnet', 'datasets',
'fashion-mnist')):
root = os.path.expanduser(root) # 展开用户路径 '~'。
transformer = []
if resize:
transformer += [gdata.vision.transforms.Resize(resize)]
transformer += [gdata.vision.transforms.ToTensor()]
transformer = gdata.vision.transforms.Compose(transformer)
mnist_train = gdata.vision.FashionMNIST(root=root, train=True)
mnist_test = gdata.vision.FashionMNIST(root=root, train=False)
out = nd.reshape(in_data, shape=(0, 0, -4, -1, factor,
-2)) # -4后面的两个参数表明h维被分割成h/2和2(factor)了
#print('out shape = ', out.shape) # 1, 3, 208, 2, 416
out = nd.transpose(out, axes=(0, 1, 3, 2, 4))
#print('out shape = ', out.shape) # 1, 3, 2, 208, 416
out = nd.reshape(out, shape=(0, -3, -1, -2))
#print('out shape = ', out.shape) # 1, 6, 208, 416
out = nd.reshape(out, shape=(0, 0, 0, -4, -1, factor))
#print('out shape = ', out.shape) # 1, 6, 208, 208, 2
out = nd.transpose(out, axes=(0, 1, 4, 2, 3))
#print('out shape = ', out.shape) # 1, 6, 2, 208, 208
out = nd.reshape(out, shape=(0, -3, -1, -2)) # output: 1, 12, 208, 208
return out
x = nd.random_uniform(shape=(1, 3, 416, 416))
#x = mx.symbol.var('data')
print('x type = ', type(x))
#y = model.stack_neightbor(x)
#y = test_stack_neightbor(x)
# test the net
y = net(x) # correct, y = (1, 125, 13, 13)
print('y type = ', type(y))
print('y = ', y)
print('y shape = ', y.shape)
y = net(nd.random.uniform(shape=(4, 8)))
print(y.mean())
params = gluon.ParameterDict(prefix='block1_')
params.get("param2", shape=(2, 3))
print(params)
class MyDense(nn.Block):
def __init__(self, units, in_units, prefix=None, params=None):
super().__init__(prefix, params)
with self.name_scope():
self.weight = self.params.get('weight', shape=(in_units, units))
self.bias = self.params.get('bias', shape=(units,))
def forward(self, x):
linear = nd.dot(x, self.weight.data()) + self.bias.data()
return nd.relu(linear)
dense = MyDense(5, in_units = 10, prefix='o_my_dense_')
print(dense.params)
dense.initialize()
dense(nd.random_uniform(shape=(2, 10)))
net = nn.Sequential()
with net.name_scope():
net.add(MyDense(32, in_units=64))
net.add(MyDense(2, in_units=32))
net.initialize()
net(nd.random.uniform(shape=(2, 64)))
