def __init__(self, load_weights=False):
super(CSRNet, self).__init__()
self.seen = 0
# self.frontend_feat = [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512]
self.backend_feat = [512, 512, 512, 256, 128, 64]
# self.front_end = make_layers(self.frontend_feat)
self.front_end = vgg16(struct='F', NL="relu", output_stride=8)
self.backend = make_layers(self.backend_feat,
in_channels=512,
dilation=True)
self.output_layer = nn.Conv2d(64, 1, kernel_size=1)
if args.dataset == "cifar10":
dataset = vgg_create_dataset(args.data_path, args.image_size, args.per_batch_size, args.rank, args.group_size)
else:
dataset = classification_dataset(args.data_path, args.image_size, args.per_batch_size,
args.rank, args.group_size)
batch_num = dataset.get_dataset_size()
args.steps_per_epoch = dataset.get_dataset_size()
args.logger.save_args(args)
# network
args.logger.important_info('start create network')
# get network and init
network = vgg16(args.num_classes, args)
# pre_trained
if args.pre_trained:
load_param_into_net(network, load_checkpoint(args.pre_trained))
# lr scheduler
if args.lr_scheduler == 'exponential':
lr = warmup_step_lr(args.lr,
args.lr_epochs,
args.steps_per_epoch,
args.warmup_epochs,
args.max_epoch,
gamma=args.lr_gamma,
)
elif args.lr_scheduler == 'cosine_annealing':
device_target=args_opt.device_target)
context.set_context(device_id=args_opt.device_id)
device_num = int(os.environ.get("DEVICE_NUM", 1))
if device_num > 1:
context.reset_auto_parallel_context()
context.set_auto_parallel_context(
device_num=device_num,
parallel_mode=ParallelMode.DATA_PARALLEL,
mirror_mean=True)
init()
dataset = vgg_create_dataset(args_opt.data_path, 1)
batch_num = dataset.get_dataset_size()
net = vgg16(num_classes=cfg.num_classes)
# pre_trained
if args_opt.pre_trained:
load_param_into_net(net, load_checkpoint(args_opt.pre_trained))
lr = lr_steps(0,
lr_init=cfg.lr_init,
lr_max=cfg.lr_max,
warmup_epochs=cfg.warmup_epochs,
total_epochs=cfg.epoch_size,
steps_per_epoch=batch_num)
opt = Momentum(filter(lambda x: x.requires_grad, net.get_parameters()),
Tensor(lr),
cfg.momentum,
weight_decay=cfg.weight_decay)
loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True,
def test(cloud_args=None):
"""test"""
args = parse_args(cloud_args)
context.set_context(mode=context.GRAPH_MODE,
enable_auto_mixed_precision=True,
device_target=args.device_target,
save_graphs=False)
if os.getenv('DEVICE_ID', "not_set").isdigit():
context.set_context(device_id=int(os.getenv('DEVICE_ID')))
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)
args.logger.save_args(args)
if args.dataset == "cifar10":
net = vgg16(num_classes=args.num_classes)
opt = Momentum(filter(lambda x: x.requires_grad, net.get_parameters()),
0.01,
cfg.momentum,
weight_decay=args.weight_decay)
loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True,
reduction='mean',
is_grad=False)
model = Model(net, loss_fn=loss, optimizer=opt, metrics={'acc'})
param_dict = load_checkpoint(args.checkpoint_path)
load_param_into_net(net, param_dict)
net.set_train(False)
dataset = vgg_create_dataset(args.data_path, 1, False)
res = model.eval(dataset)
print("result: ", res)
else:
# network
args.logger.important_info('start create network')
if os.path.isdir(args.pretrained):
models = list(glob.glob(os.path.join(args.pretrained, '*.ckpt')))
print(models)
if args.graph_ckpt:
f = lambda x: -1 * int(
os.path.splitext(os.path.split(x)[-1])[0].split('-')[-1].
split('_')[0])
else:
f = lambda x: -1 * int(
os.path.splitext(os.path.split(x)[-1])[0].split('_')[-1])
args.models = sorted(models, key=f)
else:
args.models = [
args.pretrained,
]
for model in args.models:
if args.dataset == "cifar10":
dataset = vgg_create_dataset(args.data_path,
args.image_size,
args.per_batch_size,
training=False)
else:
dataset = classification_dataset(args.data_path,
args.image_size,
args.per_batch_size)
eval_dataloader = dataset.create_tuple_iterator()
network = vgg16(args.num_classes, args, phase="test")
# pre_trained
load_param_into_net(network, load_checkpoint(model))
network.add_flags_recursive(fp16=True)
img_tot = 0
top1_correct = 0
top5_correct = 0
network.set_train(False)
t_end = time.time()
it = 0
for data, gt_classes in eval_dataloader:
output = network(Tensor(data, mstype.float32))
output = output.asnumpy()
top1_output = np.argmax(output, (-1))
top5_output = np.argsort(output)[:, -5:]
t1_correct = np.equal(top1_output, gt_classes).sum()
top1_correct += t1_correct
top5_correct += get_top5_acc(top5_output, gt_classes)
img_tot += args.per_batch_size
if args.rank == 0 and it == 0:
t_end = time.time()
it = 1
if args.rank == 0:
time_used = time.time() - t_end
fps = (img_tot -
args.per_batch_size) * args.group_size / time_used
args.logger.info(
'Inference Performance: {:.2f} img/sec'.format(fps))
results = [[top1_correct], [top5_correct], [img_tot]]
args.logger.info('before results={}'.format(results))
results = np.array(results)
args.logger.info('after results={}'.format(results))
top1_correct = results[0, 0]
top5_correct = results[1, 0]
img_tot = results[2, 0]
acc1 = 100.0 * top1_correct / img_tot
acc5 = 100.0 * top5_correct / img_tot
args.logger.info('after allreduce eval: top1_correct={}, tot={},'
'acc={:.2f}%(TOP1)'.format(
top1_correct, img_tot, acc1))
args.logger.info('after allreduce eval: top5_correct={}, tot={},'
'acc={:.2f}%(TOP5)'.format(
top5_correct, img_tot, acc5))
args.num_classes = cfg.num_classes
args.pad_mode = cfg.pad_mode
args.padding = cfg.padding
args.has_bias = cfg.has_bias
args.initialize_mode = cfg.initialize_mode
args.batch_norm = cfg.batch_norm
args.has_dropout = cfg.has_dropout
args.image_size = list(map(int, cfg.image_size.split(',')))
context.set_context(mode=context.GRAPH_MODE, device_target=args.device_target)
if args.device_target == "Ascend":
context.set_context(device_id=args.device_id)
if __name__ == '__main__':
if args.dataset == "cifar10":
net = vgg16(num_classes=args.num_classes, args=args)
else:
net = vgg16(args.num_classes, args, phase="test")
net.add_flags_recursive(fp16=True)
load_checkpoint(args.ckpt_file, net=net)
net.set_train(False)
input_data = Tensor(
np.zeros([cfg.batch_size, 3, args.image_size[0], args.image_size[1]]),
mstype.float32)
export(net,
input_data,
file_name=args.file_name,
file_format=args.file_format)
def __init__(self, output_stride=8, bn=False):
super(CRFVGG_prune, self).__init__()
self.output_stride = output_stride
self.pyramid = [2, 0.5]
self.front_end = vgg16(struct='I',
NL="prelu",
output_stride=self.output_stride)
# [24, 22, 'M', 41, 51, 'M', 108, 89, 111, 'M', 184, 276, 228],
self.passing1 = MessagePassing(
branch_n=2,
input_ncs=[51, 22],
)
self.passing2 = MessagePassing(
branch_n=3,
input_ncs=[111, 51, 22],
)
self.passing3 = MessagePassing(
branch_n=3,
input_ncs=[228, 111, 51],
)
self.passing4 = MessagePassing(
branch_n=2,
input_ncs=[228, 111],
)
self.decoder1 = nn.Sequential(
Conv2d_dilated(228,
128,
1,
dilation=1,
same_padding=True,
NL='relu',
bn=bn),
Conv2d_dilated(128,
1,
3,
dilation=1,
same_padding=True,
NL=None,
bn=bn),
)
self.decoder2 = nn.Sequential(
Conv2d_dilated(339,
128,
1,
dilation=1,
same_padding=True,
NL='relu',
bn=bn),
Conv2d_dilated(128,
1,
3,
dilation=1,
same_padding=True,
NL=None,
bn=bn),
)
self.decoder3 = nn.Sequential(
Conv2d_dilated(390,
128,
1,
dilation=1,
same_padding=True,
NL='relu',
bn=bn),
Conv2d_dilated(128,
1,
3,
dilation=1,
same_padding=True,
NL=None,
bn=bn),
)
self.decoder4 = nn.Sequential(
Conv2d_dilated(184,
128,
1,
dilation=1,
same_padding=True,
NL='relu',
bn=bn),
Conv2d_dilated(128,
1,
3,
dilation=1,
same_padding=True,
NL=None,
bn=bn),
)
self.decoder5 = nn.Sequential(
Conv2d_dilated(73,
128,
1,
dilation=1,
same_padding=True,
NL='relu',
bn=bn),
Conv2d_dilated(128,
1,
3,
dilation=1,
same_padding=True,
NL=None,
bn=bn),
)
self.passing_weight1 = Conv2d_dilated(1,
1,
3,
same_padding=True,
NL=None,
bn=bn)
self.passing_weight2 = Conv2d_dilated(1,
1,
3,
same_padding=True,
NL=None,
bn=bn)
self.passing_weight3 = Conv2d_dilated(1,
1,
3,
same_padding=True,
NL=None,
bn=bn)
self.passing_weight4 = Conv2d_dilated(1,
1,
3,
same_padding=True,
NL=None,
bn=bn)
self.prelu = nn.PReLU()
self.relu = nn.ReLU()
def __init__(self, output_stride=8, bn=False):
super(CRFVGG, self).__init__()
self.output_stride = output_stride
self.pyramid = [2, 0.5]
self.front_end = vgg16(struct='F',
NL="prelu",
output_stride=self.output_stride)
self.passing1 = MessagePassing(
branch_n=2,
input_ncs=[128, 64],
)
self.passing2 = MessagePassing(
branch_n=3,
input_ncs=[256, 128, 64],
)
self.passing3 = MessagePassing(branch_n=3, input_ncs=[512, 256, 128])
self.passing4 = MessagePassing(branch_n=2, input_ncs=[512, 256])
self.decoder1 = nn.Sequential(
Conv2d_dilated(512,
128,
1,
dilation=1,
same_padding=True,
NL='relu',
bn=bn),
Conv2d_dilated(128,
1,
3,
dilation=1,
same_padding=True,
NL=None,
bn=bn),
)
self.decoder2 = nn.Sequential(
Conv2d_dilated(768,
128,
1,
dilation=1,
same_padding=True,
NL='relu',
bn=bn),
Conv2d_dilated(128,
1,
3,
dilation=1,
same_padding=True,
NL=None,
bn=bn),
)
self.decoder3 = nn.Sequential(
Conv2d_dilated(896,
128,
1,
dilation=1,
same_padding=True,
NL='relu',
bn=bn),
Conv2d_dilated(128,
1,
3,
dilation=1,
same_padding=True,
NL=None,
bn=bn),
)
self.decoder4 = nn.Sequential(
Conv2d_dilated(448,
128,
1,
dilation=1,
same_padding=True,
NL='relu',
bn=bn),
Conv2d_dilated(128,
1,
3,
dilation=1,
same_padding=True,
NL=None,
bn=bn),
)
self.decoder5 = nn.Sequential(
Conv2d_dilated(192,
128,
1,
dilation=1,
same_padding=True,
NL='relu',
bn=bn),
Conv2d_dilated(128,
1,
3,
dilation=1,
same_padding=True,
NL=None,
bn=bn),
)
self.passing_weight1 = Conv2d_dilated(1,
1,
3,
same_padding=True,
NL=None,
bn=bn)
self.passing_weight2 = Conv2d_dilated(1,
1,
3,
same_padding=True,
NL=None,
bn=bn)
self.passing_weight3 = Conv2d_dilated(1,
1,
3,
same_padding=True,
NL=None,
bn=bn)
self.passing_weight4 = Conv2d_dilated(1,
1,
3,
same_padding=True,
NL=None,
bn=bn)
self.prelu = nn.PReLU()
self.relu = nn.ReLU()
