def test_resnet50_quant():
set_seed(1)
context.set_context(mode=context.GRAPH_MODE, device_target="Ascend")
config = config_quant
print("training configure: {}".format(config))
epoch_size = config.epoch_size
# define network
net = resnet50_quant(class_num=config.class_num)
net.set_train(True)
# define loss
if not config.use_label_smooth:
config.label_smooth_factor = 0.0
loss = CrossEntropy(smooth_factor=config.label_smooth_factor,
num_classes=config.class_num)
#loss_scale = FixedLossScaleManager(config.loss_scale, drop_overflow_update=False)
# define dataset
dataset = create_dataset(dataset_path=dataset_path,
config=config,
repeat_num=1,
batch_size=config.batch_size)
step_size = dataset.get_dataset_size()
# convert fusion network to quantization aware network
quantizer = QuantizationAwareTraining(bn_fold=True,
per_channel=[True, False],
symmetric=[True, False])
net = quantizer.quantize(net)
# get learning rate
lr = Tensor(
get_lr(lr_init=config.lr_init,
lr_end=0.0,
lr_max=config.lr_max,
warmup_epochs=config.warmup_epochs,
total_epochs=config.epoch_size,
steps_per_epoch=step_size,
lr_decay_mode='cosine'))
# define optimization
opt = Momentum(filter(lambda x: x.requires_grad, net.get_parameters()), lr,
config.momentum, config.weight_decay, config.loss_scale)
# define model
#model = Model(net, loss_fn=loss, optimizer=opt, loss_scale_manager=loss_scale, metrics={'acc'})
model = Model(net, loss_fn=loss, optimizer=opt)
print("============== Starting Training ==============")
monitor = Monitor(lr_init=lr.asnumpy(),
step_threshold=config.step_threshold)
callbacks = [monitor]
model.train(epoch_size,
dataset,
callbacks=callbacks,
dataset_sink_mode=False)
print("============== End Training ==============")
expect_avg_step_loss = 2.40
avg_step_loss = np.mean(np.array(monitor.losses))
print("average step loss:{}".format(avg_step_loss))
assert avg_step_loss < expect_avg_step_loss
get_lr(global_step=0,
lr_init=0,
lr_end=0,
lr_max=config_gpu.lr,
warmup_epochs=config_gpu.warmup_epochs,
total_epochs=epoch_size,
steps_per_epoch=step_size))
opt = Momentum(filter(lambda x: x.requires_grad,
net.get_parameters()), lr, config_gpu.momentum,
config_gpu.weight_decay, config_gpu.loss_scale)
# define model
model = Model(net,
loss_fn=loss,
optimizer=opt,
loss_scale_manager=loss_scale)
cb = [Monitor(lr_init=lr.asnumpy())]
ckpt_save_dir = config_gpu.save_checkpoint_path + "ckpt_" + str(
get_rank()) + "/"
if config_gpu.save_checkpoint:
config_ck = CheckpointConfig(
save_checkpoint_steps=config_gpu.save_checkpoint_epochs *
step_size,
keep_checkpoint_max=config_gpu.keep_checkpoint_max)
ckpt_cb = ModelCheckpoint(prefix="mobilenetV3",
directory=ckpt_save_dir,
config=config_ck)
cb += [ckpt_cb]
# begine train
model.train(epoch_size, dataset, callbacks=cb)
def strided_slice(nptype):
context.set_context(mode=context.GRAPH_MODE, device_target='GPU')
x = Tensor(np.arange(0, 2 * 3 * 4 * 5).reshape(2, 3, 4, 5).astype(nptype))
y = P.StridedSlice()(x, (1, 0, 0, 2), (2, 2, 2, 4), (1, 1, 1, 1))
expect = np.array([[[[62, 63], [67, 68]], [[82, 83],
[87, 88]]]]).astype(nptype)
assert np.allclose(y.asnumpy(), expect)
y = P.StridedSlice()(x, (1, 0, 0, 5), (2, 2, 2, 1), (1, 1, 1, -2))
expect = np.array([[[[64, 62], [69, 67]], [[84, 82],
[89, 87]]]]).astype(nptype)
assert np.allclose(y.asnumpy(), expect)
y = P.StridedSlice()(x, (1, 0, 0, -1), (2, 2, 2, 1), (1, 1, 1, -1))
expect = np.array([[[[64, 63, 62], [69, 68, 67]],
[[84, 83, 82], [89, 88, 87]]]]).astype(nptype)
assert np.allclose(y.asnumpy(), expect)
y = P.StridedSlice()(x, (1, 0, -1, -2), (2, 2, 0, -5), (1, 1, -1, -2))
expect = np.array([[[[78, 76], [73, 71], [68, 66]],
[[98, 96], [93, 91], [88, 86]]]]).astype(nptype)
assert np.allclose(y.asnumpy(), expect)
# ME Infer fault
# y = P.StridedSlice(begin_mask=0b1000, end_mask=0b0010)(x, (1, 0, 0, 2), (2, 2, 2, 4), (1, 1, 1, 1))
# expect = np.array([[[[62, 63],
# [67, 68]],
# [[82, 83],
# [87, 88]],
# [[102, 103],
# [107, 108]]]]).astype(nptype)
# assert np.allclose(y.asnumpy(), expect)
op = P.StridedSlice(begin_mask=0b1000,
end_mask=0b0010,
ellipsis_mask=0b0100)
y = op(x, (1, 0, 0, 2), (2, 2, 2, 4), (1, 1, 1, 1))
expect = np.array([[[[60, 61, 62, 63], [65, 66, 67, 68], [70, 71, 72, 73],
[75, 76, 77, 78]],
[[80, 81, 82, 83], [85, 86, 87, 88], [90, 91, 92, 93],
[95, 96, 97, 98]],
[[100, 101, 102, 103], [105, 106, 107, 108],
[110, 111, 112, 113], [115, 116, 117,
118]]]]).astype(nptype)
assert np.allclose(y.asnumpy(), expect)
x = Tensor(np.arange(0, 3 * 4 * 5).reshape(3, 4, 5).astype(nptype))
y = P.StridedSlice()(x, (1, 0, 0), (2, -3, 3), (1, 1, 3))
expect = np.array([[[20]]]).astype(nptype)
assert np.allclose(y.asnumpy(), expect)
x_np = np.arange(0, 4 * 5).reshape(4, 5).astype(nptype)
y = Tensor(x_np)[:, ::-1]
expect = x_np[:, ::-1]
assert np.allclose(y.asnumpy(), expect)
x = Tensor(
np.arange(0, 2 * 3 * 4 * 5 * 4 * 3 * 2).reshape(2, 3, 4, 5, 4, 3,
2).astype(nptype))
y = P.StridedSlice()(x, (1, 0, 0, 2, 1, 2, 0), (2, 2, 2, 4, 2, 3, 2),
(1, 1, 1, 1, 1, 1, 2))
expect = np.array([[[[[[[1498.]]], [[[1522.]]]], [[[[1618.]]],
[[[1642.]]]]],
[[[[[1978.]]], [[[2002.]]]],
[[[[2098.]]], [[[2122.]]]]]]]).astype(nptype)
assert np.allclose(y.asnumpy(), expect)
def resize_nn_grayscale_integer_ratio(datatype):
input_tensor = Tensor(np.array(
[[[[0.1, 0.2, 0.3], [0.4, 0.5, 0.6], [0.7, 0.8, 0.9]]]]).astype(datatype))
# larger h and w
resize_nn = NetResizeNearestNeighbor((9, 9))
output = resize_nn(input_tensor)
expected_output = Tensor(np.array([[[[0.1, 0.1, 0.1, 0.2, 0.2, 0.2, 0.3, 0.3, 0.3],
[0.1, 0.1, 0.1, 0.2, 0.2, 0.2, 0.3, 0.3, 0.3],
[0.1, 0.1, 0.1, 0.2, 0.2, 0.2, 0.3, 0.3, 0.3],
[0.4, 0.4, 0.4, 0.5, 0.5, 0.5, 0.6, 0.6, 0.6],
[0.4, 0.4, 0.4, 0.5, 0.5, 0.5, 0.6, 0.6, 0.6],
[0.4, 0.4, 0.4, 0.5, 0.5, 0.5, 0.6, 0.6, 0.6],
[0.7, 0.7, 0.7, 0.8, 0.8, 0.8, 0.9, 0.9, 0.9],
[0.7, 0.7, 0.7, 0.8, 0.8, 0.8, 0.9, 0.9, 0.9],
[0.7, 0.7, 0.7, 0.8, 0.8, 0.8, 0.9, 0.9, 0.9]]]]).astype(datatype))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# smaller h and w
resize_nn = NetResizeNearestNeighbor((1, 1))
output = resize_nn(input_tensor)
expected_output = Tensor(np.array([[[[0.1]]]]).astype(datatype))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# smaller h, larger w
resize_nn = NetResizeNearestNeighbor((1, 6))
output = resize_nn(input_tensor)
expected_output = Tensor(
np.array([[[[0.1, 0.1, 0.2, 0.2, 0.3, 0.3]]]]).astype(datatype))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# larger h, smaller w
resize_nn = NetResizeNearestNeighbor((6, 1))
output = resize_nn(input_tensor)
expected_output = Tensor(
np.array([[[[0.1], [0.1], [0.4], [0.4], [0.7], [0.7]]]]).astype(datatype))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# smaller h, same w
resize_nn = NetResizeNearestNeighbor((1, 3))
output = resize_nn(input_tensor)
expected_output = Tensor(np.array([[[[0.1, 0.2, 0.3]]]]).astype(datatype))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# larger h, same w
resize_nn = NetResizeNearestNeighbor((6, 3))
output = resize_nn(input_tensor)
expected_output = Tensor(np.array([[[[0.1, 0.2, 0.3],
[0.1, 0.2, 0.3],
[0.4, 0.5, 0.6],
[0.4, 0.5, 0.6],
[0.7, 0.8, 0.9],
[0.7, 0.8, 0.9]]]]).astype(datatype))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# same h, smaller w
resize_nn = NetResizeNearestNeighbor((3, 1))
output = resize_nn(input_tensor)
expected_output = Tensor(
np.array([[[[0.1], [0.4], [0.7]]]]).astype(datatype))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# same h, larger w
resize_nn = NetResizeNearestNeighbor((3, 6))
output = resize_nn(input_tensor)
expected_output = Tensor(np.array([[[[0.1, 0.1, 0.2, 0.2, 0.3, 0.3],
[0.4, 0.4, 0.5, 0.5, 0.6, 0.6],
[0.7, 0.7, 0.8, 0.8, 0.9, 0.9]]]]).astype(datatype))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# same w, same h (identity)
resize_nn = NetResizeNearestNeighbor((3, 3))
output = resize_nn(input_tensor)
np.testing.assert_array_equal(output.asnumpy(), input_tensor.asnumpy())
def train_on_ascend():
config = config_ascend_quant if args_opt.quantization_aware else config_ascend
print("training args: {}".format(args_opt))
print("training configure: {}".format(config))
print("parallel args: rank_id {}, device_id {}, rank_size {}".format(rank_id, device_id, rank_size))
epoch_size = config.epoch_size
# distribute init
if run_distribute:
context.set_auto_parallel_context(device_num=rank_size,
parallel_mode=ParallelMode.DATA_PARALLEL,
parameter_broadcast=True,
mirror_mean=True)
init()
# define network
network = mobilenetV2(num_classes=config.num_classes)
# define loss
if config.label_smooth > 0:
loss = CrossEntropyWithLabelSmooth(smooth_factor=config.label_smooth, num_classes=config.num_classes)
else:
loss = nn.SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True, reduction='mean')
# define dataset
dataset = create_dataset(dataset_path=args_opt.dataset_path,
do_train=True,
config=config,
device_target=args_opt.device_target,
repeat_num=1,
batch_size=config.batch_size)
step_size = dataset.get_dataset_size()
# load pre trained ckpt
if args_opt.pre_trained:
param_dict = load_checkpoint(args_opt.pre_trained)
load_param_into_net(network, param_dict)
# convert fusion network to quantization aware network
if config.quantization_aware:
network = quant.convert_quant_network(network,
bn_fold=True,
per_channel=[True, False],
symmetric=[True, False])
# get learning rate
lr = Tensor(get_lr(global_step=config.start_epoch * step_size,
lr_init=0,
lr_end=0,
lr_max=config.lr,
warmup_epochs=config.warmup_epochs,
total_epochs=epoch_size + config.start_epoch,
steps_per_epoch=step_size))
# define optimization
opt = nn.Momentum(filter(lambda x: x.requires_grad, network.get_parameters()), lr, config.momentum,
config.weight_decay)
# define model
model = Model(network, loss_fn=loss, optimizer=opt)
print("============== Starting Training ==============")
callback = None
if rank_id == 0:
callback = [Monitor(lr_init=lr.asnumpy())]
if config.save_checkpoint:
config_ck = CheckpointConfig(save_checkpoint_steps=config.save_checkpoint_epochs * step_size,
keep_checkpoint_max=config.keep_checkpoint_max)
ckpt_cb = ModelCheckpoint(prefix="mobilenetV2",
directory=config.save_checkpoint_path,
config=config_ck)
callback += [ckpt_cb]
model.train(epoch_size, dataset, callbacks=callback)
print("============== End Training ==============")
def resize_nn_rgb_integer_ratio(datatype):
input_tensor = Tensor(np.array(
[[[[1, 2, 3], [4, 5, 6], [7, 8, 9]],
[[11, 12, 13], [14, 15, 16], [17, 18, 19]],
[[111, 112, 113], [114, 115, 116], [117, 118, 119]]]]).astype(datatype))
# larger h and w
resize_nn = NetResizeNearestNeighbor((9, 9))
output = resize_nn(input_tensor)
expected_output_array = np.array([[[[1, 1, 1, 2, 2, 2, 3, 3, 3],
[1, 1, 1, 2, 2, 2, 3, 3, 3],
[1, 1, 1, 2, 2, 2, 3, 3, 3],
[4, 4, 4, 5, 5, 5, 6, 6, 6],
[4, 4, 4, 5, 5, 5, 6, 6, 6],
[4, 4, 4, 5, 5, 5, 6, 6, 6],
[7, 7, 7, 8, 8, 8, 9, 9, 9],
[7, 7, 7, 8, 8, 8, 9, 9, 9],
[7, 7, 7, 8, 8, 8, 9, 9, 9]],
[[11, 11, 11, 12, 12, 12, 13, 13, 13],
[11, 11, 11, 12, 12, 12, 13, 13, 13],
[11, 11, 11, 12, 12, 12, 13, 13, 13],
[14, 14, 14, 15, 15, 15, 16, 16, 16],
[14, 14, 14, 15, 15, 15, 16, 16, 16],
[14, 14, 14, 15, 15, 15, 16, 16, 16],
[17, 17, 17, 18, 18, 18, 19, 19, 19],
[17, 17, 17, 18, 18, 18, 19, 19, 19],
[17, 17, 17, 18, 18, 18, 19, 19, 19]],
[[111, 111, 111, 112, 112, 112, 113, 113, 113],
[111, 111, 111, 112, 112, 112, 113, 113, 113],
[111, 111, 111, 112, 112, 112, 113, 113, 113],
[114, 114, 114, 115, 115, 115, 116, 116, 116],
[114, 114, 114, 115, 115, 115, 116, 116, 116],
[114, 114, 114, 115, 115, 115, 116, 116, 116],
[117, 117, 117, 118, 118, 118, 119, 119, 119],
[117, 117, 117, 118, 118, 118, 119, 119, 119],
[117, 117, 117, 118, 118, 118, 119, 119, 119]]]])
expected_output = Tensor(np.array(expected_output_array).astype(datatype))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# smaller h and w
resize_nn = NetResizeNearestNeighbor((1, 1))
output = resize_nn(input_tensor)
expected_output = Tensor(
np.array([[[[1]], [[11]], [[111]]]]).astype(datatype))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# smaller h, larger w
resize_nn = NetResizeNearestNeighbor((1, 6))
output = resize_nn(input_tensor)
expected_output = Tensor(np.array([[[[1, 1, 2, 2, 3, 3]],
[[11, 11, 12, 12, 13, 13]],
[[111, 111, 112, 112, 113, 113]]]]).astype(datatype))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# larger h, smaller w
resize_nn = NetResizeNearestNeighbor((6, 1))
output = resize_nn(input_tensor)
expected_output = Tensor(np.array([[[[1], [1], [4], [4], [7], [7]],
[[11], [11], [14], [14], [17], [17]],
[[111], [111], [114], [114], [117], [117]]]]).astype(datatype))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# smaller h, same w
resize_nn = NetResizeNearestNeighbor((1, 3))
output = resize_nn(input_tensor)
expected_output = Tensor(np.array([[[[1, 2, 3]],
[[11, 12, 13]],
[[111, 112, 113]]]]).astype(datatype))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# larger h, same w
resize_nn = NetResizeNearestNeighbor((6, 3))
output = resize_nn(input_tensor)
expected_output = Tensor(np.array([[[[1, 2, 3],
[1, 2, 3],
[4, 5, 6],
[4, 5, 6],
[7, 8, 9],
[7, 8, 9]],
[[11, 12, 13],
[11, 12, 13],
[14, 15, 16],
[14, 15, 16],
[17, 18, 19],
[17, 18, 19]],
[[111, 112, 113],
[111, 112, 113],
[114, 115, 116],
[114, 115, 116],
[117, 118, 119],
[117, 118, 119]]]]).astype(datatype))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# same h, smaller w
resize_nn = NetResizeNearestNeighbor((3, 1))
output = resize_nn(input_tensor)
expected_output = Tensor(np.array([[[[1], [4], [7]],
[[11], [14], [17]],
[[111], [114], [117]]]]).astype(datatype))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# same h, larger w
resize_nn = NetResizeNearestNeighbor((3, 6))
output = resize_nn(input_tensor)
expected_output = Tensor(np.array([[[[1, 1, 2, 2, 3, 3],
[4, 4, 5, 5, 6, 6],
[7, 7, 8, 8, 9, 9]],
[[11, 11, 12, 12, 13, 13],
[14, 14, 15, 15, 16, 16],
[17, 17, 18, 18, 19, 19]],
[[111, 111, 112, 112, 113, 113],
[114, 114, 115, 115, 116, 116],
[117, 117, 118, 118, 119, 119]]]]).astype(datatype))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# same w, same h (identity)
resize_nn = NetResizeNearestNeighbor((3, 3))
output = resize_nn(input_tensor)
np.testing.assert_array_equal(output.asnumpy(), input_tensor.asnumpy())
def resize_nn_rgb_not_integer_ratio(datatype):
input_tensor = Tensor(np.array([[[[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 0, 1, 2]],
[[11, 12, 13, 14],
[15, 16, 17, 18],
[19, 10, 11, 12]],
[[111, 112, 113, 114],
[115, 116, 117, 118],
[119, 110, 111, 112]]]]).astype(datatype))
# larger h and w
resize_nn = NetResizeNearestNeighbor((7, 7))
output = resize_nn(input_tensor)
expected_output = Tensor(np.array([[[[1, 1, 2, 2, 3, 3, 4],
[1, 1, 2, 2, 3, 3, 4],
[1, 1, 2, 2, 3, 3, 4],
[5, 5, 6, 6, 7, 7, 8],
[5, 5, 6, 6, 7, 7, 8],
[9, 9, 0, 0, 1, 1, 2],
[9, 9, 0, 0, 1, 1, 2]],
[[11, 11, 12, 12, 13, 13, 14],
[11, 11, 12, 12, 13, 13, 14],
[11, 11, 12, 12, 13, 13, 14],
[15, 15, 16, 16, 17, 17, 18],
[15, 15, 16, 16, 17, 17, 18],
[19, 19, 10, 10, 11, 11, 12],
[19, 19, 10, 10, 11, 11, 12]],
[[111, 111, 112, 112, 113, 113, 114],
[111, 111, 112, 112, 113, 113, 114],
[111, 111, 112, 112, 113, 113, 114],
[115, 115, 116, 116, 117, 117, 118],
[115, 115, 116, 116, 117, 117, 118],
[119, 119, 110, 110, 111, 111, 112],
[119, 119, 110, 110, 111, 111, 112]]]]).astype(datatype))
# smaller h and w
resize_nn = NetResizeNearestNeighbor((2, 3))
output = resize_nn(input_tensor)
expected_output = Tensor(np.array([[[[1, 2, 3], [5, 6, 7]],
[[11, 12, 13], [15, 16, 17]],
[[111, 112, 113], [115, 116, 117]]]]).astype(datatype))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# smaller h, larger w
resize_nn = NetResizeNearestNeighbor((2, 7))
output = resize_nn(input_tensor)
expected_output = Tensor(np.array([[[[1, 1, 2, 2, 3, 3, 4],
[5, 5, 6, 6, 7, 7, 8]],
[[11, 11, 12, 12, 13, 13, 14],
[15, 15, 16, 16, 17, 17, 18]],
[[111, 111, 112, 112, 113, 113, 114],
[115, 115, 116, 116, 117, 117, 118]]]]).astype(datatype))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# larger h, smaller w
resize_nn = NetResizeNearestNeighbor((5, 3))
output = resize_nn(input_tensor)
expected_output = Tensor(np.array([[[[1, 2, 3],
[1, 2, 3],
[5, 6, 7],
[5, 6, 7],
[9, 0, 1]],
[[11, 12, 13],
[11, 12, 13],
[15, 16, 17],
[15, 16, 17],
[19, 10, 11]],
[[111, 112, 113],
[111, 112, 113],
[115, 116, 117],
[115, 116, 117],
[119, 110, 111]]]]).astype(datatype))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# smaller h, same w
resize_nn = NetResizeNearestNeighbor((2, 4))
output = resize_nn(input_tensor)
expected_output = Tensor(np.array([[[[1, 2, 3, 4],
[5, 6, 7, 8]],
[[11, 12, 13, 14],
[15, 16, 17, 18]],
[[111, 112, 113, 114],
[115, 116, 117, 118]]]]).astype(datatype))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# larger h, same w
resize_nn = NetResizeNearestNeighbor((8, 4))
output = resize_nn(input_tensor)
expected_output = Tensor(np.array([[[[1, 2, 3, 4],
[1, 2, 3, 4],
[1, 2, 3, 4],
[5, 6, 7, 8],
[5, 6, 7, 8],
[5, 6, 7, 8],
[9, 0, 1, 2],
[9, 0, 1, 2]],
[[11, 12, 13, 14],
[11, 12, 13, 14],
[11, 12, 13, 14],
[15, 16, 17, 18],
[15, 16, 17, 18],
[15, 16, 17, 18],
[19, 10, 11, 12],
[19, 10, 11, 12]],
[[111, 112, 113, 114],
[111, 112, 113, 114],
[111, 112, 113, 114],
[115, 116, 117, 118],
[115, 116, 117, 118],
[115, 116, 117, 118],
[119, 110, 111, 112],
[119, 110, 111, 112]]]]).astype(datatype))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# same h, smaller w
resize_nn = NetResizeNearestNeighbor((3, 2))
output = resize_nn(input_tensor)
expected_output = Tensor(np.array([[[[1, 3], [5, 7], [9, 1]],
[[11, 13], [15, 17], [19, 11]],
[[111, 113], [115, 117], [119, 111]]]]).astype(datatype))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# same h, larger w
resize_nn = NetResizeNearestNeighbor((3, 6))
output = resize_nn(input_tensor)
expected_output = Tensor(np.array([[[[1, 1, 2, 3, 3, 4],
[5, 5, 6, 7, 7, 8],
[9, 9, 0, 1, 1, 2]],
[[11, 11, 12, 13, 13, 14],
[15, 15, 16, 17, 17, 18],
[19, 19, 10, 11, 11, 12]],
[[111, 111, 112, 113, 113, 114],
[115, 115, 116, 117, 117, 118],
[119, 119, 110, 111, 111, 112]]]]).astype(datatype))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# same w, same h (identity)
resize_nn = NetResizeNearestNeighbor((3, 4))
output = resize_nn(input_tensor)
np.testing.assert_array_equal(output.asnumpy(), input_tensor.asnumpy())
def test_resize_nn_rgb_not_integer_ratio():
context.set_context(mode=context.PYNATIVE_MODE, device_target="GPU")
input_tensor = Tensor(
np.array([[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 0, 1, 2]],
[[11, 12, 13, 14], [15, 16, 17, 18], [19, 10, 11, 12]],
[[111, 112, 113, 114], [115, 116, 117, 118],
[119, 110, 111, 112]]]]).astype(np.int32))
# larger h and w
resize_nn = P.ResizeNearestNeighbor((7, 7))
output = resize_nn(input_tensor)
expected_output = Tensor(
np.array([[[[1, 1, 2, 2, 3, 3, 4], [1, 1, 2, 2, 3, 3, 4],
[1, 1, 2, 2, 3, 3, 4], [5, 5, 6, 6, 7, 7, 8],
[5, 5, 6, 6, 7, 7, 8], [9, 9, 0, 0, 1, 1, 2],
[9, 9, 0, 0, 1, 1, 2]],
[[11, 11, 12, 12, 13, 13, 14], [11, 11, 12, 12, 13, 13, 14],
[11, 11, 12, 12, 13, 13, 14], [15, 15, 16, 16, 17, 17, 18],
[15, 15, 16, 16, 17, 17, 18], [19, 19, 10, 10, 11, 11, 12],
[19, 19, 10, 10, 11, 11, 12]],
[[111, 111, 112, 112, 113, 113, 114],
[111, 111, 112, 112, 113, 113, 114],
[111, 111, 112, 112, 113, 113, 114],
[115, 115, 116, 116, 117, 117, 118],
[115, 115, 116, 116, 117, 117, 118],
[119, 119, 110, 110, 111, 111, 112],
[119, 119, 110, 110, 111, 111, 112]]]]).astype(np.int32))
# smaller h and w
resize_nn = P.ResizeNearestNeighbor((2, 3))
output = resize_nn(input_tensor)
expected_output = Tensor(
np.array([[[[1, 2, 3], [5, 6, 7]], [[11, 12, 13], [15, 16, 17]],
[[111, 112, 113], [115, 116, 117]]]]).astype(np.int32))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# smaller h, larger w
resize_nn = P.ResizeNearestNeighbor((2, 7))
output = resize_nn(input_tensor)
expected_output = Tensor(
np.array([[[[1, 1, 2, 2, 3, 3, 4], [5, 5, 6, 6, 7, 7, 8]],
[[11, 11, 12, 12, 13, 13, 14], [15, 15, 16, 16, 17, 17,
18]],
[[111, 111, 112, 112, 113, 113, 114],
[115, 115, 116, 116, 117, 117, 118]]]]).astype(np.int32))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# larger h, smaller w
resize_nn = P.ResizeNearestNeighbor((5, 3))
output = resize_nn(input_tensor)
expected_output = Tensor(
np.array([[[[1, 2, 3], [1, 2, 3], [5, 6, 7], [5, 6, 7], [9, 0, 1]],
[[11, 12, 13], [11, 12, 13], [15, 16, 17], [15, 16, 17],
[19, 10, 11]],
[[111, 112, 113], [111, 112, 113], [115, 116, 117],
[115, 116, 117], [119, 110, 111]]]]).astype(np.int32))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# smaller h, same w
resize_nn = P.ResizeNearestNeighbor((2, 4))
output = resize_nn(input_tensor)
expected_output = Tensor(
np.array([[[[1, 2, 3, 4], [5, 6, 7, 8]],
[[11, 12, 13, 14], [15, 16, 17, 18]],
[[111, 112, 113, 114], [115, 116, 117,
118]]]]).astype(np.int32))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# larger h, same w
resize_nn = P.ResizeNearestNeighbor((8, 4))
output = resize_nn(input_tensor)
expected_output = Tensor(
np.array([[[[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4], [5, 6, 7, 8],
[5, 6, 7, 8], [5, 6, 7, 8], [9, 0, 1, 2], [9, 0, 1, 2]],
[[11, 12, 13, 14], [11, 12, 13, 14], [11, 12, 13, 14],
[15, 16, 17, 18], [15, 16, 17, 18], [15, 16, 17, 18],
[19, 10, 11, 12], [19, 10, 11, 12]],
[[111, 112, 113, 114], [111, 112, 113, 114],
[111, 112, 113, 114], [115, 116, 117, 118],
[115, 116, 117, 118], [115, 116, 117, 118],
[119, 110, 111, 112], [119, 110, 111,
112]]]]).astype(np.int32))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# same h, smaller w
resize_nn = P.ResizeNearestNeighbor((3, 2))
output = resize_nn(input_tensor)
expected_output = Tensor(
np.array([[[[1, 3], [5, 7], [9, 1]], [[11, 13], [15, 17], [19, 11]],
[[111, 113], [115, 117], [119, 111]]]]).astype(np.int32))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# same h, larger w
resize_nn = P.ResizeNearestNeighbor((3, 6))
output = resize_nn(input_tensor)
expected_output = Tensor(
np.array([[[[1, 1, 2, 3, 3, 4], [5, 5, 6, 7, 7, 8], [9, 9, 0, 1, 1,
2]],
[[11, 11, 12, 13, 13, 14], [15, 15, 16, 17, 17, 18],
[19, 19, 10, 11, 11, 12]],
[[111, 111, 112, 113, 113, 114],
[115, 115, 116, 117, 117, 118],
[119, 119, 110, 111, 111, 112]]]]).astype(np.int32))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# same w, same h (identity)
resize_nn = P.ResizeNearestNeighbor((3, 4))
output = resize_nn(input_tensor)
np.testing.assert_array_equal(output.asnumpy(), input_tensor.asnumpy())
symmetric=[True, False])
# get learning rate
lr = Tensor(get_lr(global_step=config.start_epoch * step_size,
lr_init=0,
lr_end=0,
lr_max=config.lr,
warmup_epochs=config.warmup_epochs,
total_epochs=epoch_size + config.start_epoch,
steps_per_epoch=step_size))
# define optimization
opt = nn.Momentum(filter(lambda x: x.requires_grad, network.get_parameters()), lr, config.momentum,
config.weight_decay)
# define model
model = Model(network, loss_fn=loss, optimizer=opt)
print("============== Starting Training ==============")
callback = None
if rank_id == 0:
callback = [Monitor(lr_init=lr.asnumpy())]
if config.save_checkpoint:
config_ck = CheckpointConfig(save_checkpoint_steps=config.save_checkpoint_epochs * step_size,
keep_checkpoint_max=config.keep_checkpoint_max)
ckpt_cb = ModelCheckpoint(prefix="mobilenetV2",
directory=config.save_checkpoint_path,
config=config_ck)
callback += [ckpt_cb]
model.train(epoch_size, dataset, callbacks=callback)
print("============== End Training ==============")
def resize_nn_grayscale_not_integer_ratio(datatype):
context.set_context(mode=context.PYNATIVE_MODE, device_target="GPU")
input_tensor = Tensor(
np.array([[[[0.1, 0.2, 0.3, 0.4], [0.5, 0.6, 0.7, 0.8],
[0.9, 0.0, 0.1, 0.2]]]]).astype(datatype))
# larger h and w
resize_nn = P.ResizeNearestNeighbor((7, 7))
output = resize_nn(input_tensor)
expected_output = Tensor(
np.array([[[[0.1, 0.1, 0.2, 0.2, 0.3, 0.3, 0.4],
[0.1, 0.1, 0.2, 0.2, 0.3, 0.3, 0.4],
[0.1, 0.1, 0.2, 0.2, 0.3, 0.3, 0.4],
[0.5, 0.5, 0.6, 0.6, 0.7, 0.7, 0.8],
[0.5, 0.5, 0.6, 0.6, 0.7, 0.7, 0.8],
[0.9, 0.9, 0.0, 0.0, 0.1, 0.1, 0.2],
[0.9, 0.9, 0.0, 0.0, 0.1, 0.1, 0.2]]]]).astype(datatype))
# smaller h and w
resize_nn = P.ResizeNearestNeighbor((2, 3))
output = resize_nn(input_tensor)
expected_output = Tensor(
np.array([[[[0.1, 0.2, 0.3], [0.5, 0.6, 0.7]]]]).astype(datatype))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# smaller h, larger w
resize_nn = P.ResizeNearestNeighbor((2, 7))
output = resize_nn(input_tensor)
expected_output = Tensor(
np.array([[[[0.1, 0.1, 0.2, 0.2, 0.3, 0.3, 0.4],
[0.5, 0.5, 0.6, 0.6, 0.7, 0.7, 0.8]]]]).astype(datatype))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# larger h, smaller w
resize_nn = P.ResizeNearestNeighbor((5, 3))
output = resize_nn(input_tensor)
expected_output = Tensor(
np.array([[[[0.1, 0.2, 0.3], [0.1, 0.2, 0.3], [0.5, 0.6, 0.7],
[0.5, 0.6, 0.7], [0.9, 0.0, 0.1]]]]).astype(datatype))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# smaller h, same w
resize_nn = P.ResizeNearestNeighbor((2, 4))
output = resize_nn(input_tensor)
expected_output = Tensor(
np.array([[[[0.1, 0.2, 0.3, 0.4], [0.5, 0.6, 0.7,
0.8]]]]).astype(datatype))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# larger h, same w
resize_nn = P.ResizeNearestNeighbor((8, 4))
output = resize_nn(input_tensor)
expected_output = Tensor(
np.array([[[[0.1, 0.2, 0.3, 0.4], [0.1, 0.2, 0.3, 0.4],
[0.1, 0.2, 0.3, 0.4], [0.5, 0.6, 0.7, 0.8],
[0.5, 0.6, 0.7, 0.8], [0.5, 0.6, 0.7, 0.8],
[0.9, 0.0, 0.1, 0.2], [0.9, 0.0, 0.1,
0.2]]]]).astype(datatype))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# same h, smaller w
resize_nn = P.ResizeNearestNeighbor((3, 2))
output = resize_nn(input_tensor)
expected_output = Tensor(
np.array([[[[0.1, 0.3], [0.5, 0.7], [0.9, 0.1]]]]).astype(datatype))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# same h, larger w
resize_nn = P.ResizeNearestNeighbor((3, 6))
output = resize_nn(input_tensor)
expected_output = Tensor(
np.array([[[[0.1, 0.1, 0.2, 0.3, 0.3, 0.4],
[0.5, 0.5, 0.6, 0.7, 0.7, 0.8],
[0.9, 0.9, 0.0, 0.1, 0.1, 0.2]]]]).astype(datatype))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# same w, same h (identity)
resize_nn = P.ResizeNearestNeighbor((3, 4))
output = resize_nn(input_tensor)
np.testing.assert_array_equal(output.asnumpy(), input_tensor.asnumpy())
def test_resize_nn_rgb_integer_ratio():
context.set_context(mode=context.PYNATIVE_MODE, device_target="GPU")
input_tensor = Tensor(
np.array([[[[1, 2, 3], [4, 5, 6], [7, 8, 9]],
[[11, 12, 13], [14, 15, 16], [17, 18, 19]],
[[111, 112, 113], [114, 115, 116],
[117, 118, 119]]]]).astype(np.int32))
# larger h and w
resize_nn = P.ResizeNearestNeighbor((9, 9))
output = resize_nn(input_tensor)
expected_output_array = np.array(
[[[[1, 1, 1, 2, 2, 2, 3, 3, 3], [1, 1, 1, 2, 2, 2, 3, 3, 3],
[1, 1, 1, 2, 2, 2, 3, 3, 3],
[4, 4, 4, 5, 5, 5, 6, 6,
6], [4, 4, 4, 5, 5, 5, 6, 6,
6], [4, 4, 4, 5, 5, 5, 6, 6,
6], [7, 7, 7, 8, 8, 8, 9, 9,
9], [7, 7, 7, 8, 8, 8, 9, 9,
9], [7, 7, 7, 8, 8, 8, 9, 9,
9]],
[[11, 11, 11, 12, 12, 12, 13, 13, 13],
[11, 11, 11, 12, 12, 12, 13, 13, 13],
[11, 11, 11, 12, 12, 12, 13, 13, 13],
[14, 14, 14, 15, 15, 15, 16, 16, 16],
[14, 14, 14, 15, 15, 15, 16, 16, 16],
[14, 14, 14, 15, 15, 15, 16, 16, 16],
[17, 17, 17, 18, 18, 18, 19, 19, 19],
[17, 17, 17, 18, 18, 18, 19, 19, 19],
[17, 17, 17, 18, 18, 18, 19, 19, 19]],
[[111, 111, 111, 112, 112, 112, 113, 113, 113],
[111, 111, 111, 112, 112, 112, 113, 113, 113],
[111, 111, 111, 112, 112, 112, 113, 113, 113],
[114, 114, 114, 115, 115, 115, 116, 116, 116],
[114, 114, 114, 115, 115, 115, 116, 116, 116],
[114, 114, 114, 115, 115, 115, 116, 116, 116],
[117, 117, 117, 118, 118, 118, 119, 119, 119],
[117, 117, 117, 118, 118, 118, 119, 119, 119],
[117, 117, 117, 118, 118, 118, 119, 119, 119]]]])
expected_output = Tensor(np.array(expected_output_array).astype(np.int32))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# smaller h and w
resize_nn = P.ResizeNearestNeighbor((1, 1))
output = resize_nn(input_tensor)
expected_output = Tensor(
np.array([[[[1]], [[11]], [[111]]]]).astype(np.int32))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# smaller h, larger w
resize_nn = P.ResizeNearestNeighbor((1, 6))
output = resize_nn(input_tensor)
expected_output = Tensor(
np.array([[[[1, 1, 2, 2, 3, 3]], [[11, 11, 12, 12, 13, 13]],
[[111, 111, 112, 112, 113, 113]]]]).astype(np.int32))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# larger h, smaller w
resize_nn = P.ResizeNearestNeighbor((6, 1))
output = resize_nn(input_tensor)
expected_output = Tensor(
np.array([[[[1], [1], [4], [4], [7], [7]],
[[11], [11], [14], [14], [17], [17]],
[[111], [111], [114], [114], [117],
[117]]]]).astype(np.int32))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# smaller h, same w
resize_nn = P.ResizeNearestNeighbor((1, 3))
output = resize_nn(input_tensor)
expected_output = Tensor(
np.array([[[[1, 2, 3]], [[11, 12, 13]], [[111, 112,
113]]]]).astype(np.int32))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# larger h, same w
resize_nn = P.ResizeNearestNeighbor((6, 3))
output = resize_nn(input_tensor)
expected_output = Tensor(
np.array([[[[1, 2, 3], [1, 2, 3], [4, 5, 6], [4, 5, 6], [7, 8, 9],
[7, 8, 9]],
[[11, 12, 13], [11, 12, 13], [14, 15, 16], [14, 15, 16],
[17, 18, 19], [17, 18, 19]],
[[111, 112, 113], [111, 112, 113], [114, 115, 116],
[114, 115, 116], [117, 118, 119],
[117, 118, 119]]]]).astype(np.int32))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# same h, smaller w
resize_nn = P.ResizeNearestNeighbor((3, 1))
output = resize_nn(input_tensor)
expected_output = Tensor(
np.array([[[[1], [4], [7]], [[11], [14], [17]],
[[111], [114], [117]]]]).astype(np.int32))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# same h, larger w
resize_nn = P.ResizeNearestNeighbor((3, 6))
output = resize_nn(input_tensor)
expected_output = Tensor(
np.array([[[[1, 1, 2, 2, 3, 3], [4, 4, 5, 5, 6, 6], [7, 7, 8, 8, 9,
9]],
[[11, 11, 12, 12, 13, 13], [14, 14, 15, 15, 16, 16],
[17, 17, 18, 18, 19, 19]],
[[111, 111, 112, 112, 113, 113],
[114, 114, 115, 115, 116, 116],
[117, 117, 118, 118, 119, 119]]]]).astype(np.int32))
np.testing.assert_array_equal(expected_output.asnumpy(), output.asnumpy())
# same w, same h (identity)
resize_nn = P.ResizeNearestNeighbor((3, 3))
output = resize_nn(input_tensor)
np.testing.assert_array_equal(output.asnumpy(), input_tensor.asnumpy())
def test():
"""The function of eval."""
start_time = time.time()
args = parse_args()
# logger
args.outputs_dir = os.path.join(args.log_path,
datetime.datetime.now().strftime('%Y-%m-%d_time_%H_%M_%S'))
rank_id = int(os.environ.get('RANK_ID'))
args.logger = get_logger(args.outputs_dir, rank_id)
context.reset_auto_parallel_context()
parallel_mode = ParallelMode.STAND_ALONE
context.set_auto_parallel_context(parallel_mode=parallel_mode, mirror_mean=True, device_num=1)
args.logger.info('Creating Network....')
network = YOLOV3DarkNet53(is_training=False)
args.logger.info(args.pretrained)
if os.path.isfile(args.pretrained):
param_dict = load_checkpoint(args.pretrained)
param_dict_new = {}
for key, values in param_dict.items():
if key.startswith('moments.'):
continue
elif key.startswith('yolo_network.'):
param_dict_new[key[13:]] = values
else:
param_dict_new[key] = values
load_param_into_net(network, param_dict_new)
args.logger.info('load_model {} success'.format(args.pretrained))
else:
args.logger.info('{} not exists or not a pre-trained file'.format(args.pretrained))
assert FileNotFoundError('{} not exists or not a pre-trained file'.format(args.pretrained))
exit(1)
data_root = args.data_root
ann_file = args.annFile
config = ConfigYOLOV3DarkNet53()
if args.testing_shape:
config.test_img_shape = conver_testing_shape(args)
ds, data_size = create_yolo_dataset(data_root, ann_file, is_training=False, batch_size=args.per_batch_size,
max_epoch=1, device_num=1, rank=rank_id, shuffle=False,
config=config)
args.logger.info('testing shape : {}'.format(config.test_img_shape))
args.logger.info('totol {} images to eval'.format(data_size))
network.set_train(False)
# init detection engine
detection = DetectionEngine(args)
input_shape = Tensor(tuple(config.test_img_shape), ms.float32)
args.logger.info('Start inference....')
for i, data in enumerate(ds.create_dict_iterator()):
image = Tensor(data["image"])
image_shape = Tensor(data["image_shape"])
image_id = Tensor(data["img_id"])
prediction = network(image, input_shape)
output_big, output_me, output_small = prediction
output_big = output_big.asnumpy()
output_me = output_me.asnumpy()
output_small = output_small.asnumpy()
image_id = image_id.asnumpy()
image_shape = image_shape.asnumpy()
detection.detect([output_small, output_me, output_big], args.per_batch_size, image_shape, image_id)
if i % 1000 == 0:
args.logger.info('Processing... {:.2f}% '.format(i * args.per_batch_size / data_size * 100))
args.logger.info('Calculating mAP...')
detection.do_nms_for_results()
result_file_path = detection.write_result()
args.logger.info('result file path: {}'.format(result_file_path))
eval_result = detection.get_eval_result()
cost_time = time.time() - start_time
args.logger.info('\n=============coco eval reulst=========\n' + eval_result)
args.logger.info('testing cost time {:.2f}h'.format(cost_time / 3600.))
def train_on_gpu():
config = config_gpu_quant
print("training args: {}".format(args_opt))
print("training configure: {}".format(config))
# define network
network = mobilenetV2(num_classes=config.num_classes)
# define loss
if config.label_smooth > 0:
loss = CrossEntropyWithLabelSmooth(smooth_factor=config.label_smooth,
num_classes=config.num_classes)
else:
loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
# define dataset
epoch_size = config.epoch_size
dataset = create_dataset(dataset_path=args_opt.dataset_path,
do_train=True,
config=config,
device_target=args_opt.device_target,
repeat_num=1,
batch_size=config.batch_size)
step_size = dataset.get_dataset_size()
# resume
if args_opt.pre_trained:
param_dict = load_checkpoint(args_opt.pre_trained)
load_nonquant_param_into_quant_net(network, param_dict)
# convert fusion network to quantization aware network
quantizer = QuantizationAwareTraining(bn_fold=True,
per_channel=[True, False],
symmetric=[False, False],
freeze_bn=1000000,
quant_delay=step_size * 2)
network = quantizer.quantize(network)
# get learning rate
loss_scale = FixedLossScaleManager(config.loss_scale,
drop_overflow_update=False)
lr = Tensor(
get_lr(global_step=config.start_epoch * step_size,
lr_init=0,
lr_end=0,
lr_max=config.lr,
warmup_epochs=config.warmup_epochs,
total_epochs=epoch_size + config.start_epoch,
steps_per_epoch=step_size))
# define optimization
opt = nn.Momentum(
filter(lambda x: x.requires_grad, network.get_parameters()), lr,
config.momentum, config.weight_decay, config.loss_scale)
# define model
model = Model(network,
loss_fn=loss,
optimizer=opt,
loss_scale_manager=loss_scale)
print("============== Starting Training ==============")
callback = [Monitor(lr_init=lr.asnumpy())]
ckpt_save_dir = config.save_checkpoint_path + "ckpt_" + str(
get_rank()) + "/"
if config.save_checkpoint:
config_ck = CheckpointConfig(
save_checkpoint_steps=config.save_checkpoint_epochs * step_size,
keep_checkpoint_max=config.keep_checkpoint_max)
ckpt_cb = ModelCheckpoint(prefix="mobilenetV2",
directory=ckpt_save_dir,
config=config_ck)
callback += [ckpt_cb]
model.train(epoch_size, dataset, callbacks=callback)
print("============== End Training ==============")
def test():
"""test method"""
# init distributed
if args.is_distributed:
init()
args.rank = get_rank()
args.group_size = get_group_size()
# logger
args.outputs_dir = os.path.join(
args.log_path,
datetime.datetime.now().strftime('%Y-%m-%d_time_%H_%M_%S'))
args.logger = get_logger(args.outputs_dir, args.rank)
context.reset_auto_parallel_context()
if args.is_distributed:
parallel_mode = ParallelMode.DATA_PARALLEL
else:
parallel_mode = ParallelMode.STAND_ALONE
context.set_auto_parallel_context(parallel_mode=parallel_mode,
gradients_mean=True,
device_num=1)
args.logger.info('Creating Network....')
network = YOLOV4CspDarkNet53(is_training=False)
args.logger.info(args.pretrained)
if os.path.isfile(args.pretrained):
param_dict = load_checkpoint(args.pretrained)
param_dict_new = {}
for key, values in param_dict.items():
if key.startswith('moments.'):
continue
elif key.startswith('yolo_network.'):
param_dict_new[key[13:]] = values
else:
param_dict_new[key] = values
load_param_into_net(network, param_dict_new)
args.logger.info('load_model {} success'.format(args.pretrained))
else:
args.logger.info('{} not exists or not a pre-trained file'.format(
args.pretrained))
assert FileNotFoundError(
'{} not exists or not a pre-trained file'.format(args.pretrained))
exit(1)
data_root = args.data_root
# annFile = args.annFile
config = ConfigYOLOV4CspDarkNet53()
if args.testing_shape:
config.test_img_shape = convert_testing_shape(args)
data_txt = os.path.join(args.data_dir, 'testdev2017.txt')
ds, data_size = create_yolo_datasetv2(data_root,
data_txt=data_txt,
batch_size=args.per_batch_size,
max_epoch=1,
device_num=args.group_size,
rank=args.rank,
shuffle=False,
config=config)
args.logger.info('testing shape : {}'.format(config.test_img_shape))
args.logger.info('totol {} images to eval'.format(data_size))
network.set_train(False)
# init detection engine
detection = DetectionEngine(args)
input_shape = Tensor(tuple(config.test_img_shape), ms.float32)
args.logger.info('Start inference....')
for i, data in enumerate(ds.create_dict_iterator()):
image = Tensor(data["image"])
image_shape = Tensor(data["image_shape"])
image_id = Tensor(data["img_id"])
prediction = network(image, input_shape)
output_big, output_me, output_small = prediction
output_big = output_big.asnumpy()
output_me = output_me.asnumpy()
output_small = output_small.asnumpy()
image_id = image_id.asnumpy()
image_shape = image_shape.asnumpy()
detection.detect([output_small, output_me, output_big],
args.per_batch_size, image_shape, image_id)
if i % 1000 == 0:
args.logger.info('Processing... {:.2f}% '.format(
i * args.per_batch_size / data_size * 100))
args.logger.info('Calculating mAP...')
detection.do_nms_for_results()
result_file_path = detection.write_result()
args.logger.info('result file path: {}'.format(result_file_path))
def test_mobilenetv2_quant():
set_seed(1)
context.set_context(mode=context.GRAPH_MODE, device_target="Ascend")
config = config_ascend_quant
print("training configure: {}".format(config))
epoch_size = config.epoch_size
# define network
network = mobilenetV2(num_classes=config.num_classes)
# define loss
if config.label_smooth > 0:
loss = CrossEntropyWithLabelSmooth(smooth_factor=config.label_smooth,
num_classes=config.num_classes)
else:
loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
# define dataset
dataset = create_dataset(dataset_path=dataset_path,
config=config,
repeat_num=1,
batch_size=config.batch_size)
step_size = dataset.get_dataset_size()
# convert fusion network to quantization aware network
network = quant.convert_quant_network(network,
bn_fold=True,
per_channel=[True, False],
symmetric=[True, False])
# get learning rate
lr = Tensor(
get_lr(global_step=config.start_epoch * step_size,
lr_init=0,
lr_end=0,
lr_max=config.lr,
warmup_epochs=config.warmup_epochs,
total_epochs=epoch_size + config.start_epoch,
steps_per_epoch=step_size))
# define optimization
opt = nn.Momentum(
filter(lambda x: x.requires_grad, network.get_parameters()), lr,
config.momentum, config.weight_decay)
# define model
model = Model(network, loss_fn=loss, optimizer=opt)
print("============== Starting Training ==============")
monitor = Monitor(lr_init=lr.asnumpy(),
step_threshold=config.step_threshold)
callback = [monitor]
model.train(epoch_size,
dataset,
callbacks=callback,
dataset_sink_mode=False)
print("============== End Training ==============")
expect_avg_step_loss = 2.32
avg_step_loss = np.mean(np.array(monitor.losses))
print("average step loss:{}".format(avg_step_loss))
assert avg_step_loss < expect_avg_step_loss
def main():
parser = argparse.ArgumentParser(description="retinanet training")
parser.add_argument("--only_create_dataset", type=ast.literal_eval, default=False,
help="If set it true, only create Mindrecord, default is False.")
parser.add_argument("--distribute", type=ast.literal_eval, default=False,
help="Run distribute, default is False.")
parser.add_argument("--device_id", type=int, default=0, help="Device id, default is 0.")
parser.add_argument("--device_num", type=int, default=1, help="Use device nums, default is 1.")
parser.add_argument("--lr", type=float, default=0.1, help="Learning rate, default is 0.1.")
parser.add_argument("--mode", type=str, default="sink", help="Run sink mode or not, default is sink.")
parser.add_argument("--dataset", type=str, default="coco", help="Dataset, default is coco.")
parser.add_argument("--epoch_size", type=int, default=500, help="Epoch size, default is 500.")
parser.add_argument("--batch_size", type=int, default=32, help="Batch size, default is 32.")
parser.add_argument("--pre_trained", type=str, default=None, help="Pretrained Checkpoint file path.")
parser.add_argument("--pre_trained_epoch_size", type=int, default=0, help="Pretrained epoch size.")
parser.add_argument("--save_checkpoint_epochs", type=int, default=1, help="Save checkpoint epochs, default is 1.")
parser.add_argument("--loss_scale", type=int, default=1024, help="Loss scale, default is 1024.")
parser.add_argument("--filter_weight", type=ast.literal_eval, default=False,
help="Filter weight parameters, default is False.")
parser.add_argument("--run_platform", type=str, default="Ascend", choices=("Ascend"),
help="run platform, only support Ascend.")
args_opt = parser.parse_args()
if args_opt.run_platform == "Ascend":
context.set_context(mode=context.GRAPH_MODE, device_target="Ascend")
if args_opt.distribute:
if os.getenv("DEVICE_ID", "not_set").isdigit():
context.set_context(device_id=int(os.getenv("DEVICE_ID")))
init()
device_num = args_opt.device_num
rank = get_rank()
context.set_auto_parallel_context(parallel_mode=ParallelMode.DATA_PARALLEL, gradients_mean=True,
device_num=device_num)
else:
rank = 0
device_num = 1
context.set_context(device_id=args_opt.device_id)
else:
raise ValueError("Unsupported platform.")
mindrecord_file = create_mindrecord(args_opt.dataset, "retinanet.mindrecord", True)
if not args_opt.only_create_dataset:
loss_scale = float(args_opt.loss_scale)
# When create MindDataset, using the fitst mindrecord file, such as retinanet.mindrecord0.
dataset = create_retinanet_dataset(mindrecord_file, repeat_num=1,
batch_size=args_opt.batch_size, device_num=device_num, rank=rank)
dataset_size = dataset.get_dataset_size()
print("Create dataset done!")
backbone = resnet50(config.num_classes)
retinanet = retinanet50(backbone, config)
net = retinanetWithLossCell(retinanet, config)
net.to_float(mindspore.float16)
init_net_param(net)
if args_opt.pre_trained:
if args_opt.pre_trained_epoch_size <= 0:
raise KeyError("pre_trained_epoch_size must be greater than 0.")
param_dict = load_checkpoint(args_opt.pre_trained)
if args_opt.filter_weight:
filter_checkpoint_parameter(param_dict)
load_param_into_net(net, param_dict)
lr = Tensor(get_lr(global_step=config.global_step,
lr_init=config.lr_init, lr_end=config.lr_end_rate * args_opt.lr, lr_max=args_opt.lr,
warmup_epochs1=config.warmup_epochs1, warmup_epochs2=config.warmup_epochs2,
warmup_epochs3=config.warmup_epochs3, warmup_epochs4=config.warmup_epochs4,
warmup_epochs5=config.warmup_epochs5, total_epochs=args_opt.epoch_size,
steps_per_epoch=dataset_size))
opt = nn.Momentum(filter(lambda x: x.requires_grad, net.get_parameters()), lr,
config.momentum, config.weight_decay, loss_scale)
net = TrainingWrapper(net, opt, loss_scale)
model = Model(net)
print("Start train retinanet, the first epoch will be slower because of the graph compilation.")
cb = [TimeMonitor(), LossMonitor()]
cb += [Monitor(lr_init=lr.asnumpy())]
config_ck = CheckpointConfig(save_checkpoint_steps=dataset_size * args_opt.save_checkpoint_epochs,
keep_checkpoint_max=config.keep_checkpoint_max)
ckpt_cb = ModelCheckpoint(prefix="retinanet", directory=config.save_checkpoint_path, config=config_ck)
if args_opt.distribute:
if rank == 0:
cb += [ckpt_cb]
model.train(args_opt.epoch_size, dataset, callbacks=cb, dataset_sink_mode=True)
else:
cb += [ckpt_cb]
model.train(args_opt.epoch_size, dataset, callbacks=cb, dataset_sink_mode=True)
